17 Templates [temp]

A template-argument для типа, template-parameter который является типом, должен быть a type-id.

[ Example:

template <class T> class X { };
template <class T> void f(T t) { }
struct { } unnamed_obj;

void f() {
  struct A { };
  enum { e1 };
  typedef struct { } B;
  B b;
  X<A> x1;          // OK
  X<A*> x2;         // OK
  X<B> x3;          // OK
  f(e1);            // OK
  f(unnamed_obj);   // OK
  f(b);             // OK
}

 — end example ] [  Note: Аргумент типа шаблона может быть неполным типом ( [basic.types]). ] — end note 

Если тип a template-parameter содержит a placeholder type, выводимый тип параметра определяется по типу template-argument by placeholder type deduction. Если выведенный тип параметра не разрешен для template-parameterобъявления ( [temp.param]), программа имеет неправильный формат.

A template-argument для нетипа template-parameter должен быть converted constant expression типа template-parameter. Для не являющегося типом template-parameterссылки или типа указателя значение константного выражения не должно ссылаться (или для типа указателя не должно быть адресом):

• (2.1)

  а subobject,

• (2.2)

  а temporary object,

• (2.3)

  а string literal,

• (2.4)

  результат a typeid expression, или

• (2.5)

  предопределенная _­_­func_­_­ переменная.

[  Note: Если template-argument представляет собой набор перегруженных функций (или указатель или указатель на член), функция сопоставления выбирается из set ( [over.over]). ] — end note 

[ Example:

template<const int* pci> struct X { /* ... */ };
int ai[10];
X<ai> xi;                       // array to pointer and qualification conversions

struct Y { /* ... */ };
template<const Y& b> struct Z { /* ... */ };
Y y;
Z<y> z;                         // no conversion, but note extra cv-qualification

template<int (&pa)[5]> struct W { /* ... */ };
int b[5];
W<b> w;                         // no conversion

void f(char);
void f(int);

template<void (*pf)(int)> struct A { /* ... */ };

A<&f> a;                        // selects f(int)

template<auto n> struct B { /* ... */ };
B<5> b1;                        // OK: template parameter type is int
B<'a'> b2;                      // OK: template parameter type is char
B<2.5> b3;                      // error: template parameter type cannot be double

 — end example ]

[  Note: A string literal не является приемлемым template-argument. [ Example:

template<class T, const char* p> class X {
  /* ... */
};

X<int, "Studebaker"> x1;        // error: string literal as template-argument

const char p[] = "Vivisectionist";
X<int,p> x2;                    // OK

 — end example ] ] — end note 

[  Note: Адрес элемента массива или нестатического элемента данных недопустим template-argument. [ Example:

template<int* p> class X { };

int a[10];
struct S { int m; static int s; } s;

X<&a[2]> x3;                    // error: address of array element
X<&s.m> x4;                     // error: address of non-static member
X<&s.s> x5;                     // OK: address of static member
X<&S::s> x6;                    // OK: address of static member

 — end example ] ] — end note 

[  Note: Временный объект неприемлем, template-argument если соответствующий template-parameter имеет ссылочный тип. [ Example:

template<const int& CRI> struct B { /* ... */ };

B<1> b2;                        // error: temporary would be required for template argument

int c = 1;
B<c> b1;                        // OK

 — end example ] ] — end note 

A template-argument для шаблона template-parameter должно быть именем шаблона класса или шаблона псевдонима, выраженным как id-expression. При template-argumentименовании шаблона класса учитываются только первичные шаблоны классов при сопоставлении аргумента шаблона шаблона с соответствующим параметром; частичные специализации не рассматриваются, даже если их списки параметров совпадают со списком параметров шаблона.

Любые partial specializations связанные с шаблоном первичного класса или шаблоном первичной переменной рассматриваются при создании template-parameter экземпляра специализации, основанной на шаблоне . Если специализация не видна в момент создания экземпляра и была бы выбрана, если бы была видима, программа имеет неправильный формат, диагностическая проверка не требуется. [ Example:

template<class T> class A {     // primary template
  int x;
};
template<class T> class A<T*> { // partial specialization
  long x;
};
template<template<class U> class V> class C {
  V<int>  y;
  V<int*> z;
};
C<A> c;             // V<int> within C<A> uses the primary template, so c.y.x has type int
                    // V<int*> within C<A> uses the partial specialization, so c.z.x has type long

 — end example ]

Соответствует template-argumentшаблону, template-parameter P если P он не менее специализирован, чем template-argument A. Если P содержит пакет параметров, то A также соответствует, P если каждый из Aпараметров шаблона совпадает с соответствующим параметром шаблона в template-parameter-listиз P. Два параметра шаблона совпадают, если они одного типа (тип, не тип, шаблон), для не-типа template-parametersих типы эквивалентны ( [temp.over.link]), а для шаблона template-parameters, каждое из их соответствующих template-parameters совпадений, рекурсивно. Если P's template-parameter-listсодержит a template parameter pack, пакет параметров шаблона будет соответствовать нулю или более параметрам шаблона или пакетам параметров шаблона в template-parameter-listиз A с тем же типом и формой, что и пакет параметров шаблона в P (игнорируя, являются ли эти параметры шаблона пакетами параметров шаблона).

[ Example:

template<class T> class A { /* ... */ };
template<class T, class U = T> class B { /* ... */ };
template<class ... Types> class C { /* ... */ };
template<auto n> class D { /* ... */ };
template<template<class> class P> class X { /* ... */ };
template<template<class ...> class Q> class Y { /* ... */ };
template<template<int> class R> class Z { /* ... */ };

X<A> xa;            // OK
X<B> xb;            // OK
X<C> xc;            // OK
Y<A> ya;            // OK
Y<B> yb;            // OK
Y<C> yc;            // OK
Z<D> zd;            // OK

 — end example ]

[ Example:

template <class T> struct eval;

template <template <class, class...> class TT, class T1, class... Rest>
struct eval<TT<T1, Rest...>> { };

template <class T1> struct A;
template <class T1, class T2> struct B;
template <int N> struct C;
template <class T1, int N> struct D;
template <class T1, class T2, int N = 17> struct E;

eval<A<int>> eA;            // OK: matches partial specialization of eval
eval<B<int, float>> eB;     // OK: matches partial specialization of eval
eval<C<17>> eC;             // error: C does not match TT in partial specialization
eval<D<int, 17>> eD;        // error: D does not match TT in partial specialization
eval<E<int, float>> eE;     // error: E does not match TT in partial specialization

 — end example ]

Шаблон template-parameter P является, по крайней мере, таким же специализированным, как шаблон, template-argument A если, учитывая следующую перезапись двух шаблонов функций, шаблон функции, соответствующий, по P крайней мере, так же специализирован, как шаблон функции, соответствующий в A соответствии с partial ordering rules for function templates. Учитывая изобретенный шаблон класса X со списком параметров шаблона A (включая аргументы по умолчанию):

• (4.1)

  Каждый из двух шаблонов функций имеет те же параметры шаблона, что и P или A.

• (4.2)

  Каждый шаблон функции имеет один параметр функции, тип которого является специализацией X с аргументами шаблона, соответствующими параметрам шаблона из соответствующего шаблона функции, где для каждого параметра PP шаблона в списке параметров шаблона шаблона функции формируется соответствующий аргумент шаблона AA . Если PP объявляется пакет параметров, то AA это расширение пакета PP... ( [temp.variadic]); в противном случае AA - это id-expression PP.

Если при перезаписи получается недопустимый тип, то P он не такой специализированный, как A.

A class template определяет макет и операции для неограниченного набора связанных типов.

[  Example: Один шаблон класса List может предоставлять неограниченный набор определений классов: по одному классу List<T> для каждого типа T, каждое из которых описывает связанный список элементов типа T. Точно так же шаблон класса, Array описывающий непрерывный динамический массив, может быть определен следующим образом:

template<class T> class Array {
  T* v;
  int sz;
public:
  explicit Array(int);
  T& operator[](int);
  T& elem(int i) { return v[i]; }
};

Префикс template<class T> указывает, что шаблон объявляется и что в объявлении type-name T можно использовать a . Другими словами, Array это параметризованный тип с T параметром. ] — end example 

Когда функция-член, класс-член, перечисление членов, статический член-данные или шаблон-член шаблона класса определены вне определения шаблона класса, определение члена определяется как определение шаблона, в котором template-parameters есть те из шаблон класса. Имена параметров шаблона, используемые в определении члена, могут отличаться от имен параметров шаблона, используемых в определении шаблона класса. Список аргументов шаблона, следующий за именем шаблона класса в определении элемента, должен называть параметры в том же порядке, что и в списке параметров шаблона элемента. Каждый пакет параметров шаблона должен быть расширен многоточием в списке аргументов шаблона. [ Example:

template<class T1, class T2> struct A {
  void f1();
  void f2();
};

template<class T2, class T1> void A<T2,T1>::f1() { }    // OK
template<class T2, class T1> void A<T1,T2>::f2() { }    // error

template<class ... Types> struct B {
  void f3();
  void f4();
};

template<class ... Types> void B<Types ...>::f3() { }    // OK
template<class ... Types> void B<Types>::f4() { }        // error

 — end example ]

При повторном объявлении, частичной специализации, явной специализации или явном создании экземпляра шаблона класса он class-key должен согласовываться по сути с объявлением исходного шаблона класса ( [dcl.type.elab]).

Шаблон может быть объявлен в классе или шаблоне класса; такой шаблон называется шаблоном члена. Шаблон элемента может быть определен внутри или вне его определения класса или определения шаблона класса. Шаблон элемента шаблона класса, который определен вне его определения шаблона класса, должен быть указан с template-parameters помощью шаблона класса, за которым следует template-parameters элемент шаблона элемента. [ Example:

template<class T> struct string {
  template<class T2> int compare(const T2&);
  template<class T2> string(const string<T2>& s) { /* ... */ }
};

template<class T> template<class T2> int string<T>::compare(const T2& s) {
}

 — end example ]

