函数模板

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);   // OK 即使 &p 不是 int。

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);
 
// 两个不同函数具有相同类型，但在函数中，t 有不同的 cv 限定
f<int>(1);       // 函数类型是 void(int)，t 为 int
f<const int>(1); // 函数类型是 void(int)，t 为 const int
 
// 两个不同函数具有相同类型和相同的 x
// （指向这两个函数的指针不相等，且函数局部的静态变量可以拥有不同地址）
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 为 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
 
// 功能等价但不等价
// 程序非良构，不要求诊断
template <int I> void f(A<I>, A<I+10>); // 重载 #1
template <int I> void f(A<I>, A<I+1+2+3+4>); // 功能等价

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
// 为进行部分排序，成员 template 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]
// 部分排序
// #1 从变换后的 #2：void(T) 从 void(U1*)：P=T A=U1*：推导 ok：T=U1*
// #2 从变换后的 #1：void(T*) 从 void(U1)：P=T* A=U1：推导失败
// 对于 T 而言 #2 比 #1 更特殊
// #1 从变换后的 #3：void(T) 从 void(const U1*)：P=T, A=const U1*：ok
// #3 从变换后的 #1：void(const T*) 从 void(U1)：P=const T*, A=U1：失败
// 对于 T 而言 #3 比 #1 更特殊
// #2 从变换后的 #3：void(T*) 从 void(const U1*)：P=T* A=const U1*：ok
// #3 从变换后的 #2：void(const T*) 从 void(U1*)：P=const T* A=U1*：失败
// 对于 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]
 // 部分排序：
 // #1 从 #2：void(T,T*) 从 void(U1,int*)：P1=T, A1=U1：T=U1
 //                                       P2=T*, A2=int*：T=int：失败
 // #2 从 #1：void(T,int*) 从 void(U1, U2*)：P1=T A1=U1：T=U1
 //                                         P2=int* A2=U2*：失败
 // 对于 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]
// 部分排序
// #1 从 #2：void(T) 从 void(U1&)：P=T, A=U1（调整后）：ok
// #2 从 #1：void(T&) 从 void(U1)：P=T（调整后） A=U1 ：ok
// 对于 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]
 // 部分排序
 // #1 从 #2：void(const T&) 从 void(A<U1>&)：P=T A=A<U1>：ok T=A<U1>
 // #2 从 #1：void(A<T>&) 从 void(const U1&)：P=A<T> A=const U1：失败
 // 对于 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]
// 部分排序（仅考虑实参类型）
// #1 从 #2：T(int) 从 U1(U2)：失败
// #2 从 #1：T(U) 从 U1(int)：ok：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)); // 调用 #3，虽然 #1 的特化是完美匹配