C ++可变参数模板，递归decltype

Question

I know there are already a lot of questions concerning this topic, but so far I found no response that satisfactorily answers the following questions. Given the following code.

#include <map>

template<typename T, typename K>
std::map<T, K> map()
{
    return std::map<T, K>();
}

template<typename T, typename...K>
std::map<T, decltype(map<K...>())> map()
{
    return std::map<T, decltype(map<K...>())>();
}


int main(int argc, char **argv)
{
    std::map<int, int> m2 = map<int, int>();
    std::map<int, std::map<int, int>> m3 = map<int, int, int>();    
    std::map<int, std::map<int, std::map<int, int>>> m4 = map<int, int, int, int>();    // <- Compile Error here
    return 0;
}

A call to

map<int, int, int>() 

shall return an object

std::map<int, std::map<int, int>>

and this works perfectly for up to three template parameters. As mentioned in the code calling the pair function with four template parameters fails and g++ (5.1.0) returns the following error.

main.cpp: In function 'int main(int, char**)':
main.cpp:20:84: error: no matching function for call to 'map()'
      std::map<int, std::map<int, std::map<int, int>>> m4 = map<int, int, int, int>(); // <- Compile Error here
                                                                                    ^
main.cpp:4:20: note: candidate: template<class T, class K> std::map<T, K> map()
     std::map<T, K> map()
                    ^
main.cpp:4:20: note:   template argument deduction/substitution failed:
main.cpp:20:84: error: wrong number of template arguments (4, should be 2)
      std::map<int, std::map<int, std::map<int, int>>> m4 = map<int, int, int, int>(); // <- Compile Error here
                                                                                    ^
main.cpp:10:40: note: candidate: template<class T, class ... K> std::map<T, decltype (map<K ...>())> map()
     std::map<T, decltype(map<K...>())> map()
                                        ^
main.cpp:10:40: note:   template argument deduction/substitution failed:
main.cpp: In substitution of 'template<class T, class ... K> std::map<T, decltype (map<K ...>())> map() [with T = int; K = {int, int, int}]':
main.cpp:20:84:   required from here
main.cpp:10:35: error: no matching function for call to 'map()'
     std::map<T, decltype(map<K...>())> map()
                                   ^
main.cpp:4:20: note: candidate: template<class T, class K> std::map<T, K> map()
     std::map<T, K> map()
                    ^
main.cpp:4:20: note:   template argument deduction/substitution failed:
main.cpp:10:35: error: wrong number of template arguments (3, should be 2)
     std::map<T, decltype(map<K...>())> map()
                                   ^

Therefore my questions are:

• Is this issue g++ related?
• What is the designated way to solve this problem?

Answer 1

Manipulating types with types is usually easier.

template<class K0, class K1, class...Ks>
struct my_map;
template<class K0, class K1, class...Ks>
using my_map_t = typename my_map<K0,K1,Ks...>::type;


template<class K0, class K1>
struct my_map<K0,K1>{using type=std::map<K0, K1>;};

template<class K0, class K1, class K2, class...Ks>
struct my_map<K0, K1, K2, Ks...>{
  using type=std::map<K0, my_map_t<K1, K2, Ks...>>;
};

does what you want.

If you really want it as a function:

template<class K0, class K1, class...Ks>
my_map_t<K0, K1, Ks...> map() { return {}; }

does the trick.

A function is not in context during its own declaration, so your map overload cannot see itself as a valid candidate for map in its own return type.

You can get around this via ADL (both the context of its own declaration, and the ADL at point of function invocation, are considered to find overloads), but it isn't needed.