関数テンプレート

template<typename T>
void f(T s)
{
    std::cout << s << '\n';
}
 
template void f<double>(double); // f<double>(double) 実体化します。
template void f<>(char); // f<char>(char) を実体化します (テンプレート引数は推定されます)。
template void f(int); // f<int>(int) を実体化します (テンプレート引数は推定されます)。

char* p = 0;
template<class T> T g(T x = &p) { return x; }
template int g<int>(int);   // &p は int ではありませんが、 OK です。

template<typename To, typename From> To convert(From f);
 
void g(double d) 
{
    int i = convert<int>(d); // convert<int, double>(double) を実体化して呼びます。
    char c = convert<char>(d); // convert<char, double>(double) を実体化して呼びます。
    int(*ptr)(float) = convert; // convert<int, float>(float) を実体化します。
}

#include <iostream>
int main() 
{
    std::cout << "Hello, world" << std::endl;
    // operator<< が ADL を通して std::operator<< として探索され、
    // その後、 operator<<<char, std::char_traits<char>> と推定されます (両方とも)。
    // std::endl は &std::endl<char, std::char_traits<char>> と推定されます。
}

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

template <class T> void f(T t);
template <class X> void g(const X x);
template <class Z> void h(Z z, Z* zp);
 
// 同じ型を持つ2つの異なる関数。
// しかし関数内では、 t は異なる cv 修飾を持ちます。
f<int>(1);       // 関数の型は void(int) です。 t は int です。
f<const int>(1); // 関数の型は void(int) です。 t は const int です。
 
// 同じ型と同じ x を持つ2つの異なる関数。
// (これらの2つの関数へのポインタは等しくなく、
// 関数ローカルな static 変数は異なるアドレスを持ちます。)
g<int>(1);       // 関数の型は void(int) です。 x は const int です。
g<const int>(1); // 関数の型は void(int) です。 x は const int です。
 
// 最上段の cv 修飾のみが取り除かれます。
h<const int>(1, NULL); // 関数の型は void(int, const int*) です。
                       // z は const int です。 zp は const int* です。

template<int I, int J> A<I+J> f(A<I>, A<J>); // オーバーロード #1。
template<int K, int L> A<K+L> f(A<K>, A<L>); // #1 と同じ。
template<int I, int J> A<I-J> f(A<I>, A<J>); // オーバーロード #2。

template <int I, int J> void f(A<I+J>);  // テンプレートオーバーロード #1。
template <int K, int L> void f(A<K+L>);  // #1 と同等です。

// 同等。
template <int I> void f(A<I>, A<I+10>); // オーバーロード #1。
template <int I> void f(A<I>, A<I+10>); // オーバーロード #1 の再宣言。
 
// 同等でない。
template <int I> void f(A<I>, A<I+10>); // オーバーロード #1。
template <int I> void f(A<I>, A<I+11>); // オーバーロード #2。
 
// 機能的に同等だけれども同等でない。
// このプログラムは ill-formed です (診断は要求されません)。
template <int I> void f(A<I>, A<I+10>); // オーバーロード #1。
template <int I> void f(A<I>, A<I+1+2+3+4>); // オーバーロード #1 と機能的に同等。

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; // int B<A>::operator*(R&) に対するテンプレートの実引数推定は R=A を与えます。
         // int operator*(T&, R&)に対するテンプレートの実引数推定は T=B<A>, R=A を与えます。
// 半順序の目的のために、メンバテンプレート B<A>::operator* は
// template<class R> int operator*(B<A>&, R&); に変換されます。
// int operator*(   T&, R&)  T=B<A>, R=A と
// int operator*(B<A>&, R&)  R=A の間の半順序は、
// より特殊化されている方として int operator*(B<A>&, A&) を選択します。

template<class T> void f(T);        // テンプレート #1
template<class T> void f(T*);       // テンプレート #2
template<class T> void f(const T*); // テンプレート #3
void m() {
  const int* p;
  f(p); // オーバーロード解決により以下がピックアップされます。
        // #1: void f(T ) [T = const int *]
        // #2: void f(T*) [T = const int]
        // #3: void f(const T *) [T = int]
// 半順序:
// 変換された #2 から #1: void(U1*) から void(T): A=U1*, P=T: 推定成功: T=U1*
// 変換された #1 から #2: void(U1) から void(T*): A=U1, P=T*: 推定失敗
// T に関して #2 は #1 より特殊化されています。
// 変換された #3 から #1: void(const U1*) から void(T): A=const U1*, P=T: 成功: T=const U1*
// 変換された #1 から #3: void(U1) から void(const T*): A=U1, P=const T*: 失敗
// T に関して #3 は #1 より特殊化されています。
// 変換された #3 から #2: void(const U1*) から void(T*): A=const U1*, P=T*: 成功: T=const U1
// 変換された #2 から #3: void(U1*) から void(const T*): A=U1*, P=const T*: 失敗
// T に関して #3 は #2 より特殊化されています。
// 結果: #3 が選択されます。
// 別の言い方をすると、 f(const T*) は f(T) や f(T*) より特殊化されています。
}

template<class T> void f(T, T*);    // #1
template<class T> void f(T, int*);  // #2
void m(int* p) {
    f(0, p); // #1 に対する推定: void f(T, T*) [T = int]
             // #2 に対する推定: void f(T, int*) [T = int]
 // 半順序:
 // #2 から #1: void(U1,int*) から void(T,T*): A1=U1, P1=T: T=U1
 //                                           A2=int*, P2=T*: T=int: 失敗
 // #1 から #2: void(U1,U2*) から void(T,int*): A1=U1, P1=T: T=U1
 //                                            A2=U2*, P2=int*: 失敗
 // T に関してどちらもより特殊化されていません。 呼び出しは曖昧です。
}

