Insufficient template specialization

Question

I came across an interesting point that I could not explain or find an explanation. Consider the following template definition (compiled with mingw g ++ 4.6.2):

template <typename T, typename S> class Foo { public: void f(){} void g(){} }; 

If we want, we can fully specialize any member function:

 template <> void Foo<char,int>::f() {} 

But partial specialization fails with the error "invalid use of incomplete type" Foo <...> '":

 template <typename T, typename S> void Foo<T,S*>::f() { } template <typename T> void Foo<T,int>::f() { } 

And I can’t understand why. Is this a conscious design decision taken to avoid some problem that I cannot foresee? Is this supervision?

Thanks in advance.

Answer 1

The concept of partial specialization exists only for class templates (described in §14.5.5) and member templates (i.e. members of the template class, which themselves are template functions described in §14.5.5.3 / 2). It does not exist for ordinary members of class templates and does not exist for function templates - simply because it is not described by the standard.

Now you can argue that by defining a partial specialization of a member function, for example

 template <typename T> void Foo<T,int>::f() { } 

you implicitly define a partial specialization of a class template: Foo<T,int> . This, however, is expressly excluded by the standard:

(§14.5.5 / 2). Each private specialization of a class template is a separate template, and definitions must be specified for members of the partial specialization of the template (14.5.5.3).

(§14.5.5.3 / 1) [...] Members of the partial specialization of the template template are not associated with members of the primary template. The members of the partial specialization of the template class must be defined, which are used in a way that requires definition; primary template member definitions are never used as definitions for members of a partial specialization of a template template. [...]

The latter implies that it is impossible to uniquely determine a partial specialization by simply defining one of its members: the very existence of this member will not follow from the definition of the primary template, therefore its definition is equivalent to defining a member function that has not been declared, and this is unacceptable (even with non-templates).

On the other hand, the concept of an explicit specialization function (or full specialization, as you call it) exists for member functions of class templates. It is explicitly described by the Standard:

(§14.7.3 / 1) The explicit specialization of any of the following:
[...]
- member function of the class template
[...]
may be declared by the declaration entered by the template <>; [...]

§14.7.3 / 14 describes the details:

(§14.7.3 / 14) A member or member template of a class template may be explicitly specialized for a given implicit instance of a class template, even if the element or member template is defined in the class template definition. [...]

Therefore, for explicit member specializations, an instance of the rest of the template template works implicitly — it is inferred from the definition of the primary template or any partial specializations, if defined.

Answer 2

I tried to find a short quote from the standard, but I do not think it is. The fact is that there is no such partial specialization of the template function (or, for that matter, the template alias). Class templates may have partial specialization.

Forget about patterns in a second. In C ++, there is a big difference between class names and function names. There can only be one class definition within a given area. (You may have different declarations, but they all refer to One True Class.) Thus, the name really identifies the class.

The name of the function, on the other hand, is a kind of group identifier. You can define any number of functions within an area with exactly the same name. When you use a function name to call a function, the compiler must figure out what function you really had in mind, considering the various possibilities and selecting the signature of each of them with the arguments provided. There is no connection between the various functions that share the name; they are completely separate entities.

So it doesn’t matter. You all knew that, huh? But now back to the templates.

The name of the template class is still unique. Although you can define partial specialization, you need to explicitly specialize the same template class. This mechanism looks externally like the above-mentioned algorithm for resolving function names, but there are significant differences - one of them is that, unlike function prototypes, you cannot have two class templates in the same area with different types of template parameters.

Sampled functions, on the other hand, do not need to define unique names. Templating does not replace the normal function overload mechanism. Therefore, when the compiler tries to find out what the name of the function means, it must take into account all the template and non-template declarations for this function name, allow the template for a set of template parameter assignments (if possible), and then after that have a list of possible function objects, select the best with normal overload resolution.

This is a completely different algorithm from the template resolution of the template template. Instead of just comparing the list of provided template arguments with the list of parameters of the declared template, how it resolves class templates, it should take every template function that could match (for example, it has at least the right number of parameters); derive template parameters by combining the provided arguments with the template; and then add the permit specialization to the overload set for the next round of overload resolution.

I believe that partial resolution of specialization could also be added to this process, but the interaction between partial specialization and function overloading attacked me, which can lead to pseudo-magic behavior. In this case, this was not necessary, and therefore, such a mechanism does not exist. (You can completely specialize the function template. Full specialization means that there are no template arguments to output, so this is not a problem.)

So to scoop: you cannot partially specialize a template function, but there is nothing that will prevent you from providing any number of function templates with the same name. All of them will be considered when resolving overload, and the best, as usual, will win.

Usually this is really enough for your overloads. You should think of template functions the same way you think of normal functions: come up with a way to choose the one you want based on the arguments provided. If you feel that you really need to provide template parameters in the function call, instead of displaying them, just make function a (possibly static) a member of the template template and put the template arguments to the class.

Hope this helps ...

Answer 3

I think the difference is that when you do the first (valid) explicit specialization f :

 template <> void Foo<char,int>::f() {} 

You are doing an implicit instance of Foo<char,int> . But when you try partial specialization with:

 template <typename T> void Foo<T,int>::f() { } 

Before performing the specialization, the compiler will have to execute the implicit Foo<T,int> , but this cannot be done due to T And he fails.

You can check this with the following code:

 template <typename T, typename S> class Foo { public: void f(){} void g(){} }; template <> void Foo<char,int>::f() //line 11 {} template <> class Foo<char,int> //line 15 {}; 

With g++ it gives errors:

 test.cpp:15:7: error: specialization of 'Foo<char, int>' after instantiation test.cpp:15:7: error: redefinition of 'class Foo<char, int>' test.cpp:2:7: error: previous definition of 'class Foo<char, int>' 

With clang++ little clearer:

 test.cpp:15:7: error: explicit specialization of 'Foo<char, int>' after instantiation class Foo<char,int> ^~~~~~~~~~~~~ test.cpp:11:6: note: implicit instantiation first required here void Foo<char,int>::f() ^