Why substitution fails in this function template? - c++

Question

I have a set of template functions which receive an index (is an int in the example) and return a value of the given type, I've used SFINAE to separate std::string from arithmetic types:
// 1
template <typename T>
typename std::enable_if<std::is_arithmetic<T>::value, T>::type
t(int) { ... }
// 2
template <typename T>
typename std::enable_if<std::is_same<std::string, T>::value, T>::type
t(int) { ... }
// 3
template <template <typename ...> class T, typename ... P>
T<P ...> t(int) { ... }
Also, there's a function which receives a container and fills it up using the functions above:
template <typename C>
C c(int)
{
C r{};
std::insert_iterator<C> iterator(r, r.begin());
*iterator = t<typename C::value_type>(0);
return r;
}
The goal of t is to tell apart numbers and strings, but if a pair is provided (because it comes from an associative container) then, t should split each pair component in two different t calls with the first and second types.
While deserializing non-associative containers it works but using associative containers compilation fails:
using vi = std::vector<int>;
using mii = std::map<int, int>;
auto o = c<vi>(0); // Deserialize vector
auto p = c<mii>(0); // Deserialize map
The compilation fails at the point of deserializing one element of the container:
*iterator = t<typename C::value_type>(0);
For non-associative containers C::value_type is a type which mets one of the conditions of the first two versions of t, but for associative containers C::value_type is a pair and should fail for versions #1 and #2 of t but not for the #3 version of t function; the issue is that it fails for the three of them:
error: no matching function for call to 't'
*iterator = t<typename C::value_type>(0);
^~~~~~~~~~~~~~~~~~~~~~~~~
note: in instantiation of function template specialization 'c<std::map<int, int>>' requested here
auto p = c<mii>(0);
^
note: candidate template ignored: requirement 'std::is_arithmetic<pair<const int, int> >::value' was not satisfied [with T = std::pair<const int, int>]
t(int) { ... }
^
note: candidate template ignored: requirement 'std::is_same<std::string, pair<const int, int> >::value' was not satisfied [with T = std::pair<const int, int>]
t(int) { ... }
^
note: candidate template ignored: invalid explicitly-specified argument for template parameter 'T'
T<P ...> t(int) { ... }
^
Apparently the compiler is complaining about of the lack of template-template parameters but, if I get rid of SFINAE the error vanishes:
template <typename T>
T
t(int) { return {}; }
template <template <typename ...> class T, typename ... P>
T<P ...> t(int) { return {}; }
template <typename C>
C c(int)
{
C r{};
std::insert_iterator<C> iterator(r, r.begin());
*iterator = t<typename C::value_type>(0);
return r;
}
int main()
{
using vi = std::vector<int>;
using mii = std::map<int, int>;
auto o = c<vi>(0);
auto p = c<mii>(0);
// print 0
for (auto &v : o) std::cout << v << '\n';
// print 00
for (auto &v : p) std::cout << v.first << v.second << '\n';
return 0;
}
It looks like SFINAE is forcing the template-template parameter to be required instead of deduced, why is this happening? How should I solve it?
Code is available in Wandbox 三へ( へ՞ਊ ՞)へ ﾊｯﾊｯ.

Answer 1

It looks like (from your comment and edit), that you want to execute different functions depending on the given template parameters. The easiest way to do this is to use a class, since classes are much more flexible regarding specialization. Here is a small example of what you could do:
// initial declaration (without definition), the second template
// parameter will be used to enable some specializations
template <class T, class = void>
struct deserializer;
// specialization for arithmetic types
template <class T>
struct deserializer<
T, std::enable_if_t<std::is_arithmetic<T>::value>> {
T operator()() const {
}
};
// specialization for std::string
template <>
struct deserializer<std::string> {
std::string operator()() const {
}
};
// specialization for std::pair<U, V>
template <class U, class V>
struct deserializer<std::pair<U, V>> {
std::pair<U, V> operator()() const {
}
};
Then in your function c:
deserializer<typename C::value_type> ds;
*iterator = ds();
You can also add an intermediate generic function if you don't want to create an object of type deserializer each time:
template <class T>
T deserialize() {
return deserializer<T>{}();
}
But I think your goal here is to deserialize multiple objects, so having a functor is not that bad in that case.
Why does the deduction fails in your case?
Actually, there is no deduction here since deduction works with arguments and you are using a return type. The problem here is that this instantiation of t:
t<std::pair<int, int>>
...will never match this declaration of t:
template <template <class... > class, class... >
auto t();
Because you would need:
t<std::pair, int, int>
...to match such template signature. The only template signature that could be matched using t<typename C::value_type> is a signature of the form:
template <class T, /* something */>
...where /* something */ is either a variadic template parameter (class...), or a list of defaulted template parameters (class X = void, int N = 0), or a combination of both.

Answer 2

The problem here is that the original t and the new t have different template parameters:
// original.
template <template <typename ...> class T, typename ... P>
T<P ...> t(int) { ... }
// new.
template <typename C>
C c(int)
Note not only does the original t have (possibly) more than 1 template parameter, but the first parameter is a template template parameter, not a type parameter.
You also seem confused regarding template argument deduction. Template argument deduction deduces the template arguments from the function arguments. All of your functions have a single int parameter, so no deduction is taking place.
In other words, t<typename C::value_type>(0) can't work with the original function, because std::pair<const int, int> is not a valid template template parameter. You would need to write t<std::pair, const int, int>(0).
If your question is how to use SFINAE to accept a "container" (not really, because containers can have non-type template parameters), then this should work:
template<typename T>
struct is_container : std::false_type { };
template<template<typename...> class C, typename... Ts>
struct is_container<C<Ts...>> : std::true_type { };
template <typename T>
typename std::enable_if<is_container<T>::value, T>::type
t(int) { ... }