A function template defines a family of functions.

[edit]Syntax

[edit]Explanation

void f1(auto);// same as template<class T> void f1(T)void f2(C1auto);// same as template<C1 T> void f2(T), if C1 is a conceptvoid f3(C2auto...);// same as template<C2... Ts> void f3(Ts...), if C2 is a conceptvoid f4(const C3auto*, C4auto&);// same as template<C3 T, C4 U> void f4(const T*, U&); template<class T, C U>void g(T x, U y, Cauto z);// same as template<class T, C U, C W> void g(T x, U y, W z);

template<>void f4<int>(constint*,constdouble&);// specialization of f4<int, const double>

[edit]Function template signature

Every function template has a signature.

The signature of atemplate-head is thetemplate parameter list, excluding template parameter names anddefault arguments, and requires-clause (if any)(since C++20).

The signature of a function template contains the name, parameter-type-list, return type, trailing requires-clause (if any)(since C++20), and signature of thetemplate-head. Except for the following cases, its signature also contains the enclosing namespace.

If the function template is a class member, its signature contains the class of which the function is a member instead of the enclosing namespace. Its signature also containsthe trailing requires-clause (if any)(since C++20), ref-qualifier (if any), and(since C++11)cv-qualifiers (if any).

[edit]Function template instantiation

A function template by itself is not a type, or a function. No code is generated from a source file that contains only template definitions. In order for any code to appear, a template must be instantiated: the template arguments must be determined so that the compiler can generate an actual function (or class, from a class template).

[edit]Explicit instantiation

An explicit instantiation definition forces instantiation of the function or member function they refer to. It may appear in the program anywhere after the template definition, and for a given argument-list, is only allowed to appear once in the program, no diagnostic required.

A trailing template-argument can be left unspecified in an explicit instantiation of a function template specialization or of a member function template specialization if it can bededuced from the function parameter:

template<typename T>void f(T s){std::cout<< s<<'\n';} templatevoid f<double>(double);// instantiates f<double>(double)templatevoid f<>(char);// instantiates f<char>(char), template argument deducedtemplatevoid f(int);// instantiates f<int>(int), template argument deduced

Explicit instantiation of a function template or of a member function of a class template cannot useinline orconstexpr. If the declaration of the explicit instantiation names an implicitly-declared special member function, the program is ill-formed.

Explicit instantiation of aconstructor cannot use a template parameter list (syntax(1)), which is also never necessary because they can be deduced (syntax(2)).

Explicit instantiation declarations do not suppress the implicit instantiation ofinline functions,auto-declarations, references, and class template specializations. (thus, when the inline function that is a subject of explicit instantiation declaration is ODR-used, it is implicitly instantiated for inlining, but its out-of-line copy is not generated in this translation unit)

Explicit instantiation definition of a function template withdefault arguments is not a use of the arguments, and does not attempt to initialize them:

char* p=0; template<class T>T g(T x=&p){return x;} templateint g<int>(int);// OK even though &p isn’t an int.

[edit]Implicit instantiation

When code refers to a function in context that requiresthe function definition to exist, or if the existence of the definition affects the semantics of the program(since C++11), and this particular function has not been explicitly instantiated, implicit instantiation occurs. The list of template arguments does not have to be supplied if it can bededuced from context.

#include <iostream> template<typename T>void f(T s){std::cout<< s<<'\n';} int main(){    f<double>(1);// instantiates and calls f<double>(double)    f<>('a');// instantiates and calls f<char>(char)    f(7);// instantiates and calls f<int>(int)void(*pf)(std::string)= f;// instantiates f<string>(string)    pf("∇");// calls f<string>(string)}