Локальный класс незамкнутого типа не должен иметь шаблонов членов. Access control rules применяются к именам шаблонов элементов. Деструктор не должен быть шаблоном члена. В [dcl.fct]классе могут быть объявлены нешаблонная функция-член ( ) с заданным именем и типом, а также шаблон функции-члена с тем же именем, который можно использовать для создания специализации одного и того же типа. Если оба существуют, использование этого имени и типа относится к члену, не являющемуся шаблоном, если не указан явный список аргументов шаблона. [ Example:

template <class T> struct A {
  void f(int);
  template <class T2> void f(T2);
};

template <> void A<int>::f(int) { }                 // non-template member function
template <> template <> void A<int>::f<>(int) { }   // member function template specialization

int main() {
  A<char> ac;
  ac.f(1);          // non-template
  ac.f('c');        // template
  ac.f<>(1);        // template
}

 — end example ]

Шаблон функции-члена не должен быть виртуальным. [ Example:

template <class T> struct AA {
  template <class C> virtual void g(C);     // error
  virtual void f();                         // OK
};

 — end example ]

Специализация шаблона функции-члена не отменяет виртуальную функцию из базового класса. [ Example:

class B {
  virtual void f(int);
};

class D : public B {
  template <class T> void f(T); // does not override B​::​f(int)
  void f(int i) { f<>(i); }     // overriding function that calls the template instantiation
};

 — end example ]

На специализацию шаблона функции преобразования ссылаются так же, как на нешаблонную функцию преобразования, которая преобразуется в тот же тип. [ Example:

struct A {
  template <class T> operator T*();
};
template <class T> A::operator T*(){ return 0; }
template <> A::operator char*(){ return 0; }    // specialization
template A::operator void*();                   // explicit instantiation

int main() {
  A a;
  int* ip;
  ip = a.operator int*();       // explicit call to template operator A​::​operator int*()
}

 — end example ] [  Note: Поскольку явный список аргументов шаблона следует за именем шаблона функции, и поскольку шаблоны функций-членов преобразования и шаблоны функций-членов конструктора вызываются без использования имени функции, невозможно предоставить явный список аргументов шаблона для этих шаблонов функций. ] — end note 

Специализация шаблона функции преобразования не может быть найдена с помощью поиска по имени. Вместо этого рассматриваются любые шаблоны функций преобразования, видимые в контексте использования. Для каждого такого оператора, если вывод аргумента завершается успешно ( [temp.deduct.conv]), полученная специализация используется, как если бы она была найдена с помощью поиска по имени.

A using-declarationв производном классе не может ссылаться на специализацию шаблона функции преобразования в базовом классе.

Overload resolution и partial ordering используются для выбора наилучшей функции преобразования среди множества специализаций шаблонов функций преобразования и / или функций преобразования, не являющихся шаблонами.

A template parameter pack - это параметр шаблона, который принимает ноль или более аргументов шаблона. [ Example:

template<class ... Types> struct Tuple { };

Tuple<> t0;                     // Types contains no arguments
Tuple<int> t1;                  // Types contains one argument: int
Tuple<int, float> t2;           // Types contains two arguments: int and float
Tuple<0> error;                 // error: 0 is not a type

 — end example ]

A function parameter pack - это параметр функции, который принимает ноль или более аргументов функции. [ Example:

template<class ... Types> void f(Types ... args);

f();                            // OK: args contains no arguments
f(1);                           // OK: args contains one argument: int
f(2, 1.0);                      // OK: args contains two arguments: int and double

 — end example ]

A parameter pack - это либо пакет параметров шаблона, либо пакет параметров функции.

A pack expansion состоит из a pattern и многоточия, создание экземпляра которого дает ноль или более экземпляров шаблона в списке (описанном ниже). Форма паттерна зависит от контекста, в котором происходит расширение. Расширения пакетов могут происходить в следующих контекстах:

• (4.1)

  В параметре функции pack ( [dcl.fct]); узор parameter-declarationбез многоточия.

• (4.2)

  В a using-declaration; узор - это using-declarator.

• (4.3)

  В пакете параметров шаблона, который является расширением пакета ( [temp.param]):

  • (4.3.1)

    если пакет параметров шаблона - это parameter-declaration; узор parameter-declarationбез многоточия;

  • (4.3.2)

    если пакет параметров шаблона - это type-parameterс a template-parameter-list; узор соответствующий type-parameterбез многоточия.

• (4.4)

  В initializer-list; шаблон initializer-clause.

• (4.5)

  В a base-specifier-list; узор - это base-specifier.

• (4.6)

  В a mem-initializer-listдля mem-initializerкоторого mem-initializer-idобозначает базовый класс; шаблон mem-initializer.

• (4.7)

  В template-argument-list( [temp.arg]); узор - это template-argument.

• (4.8)

  В attribute-list; шаблон attribute.

• (4.9)

  В alignment-specifier( [dcl.align]); узор alignment-specifierбез многоточия.

• (4.10)

  В capture-list( [expr.prim.lambda]); узор - это capture.

• (4.11)

  В a sizeof... expression; шаблон identifier.

• (4.12)

  В a fold-expression; шаблон - это шаблон, cast-expression который содержит нерасширенный пакет параметров.

[ Example:

template<class ... Types> void f(Types ... rest);
template<class ... Types> void g(Types ... rest) {
  f(&rest ...);     // “&rest ...” is a pack expansion; “&rest” is its pattern
}

 — end example ]

Для определения того, удовлетворяет ли пакет параметров правилу в отношении объектов, отличных от пакетов параметров, пакет параметров считается объектом, который может возникнуть в результате реализации шаблона, в котором он появляется.

Пакет параметров, имя которого появляется в шаблоне расширения пакета, расширяется этим расширением пакета. Появление имени пакета параметров расширяется только расширением самого внутреннего охватывающего пакета. Шаблон расширения пакета должен называть один или несколько пакетов параметров, которые не расширяются вложенным расширением пакета; такие пакеты параметров вызываются unexpanded parameter packs в шаблоне. Все пакеты параметров, расширенные расширением пакета, должны иметь одинаковое количество аргументов. Имя пакета параметров, который не раскрывается, отображается неправильно. [ Example:

template<typename...> struct Tuple {};
template<typename T1, typename T2> struct Pair {};

template<class ... Args1> struct zip {
  template<class ... Args2> struct with {
    typedef Tuple<Pair<Args1, Args2> ... > type;
  };
};

typedef zip<short, int>::with<unsigned short, unsigned>::type T1;
    // T1 is Tuple<Pair<short, unsigned short>, Pair<int, unsigned>>
typedef zip<short>::with<unsigned short, unsigned>::type T2;
    // error: different number of arguments specified for Args1 and Args2

template<class ... Args>
  void g(Args ... args) {                   // OK: Args is expanded by the function parameter pack args
    f(const_cast<const Args*>(&args)...);   // OK: “Args” and “args” are expanded
    f(5 ...);                               // error: pattern does not contain any parameter packs
    f(args);                                // error: parameter pack “args” is not expanded
    f(h(args ...) + args ...);              // OK: first “args” expanded within h,
                                            // second “args” expanded within f
  }

 — end example ]

Создание экземпляра расширения пакета, которое не является ни sizeof... выражением, ни a, fold-expression создает список $E_1,E_2,\dots ,E_N$, где N - количество элементов в параметрах расширения пакета. Каждый $E_i$ генерируется путем создания экземпляра шаблона и замены каждого параметра расширения пакета его ith элементом. Такой элемент в контексте создания интерпретируется следующим образом:

• (7.1)

  если пакет является пакетом параметров шаблона, это элемент template parameter соответствующего типа (тип или нет), обозначающий тип или значение из аргумента шаблона; иначе,

• (7.2)

  если пакет является пакетом параметров функции, элемент является id-expression обозначением параметра функции, который возник в результате создания экземпляра шаблона, в котором объявлен пакет.

Все $E_i$ элементы стали в прилагающемся списке. [  Note: Разнообразие списка изменяется в зависимости от контекста: expression-list, base-specifier-list, template-argument-listи т.д. ] Если равен нуль, то конкретизация расширения производит пустой список. Такое создание экземпляра не изменяет синтаксическую интерпретацию включающей конструкции, даже в тех случаях, когда полное исключение списка в противном случае было бы некорректным или привело бы к двусмысленности в грамматике. [ — end note  N  Example:

template<class... T> struct X : T... { };
template<class... T> void f(T... values) {
  X<T...> x(values...);
}

template void f<>();    // OK: X<> has no base classes
                        // x is a variable of type X<> that is value-initialized

 — end example ]

Создание экземпляра a sizeof... expression создает целочисленную константу, содержащую количество элементов в расширяемом пакете параметров.

Создание экземпляра a fold-expressionпроизводит:

• (9.1)

  (($E_1$ op $E_2$) op ⋯) op $E_N$ для унарной левой складки,

• (9.2)

  $E_1$ op (⋯ op ($E_{N-1}$ op $E_N$)) для унарной правой складки,

• (9.3)

  (((E op $E_1$) op $E_2$) op ⋯) op $E_N$ для двоичной левой складки, и

• (9.4)

  $E_1$ op (⋯ op ($E_{N-1}$ op ($E_N$ op E))) для двоичной правой складки.

В каждом случае op это fold-operator, N является количеством элементов в параметрах расширения пакета, и каждый $E_i$ генерируется инстанцирование шаблона и замены каждого параметра разложения пакета с его iго элементом. Для двоичного свернутого выражения E создается путем создания экземпляра cast-expression , не содержащего нерасширенного пакета параметров. [ Example:

template<typename ...Args>
  bool all(Args ...args) { return (... && args); }

bool b = all(true, true, true, false);

Внутри экземпляра allвозвращаемое выражение расширяется до ((true && true) && true) && false, что дает результат false. ] Если для унарного свернутого выражения равно нулю, значение выражения показано в таблице ; если оператор не указан в таблице , создание экземпляра некорректно. — end example  N 14 14

Другом класса или шаблона класса может быть шаблон функции или шаблон класса, специализация шаблона функции или шаблона класса, либо функция или класс, не являющиеся шаблоном. Для объявления дружественной функции, не являющейся объявлением шаблона:

• (1.1)

  если имя друга является квалифицированным или неквалифицированным template-id, объявление друга относится к специализации шаблона функции, в противном случае,

• (1.2)

  если имя друга - a qualified-idи соответствующая функция, не являющаяся шаблоном, найдена в указанном классе или пространстве имен, объявление друга ссылается на эту функцию, в противном случае,

• (1.3)

  если имя друга - a qualified-idи соответствующий шаблон функции найден в указанном классе или пространстве имен, объявление друга ссылается на выведенную специализацию этого шаблона функции ( [temp.deduct.decl]), в противном случае,

