C++ Template 基础篇（一）：函数模板详解

template<typename T>
int compare(const T& left, const T& right) {
  if (left < right) {
    return -1; 
  }
  if (right < left) {
    return 1; 
  }
  return 0;
}

compare<int>(1, 2); //使用模板函数

class Printer {
public:
  template<typename T>
  void print(const T& t) {
    cout << t <<endl;
  }
};

Printer p;
p.print<const char*>("abc"); //打印abc

compare(1, 2); //推断T的类型为int
compare(1.0, 2.0); //推断T的类型为double
p.print("abc"); //推断T的类型为const char*

int (*pf) (const int&, const int&) = compare; //推断T的类型为int

template<typename T1, typename T2, typename T3>
T1 sum(T2 v2, T3 v3) {
 return static_cast<T1>(v2 + v3);
}

auto ret = sum<long>(1L, 23); //指定T1, T2和T3交由编译器来推断

template<typename T1, typename T2, typename T3>
T3 sum_alternative(T1 v1, T2 v2) {
 return static_cast<T1>(v1 + v2);
}
auto ret = sum_alternative<long>(1L, 23); //error，只能从左向右逐一指定
auto ret = sum_alternative<long,int,long>(1L,23); //ok, 谁叫你把最后一个T3作为返回类型的呢？

template<typename It>
auto sum(It beg, It end) -> decltype(*beg) {
 decltype(*beg) ret = *beg;
 for (It it = beg+1; it != end; it++) {
   ret = ret + *it;
 }
 return ret;
}

vector<int> v = {1, 2, 3, 4};
auto s = sum(v.begin(), v.end()); //s = 10

template<typename T>
void func(T& t) { //通用模板函数
  cout << "In generic version template " << t << endl;
}

template<typename T>
void func(T* t) { //指针版本
  cout << "In pointer version template "<< *t << endl;
}

void func(string* s) { //普通函数
  cout << "In normal function " << *s << endl;
}

int i = 10;
func(i); //调用通用版本，其他函数或者无法实例化或者不匹配
func(&i); //调用指针版本，通用版本虽然也可以用，但是编译器选择最特殊的版本
string s = "abc";
func(&s); //调用普通函数，通用版本和特殊版本虽然也都可以用，但是编译器选择最特化的版本
func<>(&s); //调用指针版本，通过<>告诉编译器我们需要用template而不是普通函数

template<>
void func(int i) {
  cout << "In special version for int "<< i << endl; 
}

int i = 10;
func(i); //调用特化版本