基本应用

在已知类型的情况下，编译器可以进行数据类型的自动推导，如下例代码，但如果编译器无法自动推导的情况，则不能简单的写 toSwap(a, b);，而是需要在调用时声明类型，如： toSwap(c, d);

  1. #include <iostream>
  2. using namespace std;
  4. template<typename T>//声明T为模板类型，使编译器不报错，typename修改成class也是一样的
  6. void toSwap(T& a,T& b){
  7.     T temp = a;
  8.     a = b;
  9.     b = temp;
  10. }
  12. int main()
  13. {
  14.     int a = 1;
  15.     int b = 2;
  17.     toSwap(a, b);
  19.     cout << "a="<<a<< endl;
  20.     cout << "b="<<b<< endl;
  22.     double c = 1.1;
  23.     double d = 2.2;
  25.     toSwap(c, d);
  27.     cout << "c="<<c<< endl;
  28.     cout << "d="<<d<< endl;
  30.     return 0;
  31. }

a=2 b=1 c=2.2 d=1.1

普通函数和函数模板同名的调用规则

  • 优先普通函数
  • 可以通过空模板参数列表来强制调用函数模板，即：func<>()
  • 如果函数模板更匹配，则调用函数模板 ```c

    include

    using namespace std;

template void toSwap(T& a,T& b){ T temp = a; a = b; b = temp; }

void toSwap(int& a,int& b){ int temp = a; a = b; b = temp; }

int main() { int a = 1; int b = 2;

  1. toSwap(a, b);//调用普通函数
  2. toSwap<>(a, b);//调用模板函数
  4. char c = 'c';
  5. char d = 'd';
  6. toSwap(c, d);//虽然两个方法都可以执行，普通函数需要强制转化为int，模板函数更匹配，故而会调用模板函数
  8. return 0;

}

  1. <a name="VwMQ3"></a>
  2. ### 模板函数的局限性
  3. 比如比较大小时，虽然类型推断可以做到，但并不是每个数据类型都支持运算符（当然我们也可以通过重载运算符让这个类支持），那么就需要用以下的模板重载的方式来解决：
  4. ```c
  5. #include <iostream>
  6. #include <string>
  7. using namespace std;
  9. template<typename T>
  10. bool toCompare(T& a,T& b){
  11.     return a > b;
  12. }
  14. class People{
  15.     public:
  16.         string name;
  17.         int age;
  18. };
  20. //重载模板对People这个类的支持
  21. template<> bool toCompare(People& a,People& b){
  22.     return a.age > b.age;
  23. }
  25. int main()
  26. {
  27.     int a = 1;
  28.     int b = 2;
  30.     cout << toCompare(a,b) << endl;
  32.     People p{"小明", 20};
  33.     People p2{"小红", 30};
  34.     cout << toCompare(p, p2) << endl;
  36.     return 0;
  37. }