• (1.4)

  имя должно быть объявлено unqualified-id(или повторно объявлено) нешаблонной функцией.

[ Example:

template<class T> class task;
template<class T> task<T>* preempt(task<T>*);

template<class T> class task {
  friend void next_time();
  friend void process(task<T>*);
  friend task<T>* preempt<T>(task<T>*);
  template<class C> friend int func(C);

  friend class task<int>;
  template<class P> friend class frd;
};

Здесь каждая специализация task шаблона класса выполняет функцию next_­time друга; поскольку process не имеет явного значения template-arguments, каждая специализация task шаблона класса имеет process в качестве друга соответствующую типизированную функцию , и этот друг не является специализацией шаблона функции; поскольку у друга preempt есть явная template-argument T, каждая специализация task шаблона класса имеет соответствующую специализацию шаблона функции preempt как друга; и каждая специализация task шаблона класса имеет все специализации шаблона функции func как друзей. Точно так же каждая специализация task шаблона класса имеет специализацию шаблона класса task<int> как друга и все специализации шаблона класса frd как друзья. ] — end example 

Шаблон друга может быть объявлен в классе или шаблоне класса. Шаблон дружественной функции может быть определен в классе или шаблоне класса, но шаблон дружественного класса не может быть определен в классе или шаблоне класса. В этих случаях все специализации класса друга или шаблона функции друга являются друзьями класса или шаблона класса, предоставляющего дружбу. [ Example:

class A {
  template<class T> friend class B;                 // OK
  template<class T> friend void f(T){ /* ... */ }   // OK
};

 — end example ]

А друг шаблон декларации указывает , что все специализации этого шаблона, являются ли они implicitly instantiated, partially specialized или explicitly specialized, являются друзьями класса , содержащего декларацию друга шаблон. [ Example:

class X {
  template<class T> friend struct A;
  class Y { };
};

template<class T> struct A { X::Y ab; };            // OK
template<class T> struct A<T*> { X::Y ab; };        // OK

 — end example ]

Член шаблона класса может быть объявлен другом не являющегося шаблоном класса. В этом случае соответствующий член каждой специализации первичного шаблона класса и его частичных специализаций шаблона класса является другом класса, предоставляющего дружбу. Для явных специализаций и специализаций частичных специализаций соответствующий член - это член (если есть), имеющий то же имя, вид (тип, функция, шаблон класса или шаблон функции), параметры шаблона и подпись, что и член класса. создание экземпляра шаблона, который в противном случае был бы сгенерирован. [ Example:

template<class T> struct A {
  struct B { };
  void f();
  struct D {
    void g();
  };
};
template<> struct A<int> {
  struct B { };
  int f();
  struct D {
    void g();
  };
};

class C {
  template<class T> friend struct A<T>::B;      // grants friendship to A<int>​::​B even though
                                                // it is not a specialization of A<T>​::​B
  template<class T> friend void A<T>::f();      // does not grant friendship to A<int>​::​f()
                                                // because its return type does not match
  template<class T> friend void A<T>::D::g();   // does not grant friendship to A<int>​::​D​::​g()
                                                // because A<int>​::​D is not a specialization of A<T>​::​D
};

 — end example ]

[  Note: Объявление друга может сначала объявлять член охватывающей области пространства имен ( [temp.inject]). ] — end note 

Шаблон друга не должен быть объявлен в локальном классе.

В дружеских объявлениях не указывается частичная специализация. [ Example:

template<class T> class A { };
class X {
  template<class T> friend class A<T*>;         // error
};

 — end example ]

Когда объявление друга ссылается на специализацию шаблона функции, объявления параметров функции не должны включать аргументы по умолчанию, и в таком объявлении нельзя использовать встроенный спецификатор.

primary class template Декларация, в которой имя шаблона класса является идентификатором. Объявление шаблона , в котором имя шаблона класса является simple-template-id это partial specialization шаблон класса с именем в simple-template-id. Частичная специализация шаблона класса обеспечивает альтернативное определение шаблона, которое используется вместо основного определения, когда аргументы в специализации совпадают с аргументами, указанными в частичной специализации ( [temp.class.spec.match]). Первичный шаблон должен быть объявлен перед любыми специализациями этого шаблона. Частичная специализация должна быть объявлена ​​перед первым использованием специализации шаблона класса, которая будет использовать частичную специализацию как результат неявной или явной реализации в каждой единице перевода, в которой такое использование происходит; Диагностика не требуется.

Каждая частичная специализация шаблона класса является отдельным шаблоном, и должны быть предоставлены определения для членов частичной специализации шаблона ( [temp.class.spec.mfunc]).

[ Example:

template<class T1, class T2, int I> class A             { };
template<class T, int I>            class A<T, T*, I>   { };
template<class T1, class T2, int I> class A<T1*, T2, I> { };
template<class T>                   class A<int, T*, 5> { };
template<class T1, class T2, int I> class A<T1, T2*, I> { };

Первое объявление объявляет первичный (неспециализированный) шаблон класса. Второе и последующие объявления объявляют частичную специализацию первичного шаблона. ] — end example 

Параметры шаблона указываются в прилагаемом списке угловых скобок, который следует сразу за ключевым словом template. Для частичных специализаций список аргументов шаблона явно записывается сразу после имени шаблона класса. Для первичных шаблонов этот список неявно описывается списком параметров шаблона. В частности, порядок аргументов шаблона - это последовательность, в которой они появляются в списке параметров шаблона. [  Example: Список аргументов шаблона для основного шаблона в примере выше <T1, T2, I>. ] [ Список аргументов шаблона не должен указываться в объявлении первичного шаблона. Например, — end example  Note:

template<class T1, class T2, int I>
class A<T1, T2, I> { };                         // error

 — end note ]

Частичная специализация шаблона класса может быть объявлена в любой области , в которой может быть определен соответствующий первичный шаблон ( [namespace.memdef], [class.mem], [temp.mem]). [ Example:

template<class T> struct A {
  struct C {
    template<class T2> struct B { };
    template<class T2> struct B<T2**> { };      // partial specialization #1
  };
};

// partial specialization of A<T>​::​C​::​B<T2>
template<class T> template<class T2>
  struct A<T>::C::B<T2*> { };                   // #2

A<short>::C::B<int*> absip;                     // uses partial specialization #2

 — end example ]

Сами по себе объявления частичной специализации не могут быть найдены поиском по имени. Скорее, когда используется имя первичного шаблона, также учитываются любые ранее объявленные частичные специализации первичного шаблона. Одним из следствий этого является то, что a, using-declaration который ссылается на шаблон класса, не ограничивает набор частичных специализаций, которые можно найти через using-declaration. [ Example:

namespace N {
  template<class T1, class T2> class A { };     // primary template
}

using N::A;                                     // refers to the primary template

namespace N {
  template<class T> class A<T, T*> { };         // partial specialization
}

A<int,int*> a;      // uses the partial specialization, which is found through the using-declaration
                    // which refers to the primary template

 — end example ]

Аргумент, не являющийся типом, считается неспециализированным, если это имя параметра, не являющегося типом. Все остальные аргументы, не относящиеся к типу, являются специализированными.

В списке аргументов частичной специализации шаблона класса действуют следующие ограничения:

• (8.1)

  Тип параметра шаблона, соответствующий специализированному аргументу, не являющемуся типом, не должен зависеть от параметра специализации. [ Example:

  template <class T, T t> struct C {};
  template <class T> struct C<T, 1>;              // error
  
  template< int X, int (*array_ptr)[X] > class A {};
  int array[5];
  template< int X > class A<X,&array> { };        // error
  

   — end example ]

• (8.2)

  Специализация должна отличаться more specialized от основного шаблона.

• (8.3)

  Список параметров шаблона для специализации не должен содержать значений аргументов шаблона по умолчанию.138

• (8.4)

  Аргумент не должен содержать нерасширенный пакет параметров. Если аргумент - это pack expansion, он должен быть последним аргументом в списке аргументов шаблона.

Шаблон функции определяет неограниченный набор связанных функций. [  Example: Семейство функций сортировки может быть объявлено следующим образом:

template<class T> class Array { };
template<class T> void sort(Array<T>&);

 — end example ]

Шаблон функции может быть перегружен другими шаблонами функций и нешаблонными функциями ( [dcl.fct]). Функция, не являющаяся шаблоном, не связана с шаблоном функции (т. Е. Никогда не считается специализацией), даже если она имеет то же имя и тип, что и потенциально сгенерированная специализация шаблона функции.139

template-declaration, В котором declarationэто alias-declarationобъявляет identifierбыть alias template. Шаблон псевдонима - это имя семейства типов. Имя шаблона псевдонима - template-name.

Когда template-idотносится к специализации шаблона псевдонима, это равносильно тому , ассоциированному типа , полученный путем замены сва template-arguments для template-parameters в type-idшаблоне псевдонима. [  Note: Имя шаблона псевдонима никогда не выводится. ] [ — end note  Example:

template<class T> struct Alloc { /* ... */ };
template<class T> using Vec = vector<T, Alloc<T>>;
Vec<int> v;         // same as vector<int, Alloc<int>> v;

template<class T>
  void process(Vec<T>& v)
  { /* ... */ }

template<class T>
  void process(vector<T, Alloc<T>>& w)
  { /* ... */ }     // error: redefinition

template<template<class> class TT>
  void f(TT<int>);

f(v);               // error: Vec not deduced

template<template<class,class> class TT>
  void g(TT<int, Alloc<int>>);
g(v);               // OK: TT = vector

 — end example ]

Однако, если template-idэто зависит, последующая подстановка аргументов шаблона по-прежнему применяется к template-id. [ Example:

template<typename...> using void_t = void;
template<typename T> void_t<typename T::foo> f();
f<int>();           // error, int does not have a nested type foo

 — end example ]

В type-idобъявлении шаблона псевдонима не должно быть ссылки на объявляемый шаблон псевдонима. Тип, созданный специализацией шаблона псевдонима, не должен прямо или косвенно использовать эту специализацию. [ Example:

template <class T> struct A;
template <class T> using B = typename A<T>::U;
template <class T> struct A {
  typedef B<T> U;
};
B<short> b;         // error: instantiation of B<short> uses own type via A<short>​::​U

 — end example ]

