Template specialization on template member of template class

Question

This is probably only a syntax problem.

So i have this template class :

template <typename String, template<class> class Allocator>
class basic_data_object
{
  template<typename T>
  using array_container = std::vector<T, Allocator<T>>;
};

And another one :

template <typename String, template<class> class Allocator, typename T>
struct get_data_object_value
{
};

Now i want to specialize the second one's T parameter with the first one's inner typedef array_container for any given type.

template <typename String, template<class> class Allocator, typename T>
struct get_data_object_value
<String, Allocator,
typename basic_data_object<String, Allocator>::template array_container<T>>
{
};

But this specialization doesn't seem to be matched when i pass an std::vector as the last parameter.

If i create a temporary hard coded typedef:

typedef basic_data_object<std::string, std::allocator<std::string>> data_object;

And use it for the specialization, everything works :

template <typename String, template<class> class Allocator, typename T>
struct get_data_object_value
<String, Allocator,
data_object::template array_container<T>>
{
};

What did i miss ? :)

---

Alternatively what is the best (smallest / cleanest) way to make this work ?

Answer 1

The answer of Jonathan Wakely gives the reason why your code does not work.

My answer shows you how to solve the problem.

---

In your example, the container type over which you want to specialize is defined outside of basic_data_object thus you can of course use it directly in your specialization:

template <typename S, template<class> class A, typename T>
struct get_data_object_value<S,A,std::vector<T,A>>
{ };

This definitely conforms with the standard and works with all compilers.

---

In the case where the type is defined in basic_data_object, you can move it out of the class.

Example: Instead of

template<typename S, template<class> class A>
struct a_data_object
{
    template<typename T>
    struct a_container
    { };
};

write this:

template<typename S, template<class> class A, typename T>
// you can perhaps drop S and A if not needed...
struct a_container
{ };

template<typename S, template<class> class A, typename T>
struct a_data_object
{
    // use a_container<S,A,T>
};

Now you can specialize with:

template <typename S, template<class> class A, typename T>
struct get_data_object_value<S,A,a_container<S,A,T>>
{ };

---

Note: The next "solution" is apparently a bug with GCC 4.8.1.

If the container is only defined in an enclosing template and can not be moved out you can do this:

1. Get the container type out of basic_data_object:

   template<typename S, template<class> class A, typename T>
   using bdo_container = basic_data_object<S,A>::array_container<T>;
   

2. Write a specialization for this type:

   template <typename S, template<class> class A, typename T>
   struct get_data_object_value<S,A,bdo_container<S,A,T>>
   { };
   

Answer 2

Alternatively what is the best (smallest / cleanest) way to make this work?

Arguably, it is:

• Write a SFINAE trait template Tr<String,Allocator,T> that determines whether T is the same as basic_data_object<String,Allocator>::array_container<T::E> for some type E - if such there be - that is T::value_type.
• Provide template get_data_object_value with a 4th parameter defaulting to Tr<String,Allocator,T>::value
• Write partial specializations of get_data_object_value instantiating that 4th parameter as true, false respectively.

Here is a demo program:

#include <type_traits>
#include <vector>
#include <iostream>

template <typename String, template<class> class Allocator>
struct basic_data_object
{
    template<typename T>
    using array_container = std::vector<T, Allocator<T>>;
};

template<typename T, typename String, template<class> class Allocator>
struct is_basic_data_object_array_container
/* 
    A trait template that has a `static const bool` member `value` equal to
    `true` if and only if parameter type `T` is a container type
    with `value_type E` s.t. 
        `T` = `basic_data_object<String,Allocator>::array_container<T::E>`
*/ 
{
    template<typename A> 
    static constexpr bool
    test(std::is_same<
            A,
            typename basic_data_object<String,Allocator>::template
                array_container<typename A::value_type>
            > *) {
        return std::is_same<
            A,
            typename basic_data_object<String,Allocator>::template
                array_container<typename A::value_type>
            >::value;
    }
    template<typename A> 
    static constexpr bool test(...) {
        return false;
    }
    static const bool value = test<T>(nullptr);
};


template <
    typename String, 
    template<class> class Allocator,
    typename T,
    bool Select = 
        is_basic_data_object_array_container<T,String,Allocator>::value
>           
struct get_data_object_value;


template <
    typename String, 
    template<class> class Allocator,
    typename T
>           
struct get_data_object_value<
    String,
    Allocator,
    T,
    false
>
{
    static void demo() {
        std::cout << "Is NOT a basic_data_object array_container" << std::endl;
    }
};

template <
    typename String, 
    template<class> class Allocator,
    typename T>
struct get_data_object_value<
    String, 
    Allocator,
    T,
    true
>
{
    static void demo() {
        std::cout << "Is a basic_data_object array_container" << std::endl;
    }
};

#include <list>
#include <memory>

