template-specialization

The C++ standard prohibits friend declarations of partial specializations. (§14.5.3/8): Friend declarations shall not declare partial specializations. [Example: template<class T> class A { }; class X { template <class T> friend class A<T*>; //error }; --end example] Other questions, e.g. this one , have received answers that invoke this prohibition, but I would like to know the rationale. I don't see it and can't find it with my favourite search engine. I can find however that it goes right back to the C++98 standard, so presumably the rationale is quite basic and clear. Can someone explain it

Are multiple class template specialisations valid, when each is distinct only between patterns involving template parameters in non-deduced contexts? A common example of std::void_t uses it to define a trait which reveals whether a type has a member typedef called "type". Here, a single specialisation is employed. This could be extended to identify say whether a type has either a member typedef called "type1", or one called "type2". The C++1z code below compiles with GCC, but not Clang. Is it legal? template <class, class = std::void_t<>> struct has_members : std::false_type {}; template

I have a template, template <typename T> class wrapper , that I would like to specialize based on the existence of typename T::context_type . If typename T::context_type is declared, then the constructors and assignment operator overloads of the wrapper<T> instantiation should accept a mandatory typename T::context_type parameter. Additionally, wrapper<T> objects would store "context" in the member data. If typename T::context_type does not exist, then the constructors and assignment operator overloads of wrapper<T> would take one less parameter and there would be no additional data member. Is

Please consider the following code: #include <iostream> #include <typeinfo> template< typename Type > void func( Type var ) { std::cout << __FUNCTION__ << ": var = " << var << " [" << typeid( var ).name( ) << "]." << std::endl; std::cout << "-> var is SCALAR. Size = " << sizeof( Type ) << std::endl; } #if 1 template< typename Type > void func( Type * var ) { std::cout << __FUNCTION__ << ": var = " << var << " [" << typeid( var ).name( ) << "]." << std::endl; std::cout << "-> var is ARRAY. Size = " << sizeof( Type * ) << std::endl; } #endif int main( ) { typedef char char16[ 16 ]; char16 c16 =

The following template specialization code: template<typename T1, typename T2> void spec1() { } Test case 1: template< typename T1> //compile error void spec1<int>() { } Test case 2: template< typename T2> //compile error void spec1<int>() { } generates the following compilation error: error C2768: 'spec1' : illegal use of explicit template arguments Does anyone know why? Function templates cannot be partially specialised, only fully, i.e. like that: template<> void spec1<char, int>() { } For why function templates cannot be partially specialised, you may want to read this . When you

Suppose I am a user of a Certain Template Library ( CTL ) which defines a template, named, say, Hector template <class T> class Hector {...}; And in its documentation it gives many guarantees about Hector template behavior. But then it also defines a specialization for a certain type Cool template <> class Hector<Cool> {....}; The purpose of the specialization is a more optimized implementation of Hector , but unfortunately because of this optimization many guarantees of Hector are violated. Currently I really don't need the optimization, I'd rather preserve all the guarantees of Hector . Is