Как и обычные (не шаблонные) классы, шаблоны классов имеют расширение injected-class-name. Введенное-имя-класса может использоваться как template-nameили type-name. Когда он используется с template-argument-list, как template-argumentдля шаблона template-parameterили как окончательный идентификатор в elaborated-type-specifierобъявлении шаблона дружественного класса, он ссылается на сам шаблон класса. В противном случае, это равносильно тому , template-name сопровождаемое template-parameters шаблон класса , заключенном в <>.

В рамках специализации шаблона класса или частичной специализации, когда имя injected-class-name используется как a type-name, оно эквивалентно, за template-nameкоторым следует template-arguments специализация шаблона класса или частичная специализация, заключенная в <>. [ Example:

template<template<class> class T> class A { };
template<class T> class Y;
template<> class Y<int> {
  Y* p;                               // meaning Y<int>
  Y<char>* q;                         // meaning Y<char>
  A<Y>* a;                            // meaning A<​::​Y>
  class B {
    template<class> friend class Y;   // meaning ​::​Y
  };
};

 — end example ]

Нагнетаемого класса имя шаблона класса или класса специализации шаблона может быть использован либо как template-nameили type-name там , где она находится в области видимости. [ Example:

template <class T> struct Base {
  Base* p;
};

template <class T> struct Derived: public Base<T> {
  typename Derived::Base* p;    // meaning Derived​::​Base<T>
};

template<class T, template<class> class U = T::template Base> struct Third { };
Third<Base<int> > t;            // OK: default argument uses injected-class-name as a template

 — end example ]

Поиск, который находит внедренное имя-класса ( [class.member.lookup]), в некоторых случаях может привести к неоднозначности (например, если он найден более чем в одном базовом классе). Если все найденные имена внедренных классов относятся к специализациям одного и того же шаблона класса, и если имя используется как a template-name, ссылка относится к самому шаблону класса, а не к его специализации, и не является двусмысленной. [ Example:

template <class T> struct Base { };
template <class T> struct Derived: Base<int>, Base<char> {
  typename Derived::Base b;             // error: ambiguous
  typename Derived::Base<double> d;     // OK
};

 — end example ]

Когда используется обычное имя шаблона (т. Е. Имя из охватывающей области, а не внедренное имя-класса), оно всегда относится к самому шаблону класса, а не к его специализации. [ Example:

template<class T> class X {
  X* p;             // meaning X<T>
  X<T>* p2;
  X<int>* p3;
  ::X* p4;          // error: missing template argument list
                    // ​::​X does not refer to the injected-class-name
};

 — end example ]

A template-parameter не следует повторно объявлять в пределах своей области действия (включая вложенные области действия). Имя A template-parameter не должно совпадать с именем шаблона. [ Example:

template<class T, int i> class Y {
  int T;            // error: template-parameter redeclared
  void f() {
    char T;         // error: template-parameter redeclared
  }
};

template<class X> class X;      // error: template-parameter redeclared

 — end example ]

В определении члена шаблона класса, который появляется вне определения шаблона класса, имя члена шаблона класса скрывает имя template-parameter любого включающего шаблона класса (но не template-parameterчлена, если член является шаблон класса или функции). [ Example:

template<class T> struct A {
  struct B { /* ... */ };
  typedef void C;
  void f();
  template<class U> void g(U);
};

template<class B> void A<B>::f() {
  B b;              // A's B, not the template parameter
}

template<class B> template<class C> void A<B>::g(C) {
  B b;              // A's B, not the template parameter
  C c;              // the template parameter C, not A's C
}

 — end example ]

В определении члена шаблона класса, который появляется за пределами пространства имен, содержащего определение шаблона класса, имя template-parameter скрывает имя члена этого пространства имен. [ Example:

namespace N {
  class C { };
  template<class T> class B {
    void f(T);
  };
}
template<class C> void N::B<C>::f(C) {
  C b;              // C is the template parameter, not N​::​C
}

 — end example ]

В определении шаблона класса или в определении члена такого шаблона, который появляется вне определения шаблона, для каждого независимого базового класса ( [temp.dep.type]), если имя базового класса или имя члена базовый класс такой же , как название template-parameter, имя базового класса или члена имя hides на template-parameter имя. [ Example:

struct A {
  struct B { /* ... */ };
  int a;
  int Y;
};

template<class B, class a> struct X : A {
  B b;              // A's B
  a b;              // error: A's a isn't a type name
};

 — end example ]

Внутри шаблона некоторые конструкции имеют семантику, которая может отличаться от одного экземпляра к другому. Такая конструкция зависит от параметров шаблона. В частности, типы и выражения могут зависеть от типа и / или значения параметров шаблона (как определено аргументами шаблона), и это определяет контекст для поиска имени для определенных имен. Выражения могут быть type-dependent (то есть его тип может зависеть от параметра шаблона) или value-dependent (то есть его значение при оценке как постоянное выражение ( [expr.const]) может зависеть от параметра шаблона), как описано в этом подпункте. В выражении формы:

postfix-expression ( expression-list${}_{opt}$ )

где postfix-expression является an unqualified-id, unqualified-id обозначает a, dependent name если

• (1.1)

  любое из выражений в expression-list- это pack expansion,

• (1.2)

  любое из выражений или braced-init-lists в expression-list есть type-dependent, или

• (1.3)

  unqualified-id является , template-idв котором любой из аргументов шаблона зависит от параметра шаблона.

Если операнд оператора является выражением, зависящим от типа, оператор также обозначает зависимое имя. Такие имена не связаны и просматриваются в точке создания экземпляра шаблона ( [temp.point]) как в контексте определения шаблона, так и в контексте точки создания экземпляра.

[ Example:

template<class T> struct X : B<T> {
  typename T::A* pa;
  void f(B<T>* pb) {
    static int i = B<T>::i;
    pb->j++;
  }
};

имя базового класса, имя B<T>типа T​::​A, имена B<T>​::​i и pb->j явно зависят от template-parameter. ] — end example 

В определении класса или шаблона класса область видимости dependent base class не проверяется во время неквалифицированного поиска имени ни в точке определения шаблона или члена класса, ни во время создания экземпляра шаблона или члена класса. [ Example:

typedef double A;
template<class T> class B {
  typedef int A;
};
template<class T> struct X : B<T> {
  A a;              // a has type double
};

Имя типа A в определении X<T> связывается с именем typedef, определенным в области глобального пространства имен, а не с именем typedef, определенным в базовом классе B<T>. ] [ — end example  Example:

struct A {
  struct B { /* ... */ };
  int a;
  int Y;
};

int a;

template<class T> struct Y : T {
  struct B { /* ... */ };
  B b;                          // The B defined in Y
  void f(int i) { a = i; }      // ​::​a
  Y* p;                         // Y<T>
};

Y<A> ya;

Члены A​::​B, A​::​aи A​::​Y аргумента шаблона A не влияют на привязку имен в Y<A>. ] — end example 

Независимые имена, используемые в определении шаблона, обнаруживаются с помощью обычного поиска по именам и привязываются к месту их использования. [ Example:

void g(double);
void h();

template<class T> class Z {
public:
  void f() {
    g(1);           // calls g(double)
    h++;            // ill-formed: cannot increment function; this could be diagnosed
                    // either here or at the point of instantiation
  }
};

void g(int);        // not in scope at the point of the template definition, not considered for the call g(1)

 — end example ]

При разрешении зависимых имен учитываются имена из следующих источников:

• (1.1)

  Объявления, которые видны в момент определения шаблона.

• (1.2)

  Объявления из пространств имен, связанных с типами аргументов функции, как из контекста создания ( [temp.point]), так и из контекста определения.

Дружественные классы или функции могут быть объявлены в шаблоне класса. Когда создается экземпляр шаблона, имена его друзей обрабатываются так, как если бы специализация была явно объявлена ​​в точке создания экземпляра.

Как и в случае с классами, не являющимися шаблонами, имена дружественных функций области видимости пространства имен специализации шаблона класса не видны во время обычного поиска, если явно не объявлены в области видимости пространства имен ( [class.friend]). Такие имена можно найти в правилах для связанных классов ( [basic.lookup.argdep]). 140 [ Example:

template<typename T> struct number {
  number(int);
  friend number gcd(number x, number y) { return 0; };
};

void g() {
  number<double> a(3), b(4);
  a = gcd(a,b);     // finds gcd because number<double> is an associated class,
                    // making gcd visible in its namespace (global scope)
  b = gcd(3,4);     // ill-formed; gcd is not visible
}

 — end example ]

Если специализация шаблона класса не была explicitly instantiated или explicitly specialized, специализация шаблона класса неявно создается, когда на специализацию ссылаются в контексте, который требует полностью определенного типа объекта, или когда полнота типа класса влияет на семантику программы. [  Note: В частности, если семантика выражения зависит от списков членов или базовых классов специализации шаблона класса, специализация шаблона класса генерируется неявно. Например, удаление указателя на тип класса зависит от того, объявляет ли класс деструктор, а преобразование между указателями в тип класса зависит от отношения наследования между двумя задействованными классами. ] [ — end note  Example:

template<class T> class B { /* ... */ };
template<class T> class D : public B<T> { /* ... */ };

void f(void*);
void f(B<int>*);

void g(D<int>* p, D<char>* pp, D<double>* ppp) {
  f(p);             // instantiation of D<int> required: call f(B<int>*)
  B<char>* q = pp;  // instantiation of D<char> required: convert D<char>* to B<char>*
  delete ppp;       // instantiation of D<double> required
}

 — end example ] Если шаблон класса был объявлен, но не определен, при point of instantiationсоздании экземпляра будет получен неполный тип класса ( [basic.types]). [ Example:

template<class T> class X;
X<char> ch;         // error: incomplete type X<char>

 — end example ] [  Note: В объявлении шаблона local class перечисление или и члены локального класса никогда не считаются сущностями, которые могут быть созданы отдельно (это включает их аргументы по умолчанию noexcept-specifiers, и инициализаторы нестатических элементов данных, если таковые имеются). В результате выполняется поиск зависимых имен, проверяются семантические ограничения, и любые используемые шаблоны создаются как часть создания экземпляра объекта, в котором объявлен локальный класс или перечисление. ] — end note 

