• Log in

namespace N{template<class T>// primary templateclass X{/*...*/};template<>// specialization in same namespaceclass X<int>{/*...*/}; template<class T>// primary templateclass Y{/*...*/};template<>// forward declare specialization for doubleclass Y<double>;} template<>// OK: specialization in same namespaceclass N::Y<double>{/*...*/};

class String{}; template<class T>class Array{/*...*/}; template<class T>// primary templatevoid sort(Array<T>& v){/*...*/} void f(Array<String>& v){    sort(v);// implicitly instantiates sort(Array<String>&),}// using the primary template for sort() template<>// ERROR: explicit specialization of sort(Array<String>)void sort<String>(Array<String>& v);// after implicit instantiation

template<class T>// primary templateclass X;template<>// specialization (declared, not defined)class X<int>; X<int>* p;// OK: pointer to incomplete typeX<int> x;// error: object of incomplete type

template<class T>void f(T){/* ... */}template<>inlinevoid f<>(int){/* ... */}// OK, inline template<class T>inline T g(T){/* ... */}template<>int g<>(int){/* ... */}// OK, not inline template<typename>[[noreturn]]void h([[maybe_unused]]int i);template<>void h<int>(int i){// [[noreturn]] has no effect, but [[maybe_unused]] has}

template<class T>class Array{/*...*/}; template<class T>// primary templatevoid sort(Array<T>& v);template<>// specialization for T = intvoid sort(Array<int>&); // no need to write// template<> void sort<int>(Array<int>&);

template<typename T>struct A{struct B{};// member class template<class U>// member class templatestruct C{};}; template<>// specializationstruct A<int>{void f(int);// member function of a specialization};// template<> not used for a member of a specializationvoid A<int>::f(int){/* ... */} template<>// specialization of a member classstruct A<char>::B{void f();};// template<> not used for a member of a specialized member class eithervoid A<char>::B::f(){/* ... */} template<>// specialization of a member class templatetemplate<class U>struct A<char>::C{void f();}; // template<> is used when defining a member of an explicitly// specialized member class template specialized as a class templatetemplate<>template<class U>void A<char>::C<U>::f(){/* ... */}

template<>X Q<int>::x;// declaration of a static membertemplate<>X Q<int>::x();// error: function declarationtemplate<>X Q<int>::x{};// definition of a default-initialized static member

template<typename T>struct A{void f(T);// member, declared in the primary template void h(T){}// member, defined in the primary template template<class X1>// member templatevoid g1(T, X1); template<class X2>// member templatevoid g2(T, X2);}; // specialization of a membertemplate<>void A<int>::f(int); // member specialization OK even if defined in-classtemplate<>void A<int>::h(int){} // out of class member template definitiontemplate<class T>template<class X1>void A<T>::g1(T, X1){} // member template specializationtemplate<>template<class X1>void A<int>::g1(int, X1); // member template specializationtemplate<>template<>void A<int>::g2<char>(int,char);// for X2 = char // same, using template argument deduction (X1 = char)template<>template<>void A<int>::g1(int,char);

template<class T1>struct A{template<class T2>struct B{template<class T3>void mf();};}; template<>struct A<int>; template<>template<>struct A<char>::B<double>; template<>template<>template<>void A<char>::B<char>::mf<double>();

template<class T1>class A{template<class T2>class B{template<class T3>// member templatevoid mf1(T3); void mf2();// non-template member};}; // specializationtemplate<>// for the specialized Atemplate<class X>// for the unspecialized Bclass A<int>::B{template<class T>void mf1(T);}; // specializationtemplate<>// for the specialized Atemplate<>// for the specialized Btemplate<class T>// for the unspecialized mf1void A<int>::B<double>::mf1(T t){} // ERROR: B<double> is specialized and is a member template, so its enclosing A// must be specialized alsotemplate<class Y>template<>void A<Y>::B<double>::mf2(){}