using namespace std;

int main(int argc, char **argv)
{
    get_data_object_value<string,allocator,std::vector<short>>::demo();
    get_data_object_value<string,allocator,std::list<short>>::demo();
    get_data_object_value<string,allocator,short>::demo();
    return 0;
}

Built with gcc 4.8.2, clang 3.4. Output:

Is a basic_data_object array_container
Is NOT a basic_data_object array_container
Is NOT a basic_data_object array_container

VC++ 2013 will not compile this for lack of constexpr support. To accommodate that compiler the following less natural implementation of the trait may be used:

template<typename T, typename String, template<class> class Allocator>
struct is_basic_data_object_array_container
{
    template<typename A>
    static
    auto test(
        std::is_same<
            A,
            typename basic_data_object<String, Allocator>::template
                array_container<typename A::value_type>
            > *
        ) ->
            std::integral_constant<
                bool,
                std::is_same<
                    A,
                    typename basic_data_object<String, Allocator>::template
                        array_container<typename A::value_type>
                >::value
            >{}
    template<typename A>
    static std::false_type test(...);
    using type = decltype(test<T>(nullptr));
    static const bool value = type::value;
};

Answer 3

For some reason, the problem seems to stem from the double level of templates. I'll leave you check the 3 test cases below, they are simple:

1. Remove the template arguments of First: works as expected
2. Make First a template, but the inner type a plain one: works as expected
3. Make both First and the inner type templates: compiles but the output is unexpected

Note: the template template parameter Allocator is useless to reproduce the issue, so I left it out.

Note: both GCC (ideone's version, 4.8.1 I believe) and Clang (Coliru version, 3.4) compile the code, and yet produce the same baffling result

From the 3 above examples, I deduce:

• that this is NOT a non-deducible context issue; otherwise why would (2) work ?
• that this is NOT an alias issue; otherwise why would (1) work ?

And therefore that either the problem is much hairier than the current hints would make us believe OR that both gcc and Clang have a bug.

EDIT: Thanks to Jonathan Wakely who patiently educated me enough that I could finally understand both the Standard wording related to this case and how it applied. I will now attempt to explain this (again) in my own words. Please refer to Jonathan's answer for the exact Standard quotes (it all sits in [temp.deduct.type])

• When deducing template parameters (P_i), whether for functions or classes, the deduction is done independently for each and every argument.
• Each argument need provide zero or one candidate C_i for each parameter; if an argument would provide more than one candidate, it provides none instead.
• Thus, each argument produces a dictionary D_n: P_i -> C_i which maps a subset (possibly empty) of the template parameters to be deduced to their candidate.
• The dictionaries D_n are merged together, parameter by parameter:
  • if only one dictionary has a candidate for a given parameter, then this parameter is accepted, with this candidate
  • if several dictionaries have the same candidate for a given parameter, then this parameter is accepted, with this candidate
  • if several dictionaries have different incompatible (*) candidates for a given parameter, then this parameter is rejected
• If the final dictionary is complete (maps each and every parameter to an accepted candidate) then deduction succeeds, otherwise it fails

(*) there seems to be a possibility for finding a "common type" from the available candidates... it is of no consequence here though.

Now we can apply this to the previous examples:

1) A single template parameter T exists:

• pattern matching std::vector<int> against typename First::template ArrayType<T> (which is std::vector<T>), we get D₀: { T -> int }
• merging the only dictionary yields { T -> int }, thus T is deduced to be int

2) A single template parameter String exists

• pattern matching std::vector<int> against String, we get D₀: { String -> std::vector<int> }
• pattern matching std::vector<int> against typename First<String>::ArrayType we hit a non-deducible context (many values of String could fit), we get D₁: {}
• merging the two dictionaries yields { String -> std::vector<int> }, thus String is deduced to be std::vector<int>

3) Two template parameters String and T exist

• pattern matching std::vector<char> against String, we get D₀: { String -> std::vector<char> }
• pattern matching std::vector<int> against typename First<String>::template ArrayType<T> we hit a non-deducible context, we get D₁: {}
• merging the two dictionaries yields { String -> std::vector<char> }, which is an incomplete dictionary (T is absent) deduction fails

I must admit I had not considered yet that the arguments were resolved independently from one another, and therefore than in this last case, when computing D₁ the compiler could not take advantage of the fact that D₀ had already deduced a value for String. Why it is done in this fashion, however, is probably a full question of its own.

---

Without the outer template, it works, as in it prints "Specialized":

#include <iostream>
#include <vector>

struct First {
    template <typename T>
    using ArrayType = std::vector<T>;
};

template <typename T>
struct Second {
    void go() { std::cout << "General\n"; }
};

template <typename T>
struct Second < typename First::template ArrayType<T> > {
    void go() { std::cout << "Specialized\n"; }
};