Неявное создание экземпляра специализации шаблона класса вызывает неявное создание экземпляров объявлений, но не определений, аргументов по умолчанию или noexcept-specifiers функций-членов класса, классов-членов, перечислений элементов с заданной областью действия, элементов статических данных, шаблонов элементов и других элементов; и это вызывает неявное создание экземпляров определений перечислений членов с незаданной областью и анонимных объединений членов. Однако для определения того, является ли созданное повторное объявление действительным в соответствии с [basic.def.odr] и [class.mem], объявление, которое соответствует определению в шаблоне, считается определением. [ Example:

template<class T, class U>
struct Outer {
  template<class X, class Y> struct Inner;
  template<class Y> struct Inner<T, Y>;         // #1a
  template<class Y> struct Inner<T, Y> { };     // #1b; OK: valid redeclaration of #1a
  template<class Y> struct Inner<U, Y> { };     // #2
};

Outer<int, int> outer;                          // error at #2

Outer<int, int>​::​Inner<int, Y> повторно заявлен на # 1b. (Он не определен, но отмечен как связанный с определением в Outer<T, U>.) # 2 также является повторным объявлением # 1a. Он отмечен как связанный с определением, поэтому это недопустимое повторное объявление той же частичной специализации.

template<typename T> struct Friendly {
  template<typename U> friend int f(U) { return sizeof(T); }
};
Friendly<char> fc;
Friendly<float> ff;                             // ill-formed: produces second definition of f(U)

 — end example ]

Если член шаблона класса или шаблона члена не был явно создан или явно специализирован, специализация члена неявно создается, когда на специализацию ссылаются в контексте, который требует существования определения члена; в частности, инициализация (и любые связанные с ней побочные эффекты) статического члена данных не происходит, если сам статический член данных не используется таким образом, который требует существования определения статического члена данных.

Если специализация шаблона функции не была явно создана или явно специализирована, специализация шаблона функции создается неявно, когда на специализацию ссылаются в контексте, который требует существования определения функции. Функция, объявление которой было создано из определения дружественной функции, создается неявно, когда на нее ссылаются в контексте, который требует существования определения функции. Если вызов не относится к явной специализации шаблона функции или к функции-члену явно специализированного шаблона класса, аргумент по умолчанию для шаблона функции или функция-член шаблона класса неявно создается, когда функция вызывается в контексте, который требует значение аргумента по умолчанию.

[ Example:

template<class T> struct Z {
  void f();
  void g();
};

void h() {
  Z<int> a;         // instantiation of class Z<int> required
  Z<char>* p;       // instantiation of class Z<char> not required
  Z<double>* q;     // instantiation of class Z<double> not required

  a.f();            // instantiation of Z<int>​::​f() required
  p->g();           // instantiation of class Z<char> required, and
                    // instantiation of Z<char>​::​g() required
}

Ничто в этом примере не требуется class Z<double>, Z<int>​::​g()или Z<char>​::​f() неявный экземпляр. ] — end example 

Если специализация шаблона переменной не была явно создана или явно специализирована, специализация шаблона переменной создается неявно при использовании этой специализации. Аргумент шаблона по умолчанию для шаблона переменной неявно создается, когда шаблон переменной упоминается в контексте, который требует значения аргумента по умолчанию.

Если функция, выбранная с помощью, overload resolution может быть определена без создания экземпляра определения шаблона класса, не указано, действительно ли это создание имеет место. [ Example:

template <class T> struct S {
  operator int();
};

void f(int);
void f(S<int>&);
void f(S<float>);

void g(S<int>& sr) {
  f(sr);            // instantiation of S<int> allowed but not required
                    // instantiation of S<float> allowed but not required
};

 — end example ]

Если шаблон функции или специализация шаблона функции-члена используется способом, который включает разрешение перегрузки, объявление специализации неявно создается ( [temp.over]).

Реализация не должна неявно создавать экземпляр шаблона функции, шаблона переменной, шаблона члена, невиртуальной функции-члена, класса-члена, члена статических данных в шаблоне класса или подвыпуска constexpr if оператора, если только такое создание не требуется. . Не указано, создает ли реализация неявно виртуальную функцию-член шаблона класса, если в противном случае виртуальная функция-член не была бы создана. Использование специализации шаблона в аргументе по умолчанию не должно вызывать неявное создание экземпляра шаблона, за исключением того, что может быть создан экземпляр шаблона класса, где его полный тип необходим для определения правильности аргумента по умолчанию. Использование аргумента по умолчанию в вызове функции вызывает неявное создание экземпляров специализаций в аргументе по умолчанию.

Неявно созданные экземпляры специализации шаблонов классов, функций и переменных помещаются в пространство имен, в котором определен шаблон. Неявно созданные экземпляры специализаций для членов шаблона класса помещаются в пространство имен, где определен включающий шаблон класса. Неявно созданные экземпляры шаблонов членов помещаются в пространство имен, в котором определен включающий класс или шаблон класса. [ Example:

namespace N {
  template<class T> class List {
  public:
    T* get();
  };
}

template<class K, class V> class Map {
public:
  N::List<V> lt;
  V get(K);
};

void g(Map<const char*,int>& m) {
  int i = m.get("Nicholas");
}

вызов lt.get() from Map<const char*,int>​::​get() будет помещаться List<int>​::​get() в пространство имен, N а не в глобальное пространство имен. ] — end example 

Если шаблон функции f вызывается способом, требующим использования аргумента по умолчанию, выполняется поиск зависимых имен, проверяются ограничения семантики, и создание экземпляра любого шаблона, используемого в аргументе по умолчанию, выполняется, как если бы аргумент по умолчанию имел был инициализатором, используемым в специализации шаблона функции с той же областью действия, теми же параметрами шаблона и тем же доступом, что и у шаблона функции, f используемого в этой точке, за исключением того, что область, в которой объявлен тип закрытия ( [expr.prim.lambda.closure]) - и, следовательно, ее связанные пространства имен - остаются такими, как определено из контекста определения для аргумента по умолчанию. Этот анализ называется default argument instantiation. Созданный аргумент по умолчанию затем используется как аргумент f.

Каждый аргумент по умолчанию создается независимо. [ Example:

template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));

class  A { };

A zdef(A);

void g(A a, A b, A c) {
  f(a, b, c);       // no default argument instantiation
  f(a, b);          // default argument z = zdef(T()) instantiated
  f(a);             // ill-formed; ydef is not declared
}

 — end example ]

Специализация noexcept-specifierшаблона функции не создается вместе с объявлением функции; он создается при необходимости ( [except.spec]). Если такой объект noexcept-specifierнеобходим, но еще не создан, выполняется поиск зависимых имен, проверяются ограничения семантики, и создание экземпляра любого шаблона, используемого в, noexcept-specifierвыполняется так, как если бы оно было выполнено как часть создания экземпляра объявления объекта. специализация на этом этапе.

[  Note: [temp.point] определяет точку реализации специализации шаблона. ] — end note 

Существует количество, определяемое реализацией, которое указывает предел общей глубины рекурсивных экземпляров ( [implimits]), которые могут включать более одного шаблона. Результат бесконечной рекурсии при создании экземпляра не определен. [ Example:

template<class T> class X {
  X<T>* p;          // OK
  X<T*> a;          // implicit generation of X<T> requires
                    // the implicit instantiation of X<T*> which requires
                    // the implicit instantiation of X<T**> which …
};

 — end example ]

Специализация шаблона класса, функции, переменной или члена может быть явно создана из его шаблона. Функция-член, класс-член или статический член-данные шаблона класса могут быть явно созданы из определения члена, связанного с его шаблоном класса. Явное создание экземпляра шаблона функции или функции-члена шаблона класса не должно использовать спецификаторы inline или constexpr .

Синтаксис явного создания экземпляра:

explicit-instantiation:
	extern${}_{opt}$ template declaration

Есть две формы явного создания экземпляра: явное определение экземпляра и явное объявление экземпляра. Явное объявление экземпляра начинается с extern ключевого слова.

Если явная Инстанциация для класса или члена класса, elaborated-type-specifierв declarationдолжны включать в себя simple-template-id. Если явная Инстанциация для функции или члена функции, то unqualified-id в declaration должна быть либо template-id или, когда все аргументы шаблона может быть выведены, template-nameили operator-function-id. [  Note: Декларация может объявить qualified-id, в этом случае unqualified-id из qualified-id должно быть template-id. ] Если явное создание экземпляра предназначено для функции-члена, класса-члена или статического члена данных специализации шаблона класса, имя специализации шаблона класса в для имени члена должно быть . Если явное создание экземпляра предназначено для переменной, в объявлении должен быть . Явное создание экземпляра должно появиться во включающем пространстве имен своего шаблона. Если имя, объявленное в явном создании экземпляра, является неквалифицированным именем, явное создание экземпляра должно появиться в пространстве имен, в котором объявлен его шаблон, или, если это пространство имен является inline ( ), в любом пространстве имен из включающего его набора пространств имен. [ Относительно полных имен в деклараторах см . ] [ — end note qualified-idsimple-template-idunqualified-idtemplate-id[namespace.def] Note: [dcl.meaning] — end note  Example:

template<class T> class Array { void mf(); };
template class Array<char>;
template void Array<int>::mf();

template<class T> void sort(Array<T>& v) { /* ... */ }
template void sort(Array<char>&);       // argument is deduced here

namespace N {
  template<class T> void f(T&) { }
}
template void N::f<int>(int&);

 — end example ]

Объявление шаблона функции, шаблона переменной, функции-члена или статического члена данных шаблона класса или шаблона функции-члена класса или шаблона класса должно предшествовать явному созданию экземпляра этой сущности. Определение шаблона класса, класса-члена шаблона класса или шаблона класса-члена шаблона класса или класса должно предшествовать явному созданию экземпляра этой сущности, если только явному созданию экземпляра не предшествует явная специализация сущности с тем же аргументы шаблона. Если declaration явное создание именует неявно объявленное special member function, программа имеет неправильный формат .

Для заданного набора аргументов шаблона, если явное создание экземпляра шаблона появляется после объявления явной специализации для этого шаблона, явное создание экземпляра не имеет никакого эффекта. В противном случае для явного определения экземпляра определение шаблона функции, шаблона переменной, шаблона функции-члена или функции-члена или статического члена данных шаблона класса должно присутствовать в каждой единице перевода, в которой он явно создан.

