Using Partial Specialization in C++11

Question

I have the following code: ``` template struct test {T j = I;}; template struct test {int j = J;}; int main() { test<55> jj; std::cout << jj.j << std::endl; return(1); } ``` The compiler (clang) complains only about the line `test<55> jj` I don't understand why? Is there a work around? And if it complains about that line, why doesn't it complain about the second template definition? Thanks in advance. The message is: ``` enable.cpp:17:8: error: template argument for template type parameter must be a type test<55> jj; ^~ enable.cpp:9:16: note: template parameter is declared here template struct test ```

Accepted Answer

The problem is that you haven't understood how selecting a class template specialization works. Your specialization: ``` template struct test {int j = J;}; ``` does not create a template for which you only have to pass in a single int template parameter. ``` test<55> jj; // doesn't work because there's no template struct test ``` Instead what it does is create a specialization of `template struct test` which will be used when the template arguments to `template struct test` match the specialization, i.e. `test`. ``` test jj; // uses the specialization template struct test ``` Here's the key quote from the standard: In a type name that refers to a class template specialization, (e.g., `A`) the argument list shall match the template parameter list of the primary template. The template arguments of a specialization are deduced from the arguments of the primary template. [emphasis added] — 14.5.5.1 [temp.class.spec.match] p4 You seem to be attempting to set `int` as a default type for `T` while simultaneously setting an independent default value for `I`. I think your intent is to be able to specify a type and a value, specify only a type and get 44 as a default value, or specify only a value and get int as a default type. Unfortunately I don't know of a way to specify independent defaults like that. You can specify defaults (`template struct test`) but getting the default type will also require accepting the default value. However if you're willing to use a second name then you can do: ``` template using test_int = test; ``` This creates a template alias such that you only have to specify a value: ``` test_int<55> jj; ``` And this will end up using whatever specialization `test` happens to resolve to whether there's an explicit specialization or the compiler generates an implicit one.

Using Partial Specialization in C++11

Solution

Problem