int main() {
    Second < std::vector<int> > second;
    second.go();
    return 0;
}

Without the inner template, it works, as in it prints "Specialized":

#include <iostream>
#include <vector>

template <typename String>
struct First {
    using ArrayType = std::vector<int>;
};

template <typename String, typename T>
struct Second {
    void go() { std::cout << "General\n"; }
};

template <typename String>
struct Second < String, typename First<String>::ArrayType > {
    void go() { std::cout << "Specialized\n"; }
};


int main() {
    Second < std::vector<int>, std::vector<int> > second;
    second.go();
    return 0;
}

With both, it fails, as in it prints "General":

#include <iostream>
#include <vector>

template <typename String>
struct First {
    template <typename T>
    using ArrayType = std::vector<T>;
};

template <typename String, typename T>
struct Second {
    void go() { std::cout << "General\n"; }
};

template <typename String, typename T>
struct Second < String, typename First<String>::template ArrayType<T> > {
    void go() { std::cout << "Specialized\n"; }
};

int main() {
    Second < std::vector<char>, std::vector<int> > second;
    second.go();
    return 0;
}

Answer 4

Edit: This answer only works because of a bug in GCC 4.8.1

---

Your code works as expected if you drop the keyword template in your specialization:

template <typename String, template<class> class Allocator, typename T>
struct get_data_object_value
{
    void foo() { std::cout << "general" << std::endl; }
};

template <typename String, template<class> class Allocator, typename T>
struct get_data_object_value
<String, Allocator,
typename basic_data_object<String, Allocator>::array_container<T>>
//                                         ^^^^^^ no template!
{
    void foo() { std::cout << "special" << std::endl; }
};

Example tested with GCC 4.8.1:

int main()  {
    get_data_object_value<std::string,std::allocator,std::vector<int>> obj;
    obj.foo(); // prints "special"
}

Answer 5

The C++ standard says, in [temp.class.spec.match] paragraph 2:

A partial specialization matches a given actual template argument list if the template arguments of the partial specialization can be deduced from the actual template argument list (14.8.2).

14.8.2 is [temp.arg.deduct] i.e. the clause describing template argument deduction for function templates.

If you modify your code to use a similar function template and attempt to call it, you will see that the arguments cannot be deduced:

template <typename String, typename T>
void deduction_test(String,
                    typename basic_data_object<String, std::allocator>::template array_container<T>)
{ }

int main()
{
  deduction_test(std::string{}, std::vector<int, std::allocator<int>>{});
}

(I removed the Allocator parameter, since there's no way to pass a template template parameter as a function argument and in the basic_data_object type it's a non-deduced context, I don't believe it affects the result.)

Both clang and GCC say they cannot deduce T here. Therefore the partial specialization will not match the same types used as template arguments.

So I haven't really answered the question yet, only clarified that the reason is in the rules of template argument deduction, and shown an equivalence with deduction in function templates.

In 14.8.2.5 [temp.deduct.type] we get a list of non-deduced contexts that prevent deduction, and the following rule in paragraph 6:

When a type name is specified in a way that includes a non-deduced context, all of the types that comprise that type name are also non-deduced.

Since basic_data_object<String, Allocator> is in a non-deduced context (it is a nested-name-specifier, i.e. appears before ::) that means the type T is also non-deduced, which is exactly what Clang and GCC tell us.

---

With your temporary hardcoded typedef there is no non-deduced context, and so deduction for T succeeds using the deduction_test function template:

template <typename String, typename T>
void deduction_test(String,
                    typename data_object::template array_container<T>)
{ }

int main()
{
  deduction_test(std::string{}, std::vector<int, std::allocator<int>>{}); // OK
}

And so, correspondingly, your class template partial specialization can be matched when it uses that type.

---

I don't see a way to make it work without changing the definition of get_data_object_value, but if that's an option you can remove the need to deduce the array_container type and instead use a trait to detect whether a type is the type you want, and specialize on the result of the trait:

#include <string>
#include <vector>
#include <iostream>

template <typename String, template<class> class Allocator>
class basic_data_object
{
public:
  template<typename T>
  using array_container = std::vector<T, Allocator<T>>;

  template<typename T>
    struct is_ac : std::false_type { };

  template<typename T>
    struct is_ac<array_container<T>> : std::true_type { };
};

template <typename String, template<class> class Allocator, typename T, bool = basic_data_object<String, Allocator>::template is_ac<T>::value>
struct get_data_object_value
{
};

template <typename String, template<class> class Allocator, typename T>
struct get_data_object_value<String, Allocator, T, true>
{
  void f() { }
};

int main()
{
  get_data_object_value<std::string,std::allocator,std::vector<short>> obj;
  obj.f();
}

This doesn't really scale if you wanted several class template partial specializations, as you would need to add several bool template parameters with default arguments.