Явное создание экземпляра класса, шаблона функции или специализации шаблона переменной помещается в пространство имен, в котором определен шаблон. Явное создание экземпляра члена шаблона класса помещается в пространство имен, в котором определен включающий шаблон класса. Явное создание экземпляра шаблона члена помещается в пространство имен, в котором определен включающий класс или шаблон класса. [ Example:

namespace N {
  template<class T> class Y { void mf() { } };
}

template class Y<int>;          // error: class template Y not visible in the global namespace

using N::Y;
template class Y<int>;          // error: explicit instantiation outside of the namespace of the template

template class N::Y<char*>;             // OK: explicit instantiation in namespace N
template void N::Y<double>::mf();       // OK: explicit instantiation in namespace N

 — end example ]

Конечный конец template-argument можно оставить неопределенным при явном создании экземпляра специализации шаблона функции или специализации шаблона функции-члена при условии, что он может быть выведен из типа параметра функции ( [temp.deduct]). [ Example:

template<class T> class Array { /* ... */ };
template<class T> void sort(Array<T>& v) { /* ... */ }

// instantiate sort(Array<int>&) – template-argument deduced
template void sort<>(Array<int>&);

 — end example ]

Явное создание экземпляра, которое именует специализацию шаблона класса, также является явным экземпляром того же типа (объявление или определение) каждого из его членов (не включая элементы, унаследованные от базовых классов, и элементы, которые являются шаблонами), который ранее не был явно специализирован в единица трансляции, содержащая явное создание экземпляра, за исключением случаев, описанных ниже. [  Note: Кроме того, это обычно будет явным экземпляром определенных данных о классе, зависящих от реализации. ]  — end note 

Явное определение экземпляра, которое именует специализацию шаблона класса, явно создает экземпляр специализации шаблона класса и является явным определением экземпляра только тех членов, которые были определены в точке создания экземпляра.

За исключением встроенных функций и переменных, объявления с типами, выведенными из их инициализатора или возвращаемого значения ( [dcl.spec.auto]), const переменных литеральных типов, переменных ссылочных типов и специализаций шаблонов классов, явные объявления создания экземпляров имеют эффект подавления неявного создания экземпляра объекта для на которые они ссылаются. [  Note: Намерение состоит в том, чтобы встроенная функция, являющаяся предметом явного объявления экземпляра, по-прежнему odr-used создавалась неявно, когда так, чтобы тело можно было рассматривать для встраивания, но чтобы внешняя копия встроенной функции не создавалась в единица перевода. ] — end note 

Если объект является предметом как явного объявления создания экземпляра, так и явного определения экземпляра в одной и той же единице преобразования, определение должно следовать за объявлением. Сущность, которая является предметом явного объявления экземпляра и который также используется таким образом, который в противном случае вызвал бы implicit instantiation в блоке преобразования, должен быть предметом явного определения экземпляра где-то в программе; в противном случае программа имеет неправильный формат, и диагностика не требуется. [  Note: Это правило применяется к встроенным функциям, даже если явное объявление экземпляра такой сущности не имеет другого нормативного эффекта. Это необходимо для того, чтобы гарантировать, что если адрес встроенной функции будет взят в блоке трансляции, в котором реализация решила подавить внешнее тело, другая единица трансляции предоставит тело. ] Явное объявление экземпляра не должно называть специализацию шаблона с внутренней связью. — end note 

Обычные правила проверки доступа не применяются к именам, используемым для указания явных экземпляров. [  Note: В частности, аргументы и имена шаблона, используемые в деклараторе функции (включая типы параметров, возвращаемые типы и спецификации исключений), могут быть частными типами или объектами, которые обычно недоступны, а шаблон может быть шаблоном члена или функцией-членом, которая будет обычно недоступны. ] — end note 

Явное создание экземпляра не означает использование аргумента по умолчанию, поэтому создание экземпляра аргумента по умолчанию не выполняется. [ Example:

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

 — end example ]

Явная специализация любого из следующего:

• (1.1)

  шаблон функции

• (1.2)

  шаблон класса

• (1.3)

  шаблон переменных

• (1.4)

  функция-член шаблона класса

• (1.5)

  статический член данных шаблона класса

• (1.6)

  класс-член шаблона класса

• (1.7)

  перечисление членов шаблона класса

• (1.8)

  шаблон класса члена класса или шаблона класса

• (1.9)

  шаблон функции-члена класса или шаблона класса

может быть объявлено посредством объявления, представленного template<>; то есть:

explicit-specialization:
	template < > declaration

[ Example:

template<class T> class stream;

template<> class stream<char> { /* ... */ };

template<class T> class Array { /* ... */ };
template<class T> void sort(Array<T>& v) { /* ... */ }

template<> void sort<char*>(Array<char*>&);

Учитывая эти объявления, stream<char> будет использоваться как определение потоков chars; другие потоки будут обрабатываться специализациями шаблонов классов, созданными из шаблона класса. Точно так же sort<char*> будет использоваться функция сортировки для аргументов типа Array<char*>; другие Array типы будут отсортированы по функциям, сгенерированным из шаблона. ] — end example 

Явная специализация может быть объявлена в любой области , в которой может быть определен соответствующий первичный шаблон ( [namespace.memdef], [class.mem], [temp.mem]).

Объявление явной специализации шаблона функции, шаблона класса или шаблона переменной должно предшествовать объявлению явной специализации. [  Note: Требуется декларация, но не определение шаблона. ] Определение класса или шаблона класса должно предшествовать объявлению явной специализации для шаблона члена этого класса или шаблона класса. [ — end note  Example:

template<> class X<int> { /* ... */ };          // error: X not a template

template<class T> class X;

template<> class X<char*> { /* ... */ };        // OK: X is a template

 — end example ]

Функция-член, шаблон функции-члена, класс-член, перечисление члена, шаблон класса-члена, статический член-данные или статический элемент-данные-шаблон шаблона класса могут быть явно специализированы для неявно создаваемой специализации класса; в этом случае определение шаблона класса должно предшествовать явной специализации для члена шаблона класса. Если такая явная специализация для члена шаблона класса называет неявно объявленную специальную функцию-член (предложение [special]), программа плохо сформирована.

Член явно специализированного класса не создается неявно из объявления члена шаблона класса; вместо этого член специализации шаблона класса должен быть явно определен, если требуется его определение. В этом случае определение явной специализации шаблона класса должно входить в область видимости в точке, в которой определяется член. Определение явно специализированного класса не связано с определением сгенерированной специализации. То есть его члены не обязательно должны иметь те же имена, типы и т. Д., Что и члены сгенерированной специализации. Члены явно специализированного шаблона класса определяются так же, как члены обычных классов, и не используют template<> синтаксис. То же самое верно и при определении члена явно специализированного класса-члена. Однако template<> он используется при определении члена явно специализированного шаблона класса члена, который специализирован как шаблон класса. [ Example:

template<class T> struct A {
  struct B { };
  template<class U> struct C { };
};

template<> struct A<int> {
  void f(int);
};

void h() {
  A<int> a;
  a.f(16);          // A<int>​::​f must be defined somewhere
}

// template<> not used for a member of an explicitly specialized class template
void A<int>::f(int) { /* ... */ }

template<> struct A<char>::B {
  void f();
};
// template<> also not used when defining a member of an explicitly specialized member class
void A<char>::B::f() { /* ... */ }

template<> template<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 template
template<>
template<class U> void A<char>::C<U>::f() { /* ... */ }

template<> struct A<short>::B {
  void f();
};
template<> void A<short>::B::f() { /* ... */ }              // error: template<> not permitted

template<> template<class U> struct A<short>::C {
  void f();
};
template<class U> void A<short>::C<U>::f() { /* ... */ }    // error: template<> required

 — end example ]

Если шаблон, шаблон члена или член шаблона класса явно специализирован, тогда эта специализация должна быть объявлена ​​перед первым использованием этой специализации, которая вызовет неявное создание экземпляра, в каждой единице перевода, в которой происходит такое использование. ; Диагностика не требуется. Если программа не предоставляет определение для явной специализации и либо специализация используется таким образом, что может иметь место неявное создание экземпляра, либо член является виртуальной функцией-членом, программа имеет неправильный формат, диагностика не требуется. Неявное создание экземпляра никогда не создается для явной специализации, которая объявлена, но не определена. [ Example:

class String { };
template<class T> class Array { /* ... */ };
template<class T> void sort(Array<T>& v) { /* ... */ }

void f(Array<String>& v) {
  sort(v);          // use primary template sort(Array<T>&), T is String
}

template<> void sort<String>(Array<String>& v);     // error: specialization after use of primary template
template<> void sort<>(Array<char*>& v);            // OK: sort<char*> not yet used
template<class T> struct A {
  enum E : T;
  enum class S : T;
};
template<> enum A<int>::E : int { eint };           // OK
template<> enum class A<int>::S : int { sint };     // OK
template<class T> enum A<T>::E : T { eT };
template<class T> enum class A<T>::S : T { sT };
template<> enum A<char>::E : char { echar };        // ill-formed, A<char>​::​E was instantiated
                                                    // when A<char> was instantiated
template<> enum class A<char>::S : char { schar };  // OK

 — end example ]

Размещение явных объявлений специализации для шаблонов функций, шаблонов классов, шаблонов переменных, функций-членов шаблонов классов, статических элементов данных шаблонов классов, классов-членов шаблонов классов, перечислений элементов шаблонов классов, шаблонов классов-членов шаблонов классов, функций-членов шаблоны шаблонов классов, шаблоны элементов статических данных шаблонов классов, функции-члены шаблонов-членов шаблонов классов, функции-члены шаблонов-членов нешаблонных классов, шаблоны элементов статических данных нешаблонных классов, шаблоны функций-членов классов-членов шаблоны классов и т. д., а также размещение объявлений частичной специализации шаблонов классов, шаблонов переменных, шаблонов классов-членов нешаблонных классов, статических шаблонов элементов данных нешаблонных классов, шаблонов классов-членов шаблонов классов и т. д. влияет на то, правильно ли сформирована программа в соответствии с относительным расположением явной спецификации lization и их точки создания в блоке перевода, как указано выше и ниже. При написании специализации внимательно относитесь к ее расположению; или заставить его скомпилировать будет такое испытание, чтобы разжечь его самосожжение.