template<typename T>constexprint f(){return T::value;} template<bool B,typename T>void g(decltype(B? f<T>():0));template<bool B,typename T>void g(...); template<bool B,typename T>void h(decltype(int{B? f<T>():0}));template<bool B,typename T>void h(...); void x(){    g<false,int>(0);// OK: B ? f<T>() : 0 is not potentially constant evaluated    h<false,int>(0);// error: instantiates f<int> even though B evaluates to false// and list-initialization of int from int cannot be narrowing}

Note: omitting<> entirely allowsoverload resolution to examine both template and non-template overloads.

[edit]Template argument deduction

In order to instantiate a function template, every template argument must be known, but not every template argument has to be specified. When possible, the compiler will deduce the missing template arguments from the function arguments. This occurs when a function call is attempted and when an address of a function template is taken.

template<typename To,typename From>To convert(From f); void g(double d){int i= convert<int>(d);// calls convert<int,double>(double)char c= convert<char>(d);// calls convert<char,double>(double)int(*ptr)(float)= convert;// instantiates convert<int, float>(float)}

This mechanism makes it possible to use template operators, since there is no syntax to specify template arguments for an operator other than by re-writing it as a function call expression.

#include <iostream> int main(){std::cout<<"Hello, world"<<std::endl;// operator<< is looked up via ADL as std::operator<<,// then deduced to operator<<<char, std::char_traits<char>> both times// std::endl is deduced to &std::endl<char, std::char_traits<char>>}

Template argument deduction takes place after the function templatename lookup (which may involveargument-dependent lookup) and beforeoverload resolution.

Seetemplate argument deduction for details.

[edit]Explicit template arguments

Template arguments of a function template may be obtained from

• template argument deduction
• default template arguments
• specified explicitly, which can be done in the following contexts:

• in a function call expression
• when an address of a function is taken
• when a reference to function is initialized
• when a pointer to member function is formed
• in an explicit specialization
• in an explicit instantiation
• in a friend declaration

There is no way to explicitly specify template arguments tooverloaded operators,conversion functions, and constructors, because they are called without the use of the function name.

The specified template arguments must match the template parameters in kind (i.e., type for type, constant for constant, and template for template). There cannot be more arguments than there are parameters (unless one parameter is a parameter pack, in which case there has to be an argument for each non-pack parameter)(since C++11).

The specified constant arguments must either match the types of the corresponding constant template parameters, or beconvertible to them.

The function parameters that do not participate in template argument deduction (e.g. if the corresponding template arguments are explicitly specified) are subject to implicit conversions to the type of the corresponding function parameter (as in the usualoverload resolution).

template<class...Types>void f(Types...values); void g(){    f<int*,float*>(0,0,0);// Types = {int*, float*, int}}

[edit]Template argument substitution

When all template arguments have been specified, deduced or obtained from default template arguments, every use of a template parameter in the function parameter list is replaced with the corresponding template arguments.

Substitution failure (that is, failure to replace template parameters with the deduced or provided template arguments) of a function template removes the function template from theoverload set. This allows a number of ways to manipulate overload sets using template metaprogramming: seeSFINAE for details.

After substitution, all function parameters of array and function type are adjusted to pointers and all top-level cv-qualifiers are dropped from function parameters (as in a regularfunction declaration).

The removal of the top-level cv-qualifiers does not affect the type of the parameter as it appears within the function:

template<class T>void f(T t); template<class X>void g(const X x); template<class Z>void h(Z z, Z* zp); // two different functions with the same type, but// within the function, t has different cv qualificationsf<int>(1);// function type is void(int), t is intf<constint>(1);// function type is void(int), t is const int // two different functions with the same type and the same x// (pointers to these two functions are not equal,//  and function-local statics would have different addresses)g<int>(1);// function type is void(int), x is const intg<constint>(1);// function type is void(int), x is const int // only top-level cv-qualifiers are dropped:h<constint>(1,NULL);// function type is void(int, const int*)// z is const int, zp is const int*

[edit]Function template overloading

Function templates and non-template functions may be overloaded.

A non-template function is always distinct from a template specialization with the same type. Specializations of different function templates are always distinct from each other even if they have the same type. Two function templates with the same return type and the same parameter list are distinct and can be distinguished by their explicit template argument list.

When an expression that uses type or constant template parameters appears in the function parameter list or in the return type, that expression remains a part of the function template signature for the purpose of overloading:

template<int I,int J>A<I+J> f(A<I>, A<J>);// overload #1 template<int K,int L>A<K+L> f(A<K>, A<L>);// same as #1 template<int I,int J>A<I-J> f(A<I>, A<J>);// overload #2

Two expressions involving template parameters are calledequivalent if two function definitions that contain these expressions would be the same underODR, that is, the two expressions contain the same sequence of tokens whose names are resolved to same entities via name lookup, except template parameters may be differently named.Twolambda expressions are never equivalent.(since C++20)

template<int I,int J>void f(A<I+J>);// template overload #1 template<int K,int L>void f(A<K+L>);// equivalent to #1

When determining if twodependent expressions are equivalent, only the dependent names involved are considered, not the results of name lookup. If multiple declarations of the same template differ in the result of name lookup, the first such declaration is used:

template<class T>decltype(g(T())) h();// decltype(g(T())) is a dependent type int g(int); template<class T>decltype(g(T())) h(){// redeclaration of h() uses earlier lookupreturn g(T());// although the lookup here does find g(int)} int i= h<int>();// template argument substitution fails; g(int)// was not in scope at the first declaration of h()

Two function templates are consideredequivalent if

• they are declared in the same scope
• they have the same name
• they haveequivalent template parameter lists, meaning the lists are of the same length, and for each corresponding parameter pair, all of the following is true:

• the two parameters are of the same kind (both types, both constants, or both templates)

• if constant, their types are equivalent,
• if template, their template parameters are equivalent,

• the expressions involving template parameters in their return types and parameter lists areequivalent

Twopotentially-evaluated(since C++20) expressions involving template parameters are calledfunctionally equivalent if they are notequivalent, but for any given set of template arguments, the evaluation of the two expressions results in the same value.

Two function templates are consideredfunctionally equivalent if they areequivalent, except that one or more expressions that involve template parameters in their return types and parameter lists arefunctionally equivalent.

If a program contains declarations of function templates that arefunctionally equivalent but notequivalent, the program is ill-formed; no diagnostic is required.

// equivalenttemplate<int I>void f(A<I>, A<I+10>);// overload #1template<int I>void f(A<I>, A<I+10>);// redeclaration of overload #1 // not equivalenttemplate<int I>void f(A<I>, A<I+10>);// overload #1template<int I>void f(A<I>, A<I+11>);// overload #2 // functionally-equivalent but not equivalent// This program is ill-formed, no diagnostic requiredtemplate<int I>void f(A<I>, A<I+10>);// overload #1template<int I>void f(A<I>, A<I+1+2+3+4>);// functionally equivalent

When the same function template specialization matches more than one overloaded function template (this often results fromtemplate argument deduction),partial ordering of overloaded function templates is performed to select the best match.

Specifically, partial ordering takes place in the following situations:

template<class X>void f(X a);template<class X>void f(X* a); int* p;f(p);

template<class X>void f(X a);template<class X>void f(X* a); void(*p)(int*)=&f;

template<class X>void f(X a);// first template ftemplate<class X>void f(X* a);// second template ftemplate<>void f<>(int*a){}// explicit specialization // template argument deduction comes up with two candidates:// f<int*>(int*) and f<int>(int*)// partial ordering selects f<int>(int*) as more specialized

Informally "A is more specialized than B" means "A accepts fewer types than B".

Formally, to determine which of any two function templates is more specialized, the partial ordering process first transforms one of the two templates as follows:

• For each type, constant, and template parameter,including parameter packs,(since C++11) a unique fictitious type, value, or template is generated and substituted into function type of the template
• If only one of the two function templates being compared is a member function, and that function template is a non-static member of some classA, a new first parameter is inserted into its parameter list. Givencv as the cv-qualifiers of the function template andref as the ref-qualifier of the function template(since C++11), the new parameter type iscvA& unlessref is&&, orref is not present and the first parameter of the other template has rvalue reference type, in this case the type iscvA&&(since C++11). This helps the ordering of operators, which are looked up both as member and as non-member functions:

struct A{}; template<class T>struct B{template<class R>int operator*(R&);// #1}; template<class T,class R>int operator*(T&, R&);// #2 int main(){    A a;    B<A> b;    b* a;// template argument deduction for int B<A>::operator*(R&) gives R=A//                             for int operator*(T&, R&), T=B<A>, R=A // For the purpose of partial ordering, the member template B<A>::operator*// is transformed into template<class R> int operator*(B<A>&, R&); // partial ordering between//     int operator*(   T&, R&)  T=B<A>, R=A// and int operator*(B<A>&, R&)  R=A// selects int operator*(B<A>&, A&) as more specialized}

After one of the two templates was transformed as described above,template argument deduction is executed using the transformed template as the argument template and the original template type of the other template as the parameter template. The process is then repeated using the second template (after transformations) as the argument and the first template in its original form as the parameter.

The types used to determine the order depend on the context:

• in the context of a function call, the types are those function parameter types for which the function call has arguments (default function arguments, parameter packs,(since C++11) and ellipsis parameters are not considered -- see examples below)
• in the context of a call to a user-defined conversion function, the return types of the conversion function templates are used
• in other contexts, the function template type is used

Each type from the list above from the parameter template is deduced. Before deduction begins, each parameterP of the parameter template and the corresponding argumentA of the argument template is adjusted as follows:

• If bothP andA are reference types before, determine which is more cv-qualified (in all other cases, cv-qualifications are ignored for partial ordering purposes)
• IfP is a reference type, it is replaced by the type referred to
• IfA is a reference type, it is replaced by the type referred to
• IfP is cv-qualified,P is replaced with cv-unqualified version of itself
• IfA is cv-qualified,A is replaced with cv-unqualified version of itself

After these adjustments, deduction ofP fromA is done followingtemplate argument deduction from a type.

If the argumentA of the transformed template-1 can be used to deduce the corresponding parameterP of template-2, but not vice versa, then thisA is more specialized thanP with regards to the type(s) that are deduced by thisP/A pair.

If deduction succeeds in both directions, and the originalP andA were reference types, then additional tests are made:

• IfA was lvalue reference andP was rvalue reference,A is considered to be more specialized thanP
• IfA was more cv-qualified thanP,A is considered to be more specialized thanP

In all other cases, neither template is more specialized than the other with regards to the type(s) deduced by thisP/A pair.

After considering everyP andA in both directions, if, for each type that was considered,

• template-1 is at least as specialized as template-2 for all types
• template-1 is more specialized than template-2 for some types
• template-2 is not more specialized than template-1 for any types OR is not at least as specialized for any types

Then template-1 is more specialized than template-2. If the conditions above are true after switching template order, then template-2 is more specialized than template-1. Otherwise, neither template is more specialized than the other.

If, after considering all pairs of overloaded templates, there is one that is unambiguously more specialized than all others, that template's specialization is selected, otherwise compilation fails.

In the following examples, the fictitious arguments will be called U1, U2:

template<class T>void f(T);// template #1template<class T>void f(T*);// template #2template<class T>void f(const T*);// template #3 void m(){constint* p;    f(p);// overload resolution picks: #1: void f(T ) [T = const int *]//                            #2: void f(T*) [T = const int]//                            #3: void f(const T *) [T = int] // partial ordering: // #1 from transformed #2: void(T) from void(U1*): P=T A=U1*: deduction ok: T=U1*// #2 from transformed #1: void(T*) from void(U1): P=T* A=U1: deduction fails// #2 is more specialized than #1 with regards to T // #1 from transformed #3: void(T) from void(const U1*): P=T, A=const U1*: ok// #3 from transformed #1: void(const T*) from void(U1): P=const T*, A=U1: fails// #3 is more specialized than #1 with regards to T // #2 from transformed #3: void(T*) from void(const U1*): P=T* A=const U1*: ok// #3 from transformed #2: void(const T*) from void(U1*): P=const T* A=U1*: fails// #3 is more specialized than #2 with regards to T // result: #3 is selected// in other words, f(const T*) is more specialized than f(T) or f(T*)}

template<class T>void f(T, T*);// #1template<class T>void f(T,int*);// #2 void m(int* p){    f(0, p);// deduction for #1: void f(T, T*) [T = int]// deduction for #2: void f(T, int*) [T = int] // partial ordering: // #1 from #2: void(T,T*) from void(U1,int*): P1=T, A1=U1: T=U1//                                            P2=T*, A2=int*: T=int: fails // #2 from #1: void(T,int*) from void(U1,U2*): P1=T A1=U1: T=U1//                                             P2=int* A2=U2*: fails // neither is more specialized w.r.t T, the call is ambiguous}

template<class T>void g(T);// template #1template<class T>void g(T&);// template #2 void m(){float x;    g(x);// deduction from #1: void g(T ) [T = float]// deduction from #2: void g(T&) [T = float] // partial ordering: // #1 from #2: void(T) from void(U1&): P=T, A=U1 (after adjustment), ok // #2 from #1: void(T&) from void(U1): P=T (after adjustment), A=U1: ok // neither is more specialized w.r.t T, the call is ambiguous}

template<class T>struct A{ A();}; template<class T>void h(const T&);// #1template<class T>void h(A<T>&);// #2 void m(){    A<int> z;    h(z);// deduction from #1: void h(const T &) [T = A<int>]// deduction from #2: void h(A<T> &) [T = int] // partial ordering: // #1 from #2: void(const T&) from void(A<U1>&): P=T A=A<U1>: ok T=A<U1> // #2 from #1: void(A<T>&) from void(const U1&): P=A<T> A=const U1: fails // #2 is more specialized than #1 w.r.t T const A<int> z2;    h(z2);// deduction from #1: void h(const T&) [T = A<int>]// deduction from #2: void h(A<T>&) [T = int], but substitution fails // only one overload to choose from, partial ordering not tried, #1 is called}

Since a call context considers only parameters for which there are explicit call arguments, those function parameter packs,(since C++11) ellipsis parameters, and parameters with default arguments, for which there is no explicit call argument, are ignored:

template<class T>void f(T);// #1template<class T>void f(T*,int=1);// #2 void m(int* ip){int* ip;    f(ip);// calls #2 (T* is more specialized than T)}

template<class T>void g(T);// #1template<class T>void g(T*, ...);// #2 void m(int* ip){    g(ip);// calls #2 (T* is more specialized than T)}

template<class T,class U>struct A{}; template<class T,class U>void f(U, A<U, T>* p=0);// #1template<class U>void f(U, A<U, U>* p=0);// #2 void h(){    f<int>(42,(A<int,int>*)0);// calls #2    f<int>(42);// error: ambiguous}

template<class T>void g(T, T= T());// #1template<class T,class...U>void g(T, U...);// #2 void h(){    g(42);// error: ambiguous}

template<class T,class...U>void f(T, U...);// #1template<class T>void f(T);// #2 void h(int i){    f(&i);// calls #2 due to the tie-breaker between parameter pack and no parameter// (note: was ambiguous between DR692 and DR1395)}

template<class T,class...U>void g(T*, U...);// #1template<class T>void g(T);// #2 void h(int i){    g(&i);// OK: calls #1 (T* is more specialized than T)}

template<class...T>int f(T*...);// #1template<class T>int f(const T&);// #2 f((int*)0);// OK: selects #2; non-variadic template is more specialized than// variadic template (was ambiguous before DR1395 because deduction// failed in both directions)

template<class...Args>void f(Args...args);// #1template<class T1,class...Args>void f(T1 a1, Args...args);// #2template<class T1,class T2>void f(T1 a1, T2 a2);// #3 f();// calls #1f(1,2,3);// calls #2f(1,2);// calls #3; non-variadic template #3 is more// specialized than the variadic templates #1 and #2

During template argument deduction within the partial ordering process, template parameters don't require to be matched with arguments, if the argument is not used in any of the types considered for partial ordering

template<class T>T f(int);// #1template<class T,class U>T f(U);// #2 void g(){    f<int>(1);// specialization of #1 is explicit: T f(int) [T = int]// specialization of #2 is deduced:  T f(U) [T = int, U = int] // partial ordering (only considering the argument type): // #1 from #2: T(int) from U1(U2): fails// #2 from #1: T(U) from U1(int): ok: U=int, T unused // calls #1}

template<class...>struct Tuple{}; template<class...Types>void g(Tuple<Types...>);// #1template<class T1,class...Types>void g(Tuple<T1, Types...>);// #2template<class T1,class...Types>void g(Tuple<T1, Types&...>);// #3 g(Tuple<>());// calls #1g(Tuple<int,float>());// calls #2g(Tuple<int,float&>());// calls #3g(Tuple<int>());// calls #3

To compile a call to a function template, the compiler has to decide between non-template overloads, template overloads, and the specializations of the template overloads.

template<class T>void f(T);// #1: template overloadtemplate<class T>void f(T*);// #2: template overload void f(double);// #3: non-template overloadtemplate<>void f(int);// #4: specialization of #1 f('a');// calls #1f(newint(1));// calls #2f(1.0);// calls #3f(1);// calls #4

[edit]Function overloads vs function specializations

Note that only non-template and primary template overloads participate in overload resolution. The specializations are not overloads and are not considered. Only after the overload resolution selects the best-matching primary function template, its specializations are examined to see if one is a better match.

template<class T>void f(T);// #1: overload for all typestemplate<>void f(int*);// #2: specialization of #1 for pointers to inttemplate<class T>void f(T*);// #3: overload for all pointer types f(newint(1));// calls #3, even though specialization of #1 would be a perfect match

It is important to remember this rule while ordering the header files of a translation unit. For more examples of the interplay between function overloads and function specializations, expand below:

#include <iostream> struct A{}; template<class T>void f(T){std::cout<<"#1\n";}// overload #1 before f() PORtemplate<class T>void f(T*){std::cout<<"#2\n";}// overload #2 before f() POR template<class T>void g(T* t){(f)(t);// f() POR} int main(){    A* p= nullptr;    g(p);// POR of g() and f()} // Both #1 and #2 are added to the candidate list;// #2 is selected because it is a better match.

#2

#include <iostream> struct A{}; template<class T>void f(T){std::cout<<"#1\n";}// #1 template<class T>void g(T* t){(f)(t);// f() POR} template<class T>void f(T*){std::cout<<"#2\n";}// #2 int main(){    A* p= nullptr;    g(p);// POR of g() and f()} // Only #1 is added to the candidate list; #2 is defined after POR;// therefore, it is not considered for overloading even if it is a better match.

#1

#include <iostream> struct A{}; template<class T>void f(T){std::cout<<"#1\n";}// #1 template<class T>void g(T* t){(f)(t);// f() POR}template<>void f<>(A*){std::cout<<"#3\n";}// #3 int main(){    A* p= nullptr;    g(p);// POR of g() and f()} // #1 is added to the candidate list; #3 is a better match defined after POR. The// candidate list consists of #1 which is eventually selected. After that, the explicit// specialization #3 of #1 declared after POI is selected because it is a better match.// This behavior is governed by 14.7.3/6 [temp.expl.spec] and has nothing to do with ADL.

#3

#include <iostream> struct A{}; template<class T>void f(T){std::cout<<"#1\n";}// #1 template<class T>void g(T* t){(f)(t);// f() POR} template<class T>void f(T*){std::cout<<"#2\n";}// #2template<>void f<>(A*){std::cout<<"#3\n";}// #3 int main(){    A* p= nullptr;    g(p);// POR of g() and f()} // #1 is the only member of the candidate list and it is eventually selected.// After that, the explicit specialization #3 is skipped because it actually// specializes #2 declared after POR.

#1

#include <iostream> struct A{}; template<class T>void f(T){std::cout<<"#1\n";}// #1 template<class T>void g(T* t){    f(t);// f() POR} template<class T>void f(T*){std::cout<<"#2\n";}// #2 int main(){    A* p= nullptr;    g(p);// POR of g() and f()} // #1 is added to the candidate list as a result of the ordinary lookup;// #2 is defined after POR but it is added to the candidate list via ADL lookup.// #2 is selected being the better match.

#2

#include <iostream> struct A{}; template<class T>void f(T){std::cout<<"#1\n";}// #1 template<class T>void g(T* t){    f(t);// f() POR} template<>void f<>(A*){std::cout<<"#3\n";}// #3template<class T>void f(T*){std::cout<<"#2\n";}// #2 int main(){    A* p= nullptr;    g(p);// POR of g() and f()} // #1 is added to the candidate list as a result of the ordinary lookup;// #2 is defined after POR but it is added to the candidate list via ADL lookup.// #2 is selected among the primary templates, being the better match.// Since #3 is declared before #2, it is an explicit specialization of #1.// Hence the final selection is #2.

#2

#include <iostream> struct A{}; template<class T>void f(T){std::cout<<"#1\n";}// #1 template<class T>void g(T* t){    f(t);// f() POR} template<class T>void f(T*){std::cout<<"#2\n";}// #2template<>void f<>(A*){std::cout<<"#3\n";}// #3 int main(){    A* p= nullptr;    g(p);// POR of g() and f()} // #1 is added to the candidate list as a result of the ordinary lookup;// #2 is defined after POR but it is added to the candidate list via ADL lookup.// #2 is selected among the primary templates, being the better match.// Since #3 is declared after #2, it is an explicit specialization of #2;// therefore, selected as the function to call.

#3

For detailed rules on overload resolution, seeoverload resolution.

[edit]Function template specialization

[edit]Keywords

template,extern(since C++11)

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]See also

• class template
• function declaration

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文