template<class T> void g(T);  // テンプレート #1
template<class T> void g(T&); // テンプレート #2
void m() {
  float x;
  g(x); // #1 からの推定: void g(T ) [T = float]
        // #2 からの推定: void g(T&) [T = float]
// 半順序:
// #2 から #1: void(U1&) から void(T): A=U1 (調節後), P=T: 成功
// #1 から #2: void(U1) から void(T&): A=U1, P=T (調節後): 成功
// T に関してどちらもより特殊化されていません。 呼び出しは曖昧です。
}

template<class T> struct A { A(); };
 
template<class T> void h(const T&); // #1
template<class T> void h(A<T>&);    // #2
void m() {
  A<int> z;
  h(z);  // #1 からの推定: void h(const T &) [T = A<int>]
         // #2 からの推定: void h(A<T> &) [T = int]
 // 半順序:
 // #2 から #1: void(A<U1>&) から void(const T&): A=A<U1>, P=T: 成功: T=A<U1>
 // #1 から #2: void(const U1&) から void(A<T>&): A=const U1, P=A<T>: 失敗
 // T に関して #2 は #1 より特殊化されています。
 
  const A<int> z2;
  h(z2); // #1 からの推定: void h(const T&) [T = A<int>]
         // #2 からの推定: void h(A<T>&) [T = int] (しかし置換は失敗します)
 // 選択肢となるオーバーロードはひとつしかなく、半順序は試みられません。 #1 が呼ばれます。
}

template<class T>  void  f(T);               // #1
template<class T>  void  f(T*, int=1);       // #2
void m(int* ip) {
  int* ip;
  f(ip);     // #2 を呼びます (T* は T より特殊化されています)。
}

template<class  T>  void  g(T);               // #1
template<class  T>  void  g(T*, ...);         // #2
void m(int* ip) {
   g(ip);     // #2 を呼びます (T* は T より特殊化されています)。
}

template<class T, class U> struct A { };
template<class T, class U> void f(U, A<U,T>* p = 0); // #1
template<         class U> void f(U, A<U,U>* p = 0); // #2
void h() {
  f<int>(42, (A<int, int>*)0);  // #2 を呼びます。
  f<int>(42);                   // エラー、曖昧です。
}

template<class T           >  void g(T, T = T());  // #1
template<class T, class... U> void g(T, U ...);    // #2
void h() {
  g(42);  // エラー、曖昧です。
}

template<class  T, class... U> void f(T, U...);           // #1
template<class  T            > void f(T);                 // #2
void h(int i) {
  f(&i);        // パラメータパックと引数なしの間のタイブレーカーにより、 #2 を呼びます。
                // (ノート: 以前は DR692 と DR1395 の間で曖昧でした)
}

template<class  T, class... U> void g(T*, U...);          // #1
template<class  T            > void g(T);                 // #2
void h(int i) {
  g(&i);        // OK: #1 を呼びます (T* は T より特殊化されています)。
}

template <class ...T> int f(T*...);  // #1
template <class T>  int f(const T&); // #2
f((int*)0); // OK: #1 を選択します。
            // (両方向で推定が失敗するため、 DR1395 より前では曖昧でした)

template<class... Args>           void f(Args... args);               // #1
template<class T1, class... Args> void f(T1 a1, Args... args);        // #2
template<class T1, class T2>      void f(T1 a1, T2 a2);               // #3
f();                  // #1 を呼びます。
f(1, 2, 3);           // #2 を呼びます。
f(1, 2);              // #3 を呼びます。 可変長引数でないテンプレート #3 は
                      // 可変長引数テンプレート #1 および #2 より特殊化されています。

template <class T>          T f(int);  // #1
template <class T, class U> T f(U);    // #2
void g() {
  f<int>(1);  // #1 の特殊化は明示的です: T f(int) [T = int]
              // #2 の特殊化は推定されます: T f(U) [T = int, U = int]
// 半順序 (引数の型のみが考慮されます):
// #2 から #1: U1(U2) から T(int): 失敗。
// #1 から #2: U1(int) から T(U): 成功: U=int, T は使用されません。
// #1 を呼びます。
}

template<class...> struct Tuple { };
template<          class... Types> void g(Tuple<Types ...>);        // #1
template<class T1, class... Types> void g(Tuple<T1, Types ...>);    // #2
template<class T1, class... Types> void g(Tuple<T1, Types& ...>);   // #3
 
g(Tuple<>());                     // #1 を呼びます。
g(Tuple<int, float>());           // #2 を呼びます。
g(Tuple<int, float&>());          // #3 を呼びます。
g(Tuple<int>());                  // #3 を呼びます。

template< class T > void f(T);              // #1: テンプレートオーバーロード。
template< class T > void f(T*);             // #2: テンプレートオーバーロード。
void                     f(double);         // #3: 非テンプレートオーバーロード。
template<>          void f(int);            // #4: #1 の特殊化。
 
f('a');        // #1 を呼びます。
f(new int(1)); // #2 を呼びます。
f(1.0);        // #3 を呼びます。
f(1);          // #4 を呼びます。

template< class T > void f(T);    // #1: すべての型に対するオーバーロード。
template<>          void f(int*); // #2: int へのポインタに対する #1 の特殊化。
template< class T > void f(T*);   // #3: すべてのポインタ型に対するオーバーロード。
 
f(new int(1)); // #2 がパーフェクトマッチであったかもしれませんが、 #3 を呼びます。