Явная специализация шаблона находится в области пространства имен, в котором был определен шаблон. [ Example:

namespace N {
  template<class T> class X { /* ... */ };
  template<class T> class Y { /* ... */ };

  template<> class X<int> { /* ... */ };        // OK: specialization in same namespace
  template<> class Y<double>;                   // forward-declare intent to specialize for double
}

template<> class N::Y<double> { /* ... */ };    // OK: specialization in enclosing namespace
template<> class N::Y<short> { /* ... */ };     // OK: specialization in enclosing namespace

 — end example ]

Объект, simple-template-id который называет явную специализацию шаблона класса, которая была объявлена, но не определена, может использоваться точно так же, как имена других не полностью определенных классов ( [basic.types]). [ Example:

template<class T> class X;                      // X is a class template
template<> class X<int>;

X<int>* p;                                      // OK: pointer to declared class X<int>
X<int> x;                                       // error: object of incomplete class X<int>

 — end example ]

Конечный конец template-argument можно не указывать в template-id явном названии специализации шаблона функции, при условии, что он может быть выведен из типа аргумента функции. [ Example:

template<class T> class Array { /* ... */ };
template<class T> void sort(Array<T>& v);

// explicit specialization for sort(Array<int>&)
// with deduced template-argument of type int
template<> void sort(Array<int>&);

 — end example ]

Функция с тем же именем, что и шаблон, и типом, который точно соответствует специализации шаблона, не является явной специализацией ( [temp.fct]).

Явная специализация шаблона функции или переменной является встроенной, только если она объявлена ​​со inline спецификатором или определена как удаленная, и независимо от того, является ли ее шаблон функции или переменной встроенным. [ Example:

template<class T> void f(T) { /* ... */ }
template<class T> inline T g(T) { /* ... */ }

template<> inline void f<>(int) { /* ... */ }   // OK: inline
template<> int g<>(int) { /* ... */ }           // OK: not inline

 — end example ]

Явная специализация статического элемента данных шаблона или явная специализация шаблона статического элемента данных является определением, если объявление включает инициализатор; в противном случае это декларация. [  Note: Определение статического элемента данных шаблона, который требует инициализации по умолчанию, должно использовать braced-init-list:

template<> X Q<int>::x;                         // declaration
template<> X Q<int>::x ();                      // error: declares a function
template<> X Q<int>::x { };                     // definition

 — end note ]

Член или шаблон члена шаблона класса может быть явно специализирован для данного неявного создания экземпляра шаблона класса, даже если член или шаблон члена определен в определении шаблона класса. Явная специализация элемента или шаблона элемента указывается с использованием синтаксиса явной специализации. [ Example:

template<class T> struct A {
  void f(T);
  template<class X1> void g1(T, X1);
  template<class X2> void g2(T, X2);
  void h(T) { }
};

// specialization
template<> void A<int>::f(int);

// out of class member template definition
template<class T> template<class X1> void A<T>::g1(T, X1) { }

// member template specialization
template<> template<class X1> void A<int>::g1(int, X1);

// member template specialization
template<> template<>
  void A<int>::g1(int, char);           // X1 deduced as char
template<> template<>
  void A<int>::g2<char>(int, char);     // X2 specified as char

// member specialization even if defined in class definition
template<> void A<int>::h(int) { }

 — end example ]

Член или шаблон члена могут быть вложены во многие шаблоны включающих классов. При явной специализации для такого члена объявлению члена должен предшествовать a template<> для каждого шаблона включающего класса, который явно специализирован. [ Example:

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

 — end example ]

В явном объявлении специализации для члена шаблона класса или шаблона члена, который появляется в области пространства имен, шаблон члена и некоторые из включающих его шаблонов классов могут оставаться неспециализированными, за исключением того, что объявление не должно явно специализировать шаблон члена класса, если его шаблоны включающих классов также не являются явно специализированными. В таком явном объявлении специализации должно быть предоставлено ключевое слово, template за которым следует a template-parameter-list, вместо template<> предшествующего явного объявления специализации члена. Типы template-parameters в template-parameter-list должны быть такими же, как те, которые указаны в определении первичного шаблона. [ Example:

template <class T1> class A {
  template<class T2> class B {
    template<class T3> void mf1(T3);
    void mf2();
  };
};
template <> template <class X>
  class A<int>::B {
      template <class T> void mf1(T);
  };
template <> template <> template<class T>
  void A<int>::B<double>::mf1(T t) { }
template <class Y> template <>
  void A<Y>::B<double>::mf2() { }       // ill-formed; B<double> is specialized but
                                        // its enclosing class template A is not

 — end example ]

Специализация шаблона функции-члена, шаблона класса-члена или шаблона статических данных-члена неспециализированного шаблона класса сама по себе является шаблоном.

Явное объявление специализации не должно быть дружественным объявлением.

Аргументы функции по умолчанию не должны указываться в объявлении или определении для одной из следующих явных специализаций:

• (19.1)

  явная специализация шаблона функции;

• (19.2)

  явная специализация шаблона функции-члена;

• (19.3)

  явная специализация функции-члена шаблона класса, где неявно создается экземпляр специализации шаблона класса, к которой принадлежит специализация функции-члена. [  Note: Аргументы функции по умолчанию могут быть указаны в объявлении или определении функции-члена специализации шаблона класса, которая является явно специализированной. ]  — end note 

Аргументы шаблона могут быть указаны при ссылке на специализацию шаблона функции путем уточнения имени шаблона функции списком template-arguments таким же образом, как template-arguments это указывается при использовании специализации шаблона класса. [ Example:

template<class T> void sort(Array<T>& v);
void f(Array<dcomplex>& cv, Array<int>& ci) {
  sort<dcomplex>(cv);                   // sort(Array<dcomplex>&)
  sort<int>(ci);                        // sort(Array<int>&)
}

а также

template<class U, class V> U convert(V v);

void g(double d) {
  int i = convert<int,double>(d);       // int convert(double)
  char c = convert<char,double>(d);     // char convert(double)
}

 — end example ]

Список аргументов шаблона может быть указан при ссылке на специализацию шаблона функции.

• (2.1)

  когда функция вызывается,

• (2.2)

  когда берется адрес функции, когда функция инициализирует ссылку на функцию или когда формируется указатель на функцию-член,

• (2.3)

  в явной специализации,

• (2.4)

  в явном экземпляре, или

• (2.5)

  в объявлении друга.

Конечные аргументы шаблона, которые могут быть deduced или получены по умолчанию, template-arguments могут быть исключены из списка явных template-arguments. Завершающий, template parameter pack не выведенный иным образом, будет выведен в пустую последовательность аргументов шаблона. Если все аргументы шаблона могут быть выведены, все они могут быть опущены; в этом случае сам пустой список аргументов шаблона <> также может быть опущен. В контекстах, где дедукция выполняется и терпит неудачу, или в контекстах, где дедукция не выполняется, если указан список аргументов шаблона и он, вместе с любыми аргументами шаблона по умолчанию, идентифицирует одну специализацию шаблона функции, тогда template-id это lvalue для функции специализация шаблона. [ Example:

template<class X, class Y> X f(Y);
template<class X, class Y, class ... Z> X g(Y);
void h() {
  int i = f<int>(5.6);          // Y is deduced to be double
  int j = f(5.6);               // ill-formed: X cannot be deduced
  f<void>(f<int, bool>);        // Y for outer f deduced to be int (*)(bool)
  f<void>(f<int>);              // ill-formed: f<int> does not denote a single function template specialization
  int k = g<int>(5.6);          // Y is deduced to be double, Z is deduced to an empty sequence
  f<void>(g<int, bool>);        // Y for outer f is deduced to be int (*)(bool),
                                // Z is deduced to an empty sequence
}

 — end example ]

[  Note: Пустой список аргументов шаблона может использоваться, чтобы указать, что данное использование относится к специализации шаблона функции, даже если [dcl.fct]видна не являющаяся шаблоном функция ( ), которая в противном случае использовалась бы. Например:

template <class T> int f(T);    // #1
int f(int);                     // #2
int k = f(1);                   // uses #2
int l = f<>(1);                 // uses #1

 — end note ]

Присутствующие аргументы шаблона должны быть указаны в порядке объявления их соответствующих template-parameters. Список аргументов шаблона не должен указывать больше, template-arguments чем есть соответствующие, template-parameters если один из них не template-parameters является пакетом параметров шаблона. [ Example:

template<class X, class Y, class Z> X f(Y,Z);
template<class ... Args> void f2();
void g() {
  f<int,const char*,double>("aa",3.0);
  f<int,const char*>("aa",3.0); // Z is deduced to be double
  f<int>("aa",3.0);             // Y is deduced to be const char*, and Z is deduced to be double
  f("aa",3.0);                  // error: X cannot be deduced
  f2<char, short, int, long>(); // OK
}

 — end example ]

Неявные преобразования (Clause [conv]) будут выполнены для аргумента функции, чтобы преобразовать его в тип соответствующего параметра функции, если тип параметра не содержит никаких, template-parameters которые участвуют в выводе аргумента шаблона. [  Note: Параметры шаблона не участвуют в выводе аргументов шаблона, если они явно указаны. Например,

template<class T> void f(T);

class Complex {
  Complex(double);
};

void g() {
  f<Complex>(1);    // OK, means f<Complex>(Complex(1))
}

 — end note ]

[  Note: Поскольку явный список аргументов шаблона следует за именем шаблона функции и поскольку шаблоны функций-членов преобразования и шаблоны функций-членов конструктора вызываются без использования имени функции, невозможно предоставить явный список аргументов шаблона для этих шаблонов функций. ] — end note 

[  Note: Для простых имен функций argument dependent lookup применяется, даже если имя функции не отображается в рамках вызова. Это потому, что вызов по-прежнему имеет синтаксическую форму вызова функции ( [basic.lookup.unqual]). Но когда используется шаблон функции с явными аргументами шаблона, вызов не имеет правильной синтаксической формы, если не существует шаблона функции с таким именем, видимого в точке вызова. Если такое имя не отображается, вызов не имеет синтаксической правильной формы и поиск, зависящий от аргументов, не применяется. Если такое имя видно, применяется поиск, зависящий от аргументов, и дополнительные шаблоны функций могут быть найдены в других пространствах имен. [ Example:

namespace A {
  struct B { };
  template<int X> void f(B);
}
namespace C {
  template<class T> void f(T t);
}
void g(A::B b) {
  f<3>(b);          // ill-formed: not a function call
  A::f<3>(b);       // well-formed
  C::f<3>(b);       // ill-formed; argument dependent lookup applies only to unqualified names
  using C::f;
  f<3>(b);          // well-formed because C​::​f is visible; then A​::​f is found by argument dependent lookup
}

 — end example ] ] — end note 

Вывод аргументов шаблона может расширить последовательность аргументов шаблона, соответствующую пакету параметров шаблона, даже если последовательность содержит явно указанные аргументы шаблона. [ Example:

template<class ... Types> void f(Types ... values);

void g() {
  f<int*, float*>(0, 0, 0);     // Types is deduced to the sequence int*, float*, int
}

 — end example ]

При ссылке на специализацию шаблона функции все аргументы шаблона должны иметь значения. Значения могут быть явно указаны или, в некоторых случаях, выведены из использования или получены по умолчанию template-arguments. [ Example:

void f(Array<dcomplex>& cv, Array<int>& ci) {
  sort(cv);                     // calls sort(Array<dcomplex>&)
  sort(ci);                     // calls sort(Array<int>&)
}

а также

void g(double d) {
  int i = convert<int>(d);      // calls convert<int,double>(double)
  int c = convert<char>(d);     // calls convert<char,double>(double)
}

 — end example ]

Если указан явный список аргументов шаблона, аргументы шаблона должны быть совместимы со списком параметров шаблона и должны приводить к допустимому типу функции, как описано ниже; в противном случае определение типа не удастся. В частности, при оценке явно указанного списка аргументов шаблона по отношению к заданному шаблону функции выполняются следующие шаги:

• (2.1)

  Указанные аргументы шаблона должны соответствовать параметрам шаблона в натуральном выражении (т. Е. Тип, не тип, шаблон). Аргументов не должно быть больше, чем параметров, если хотя бы один параметр не является пакетом параметров шаблона, и должен быть аргумент для каждого параметра, не являющегося пакетом. В противном случае определение типа не удастся.

• (2.2)

  Аргументы, не являющиеся типами, должны соответствовать типам соответствующих параметров шаблона, не являющихся типами, или должны быть преобразованы в типы соответствующих параметров, не являющихся типами, как указано в [temp.arg.nontype], в противном случае определение типа завершится ошибкой.

• (2.3)

  Указанные значения аргументов шаблона заменяются соответствующими параметрами шаблона, как указано ниже.

После выполнения этой замены выполняются настройки типа параметра функции, описанные в [dcl.fct] . [  Example: Тип параметра « void (const int, int[5])» становится « void(*)(int,int*)». ] [ Квалификатор верхнего уровня в объявлении параметра функции не влияет на тип функции, но по-прежнему влияет на тип переменной параметра функции внутри функции. ] [ — end example  Note:  — end note  Example:

template <class T> void f(T t);
template <class X> void g(const X x);
template <class Z> void h(Z, Z*);

int main() {
  // #1: function type is f(int), t is non const
  f<int>(1);

  // #2: function type is f(int), t is const
  f<const int>(1);

  // #3: function type is g(int), x is const
  g<int>(1);

  // #4: function type is g(int), x is const
  g<const int>(1);

  // #5: function type is h(int, const int*)
  h<const int>(1,0);
}

 — end example ]

[  Note: f<int>(1) и f<const int>(1) вызывают разные функции, даже если обе вызываемые функции имеют один и тот же тип функции. ] — end note 

Результирующий замещенный и скорректированный тип функции используется в качестве типа шаблона функции для вывода аргументов шаблона. Если аргумент шаблона не был выведен и соответствующий ему параметр шаблона имеет аргумент по умолчанию, аргумент шаблона определяется путем замены аргументов шаблона, определенных для предыдущих параметров шаблона, в аргумент по умолчанию. Если замена приводит к недопустимому типу, как описано выше, определение типа не выполняется. [ Example:

template <class T, class U = double>
void f(T t = 0, U u = 0);

void g() {
  f(1, 'c');        // f<int,char>(1,'c')
  f(1);             // f<int,double>(1,0)
  f();              // error: T cannot be deduced
  f<int>();         // f<int,double>(0,0)
  f<int,char>();    // f<int,char>(0,0)
}

 — end example ]

Когда все аргументы шаблона были выведены или получены из аргументов шаблона по умолчанию, все случаи использования параметров шаблона в списке параметров шаблона и типе функции заменяются соответствующими выведенными значениями аргументов или значениями аргументов по умолчанию. Если замена приводит к недопустимому типу, как описано выше, определение типа не выполняется.

В определенных точках процесса вывода аргументов шаблона необходимо выбрать тип функции, который использует параметры шаблона, и заменить эти параметры шаблона соответствующими аргументами шаблона. Это делается в начале вывода аргументов шаблона, когда любые явно указанные аргументы шаблона подставляются в тип функции, и снова в конце вывода аргументов шаблона, когда заменяются любые аргументы шаблона, которые были выведены или получены из аргументов по умолчанию.

Подстановка происходит во всех типах и выражениях, которые используются в типе функции и в объявлениях параметров шаблона. Выражения включают в себя не только постоянные выражения , такие как те , которые появляются в пределах массива или в качестве аргументов шаблона нетипового , но и общих выражений (т.е. непостоянных выражений) внутри sizeof, decltypeи других контекстов , которые позволяют непостоянные выражения. Подстановка выполняется в лексическом порядке и останавливается, когда встречается условие, которое приводит к сбою дедукции. [  Note: Эквивалентная подстановка в спецификациях исключений выполняется только тогда, когда noexcept-specifierсоздается экземпляр, и в этот момент программа формируется неправильно, если в результате подстановки возникает недопустимый тип или выражение. ] [  — end note  Example:

template <class T> struct A { using X = typename T::X; };
template <class T> typename T::X f(typename A<T>::X);
template <class T> void f(...) { }
template <class T> auto g(typename A<T>::X) -> typename T::X;
template <class T> void g(...) { }

void h() {
  f<int>(0);        // OK, substituting return type causes deduction to fail
  g<int>(0);        // error, substituting parameter type instantiates A<int>
}

 — end example ]

Если подстановка приводит к недопустимому типу или выражению, определение типа не выполняется. Недопустимый тип или выражение - это тот, который был бы неправильно сформирован и потребовал бы диагностики, если бы он был записан с использованием подставленных аргументов. [  Note: Если диагностика не требуется, программа все еще плохо сформирована. Проверка доступа выполняется как часть процесса замены. ] Только недопустимые типы и выражения в непосредственном контексте типа функции и его типов параметров шаблона могут привести к сбою вывода. [ Подстановка типов и выражений может привести к таким эффектам, как создание экземпляров специализаций шаблонов классов и / или специализаций шаблонов функций, создание неявно определенных функций и т. Д. Такие эффекты не находятся в «непосредственном контексте» и могут привести к программа плохо сформирована. ]  — end note  Note:  — end note 

[ Example:

struct X { };
struct Y {
  Y(X){}
};

template <class T> auto f(T t1, T t2) -> decltype(t1 + t2);     // #1
X f(Y, Y);          // #2

X x1, x2;
X x3 = f(x1, x2);   // deduction fails on #1 (cannot add X+X), calls #2

 — end example ]

[  Note: Вычет типа может не работать по следующим причинам:

• (8.1)

  Попытка создать экземпляр расширения пакета, содержащего несколько пакетов параметров разной длины.

• (8.2)

  Попытка создать массив с типом элемента, то есть voidтипом функции, типом ссылки или типом абстрактного класса, или попытка создать массив с нулевым или отрицательным размером. [ Example:

  template <class T> int f(T[5]);
  int I = f<int>(0);
  int j = f<void>(0);             // invalid array
  

   — end example ]

• (8.3)

  Попытка использовать тип, который не является типом класса или перечисления, в квалифицированном имени. [ Example:

  template <class T> int f(typename T::B*);
  int i = f<int>(0);

   — end example ]

• (8.4)

  Попытка использовать тип в a nested-name-specifierиз a, qualified-idкогда этот тип не содержит указанный член, или

  • (8.4.1)

    указанный член не является типом, для которого требуется тип, или

  • (8.4.2)

    указанный член не является шаблоном, в котором шаблон требуется, или

  • (8.4.3)

    указанный член не является не типом, где не требуется тип.

  [ Example:

  template <int I> struct X { };
  template <template <class T> class> struct Z { };
  template <class T> void f(typename T::Y*){}
  template <class T> void g(X<T::N>*){}
  template <class T> void h(Z<T::template TT>*){}
  struct A {};
  struct B { int Y; };
  struct C {
    typedef int N;
  };
  struct D {
    typedef int TT;
  };
  
  int main() {
    // Deduction fails in each of these cases:
    f<A>(0);          // A does not contain a member Y
    f<B>(0);          // The Y member of B is not a type
    g<C>(0);          // The N member of C is not a non-type
    h<D>(0);          // The TT member of D is not a template
  }

   — end example ]

• (8.5)

  Попытка создать указатель на ссылочный тип.

• (8.6)

  Попытка создать ссылку на void.

• (8.7)

  Попытка создать «указатель на член T», когда T это не класс. [ Example:

  template <class T> int f(int T::*);
  int i = f<int>(0);

   — end example ]

• (8.8)

  Попытка присвоить недопустимый тип параметру шаблона, не являющемуся типом. [ Example:

  template <class T, T> struct S {};
  template <class T> int f(S<T, T()>*);
  struct X {};
  int i0 = f<X>(0);

   — end example ]

• (8.9)

  Попытка выполнить недопустимое преобразование в выражении аргумента шаблона или в выражении, используемом в объявлении функции. [ Example:

  template <class T, T*> int f(int);
  int i2 = f<int,1>(0);           // can't conv 1 to int*
  

   — end example ]

• (8.10)

  Попытка создать тип функции, в котором параметр имеет тип voidили возвращаемый тип является типом функции или типом массива.

• (8.11)

  Попытка создать тип функции, в котором тип параметра или возвращаемый тип - это abstract class type.

 — end note ]

[  Example: В следующем примере, предполагая, что a signed char не может представлять значение 1000, a narrowing conversion потребуется для преобразования template-argument типа int в signed char, поэтому подстановка не выполняется для второго шаблона ( [temp.arg.nontype]).

template <int> int f(int);
template <signed char> int f(int);
int i1 = f<1000>(0);            // OK
int i2 = f<1>(0);               // ambiguous; not narrowing

 — end example ]