当前位置：首页 > java >正文

C++模板

java 2025/7/3 13:46:45

1. 泛型编程

如何实现一个通用的交换函数呢？

#include<iostream>using namespace std;void swap(int& a, int& b)
{int temp = a;a = b;b = temp;
}void swap(double& a, double& b)
{double temp = a;a = b;b = temp;
}void swap(char& a, char& b)
{char temp = a;a = b;b = temp;
}

使用函数重载虽然可以实现，但是有以下几个不好的地方：

1. 重载的函数仅仅是类型不同，代码复用率太低，只要有新类型出现时，就需要用户自己增加对应的函数。

2. 代码的可维护性比较低，一个出错可能所有的重载均出错。

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

如果在C++中，也能够存在一个模具，通过给这个模具中填充不同材料（类型），来获得不同材料的铸件（即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础

模板又分为函数模板和类模板。

2. 函数模板

2.1 函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.2 函数模板格式

template<typename T1, typename T2, ......, typename Tn>

返回值类型函数名(参数列表){ }

#include<iostream>using namespace std;template<typename T>
void swap(T& a, T& b)
{T temp = a;a = b;b = temp;
}

typename是用来定义模板参数的关键字，也可以用class来定义，两者是等价的。

2.3 函数模板的原理

函数模板就是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

2.4 函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

1. 隐式实例化：让编译器根据实参类型推演模板参数的实际类型。

#include<iostream>using namespace std;template<class T>
T Add(const T& a, const T& b)
{return a + b;
}int main()
{int a1 = 3, a2 = 4;cout << Add(a1, a2) << endl;double b1 = 3.0, b2 = 4.0;cout << Add(b1, b2) << endl;// 该语句不能编译，因为类型不一致// 有两种方法可以解决// 1. 用户自己来强制转换// 2. 使用显式实例化//cout << Add(a1, b2) << endl;cout << Add(a1, (int)b2) << endl;cout << Add<int>(a1, b2) << endl;return 0;
}

2. 显式实例化：在函数名后的<>中指定模板参数的实际类型

上面已经举例了。

2.5 模板参数的匹配原则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

#include<iostream>using namespace std;int Add(int a, int b)
{return a + b;
}template<class T>
T Add(T a, T b)
{return a + b;
}int main()
{// 调用第一个cout << Add(3, 4) << endl;// 调用第二个cout << Add<int>(3, 4) << endl;return 0;
}

2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板。

#include<iostream>using namespace std;int Add(int a, int b)
{cout << "int Add(int a, int b)" << endl;return a + b;
}template<class T1, class T2>
T1 Add(T1 a, T2 b)
{cout << "T1 Add(T1 a, T2 b)" << endl;return a + b;
}int main()
{cout << Add(3, 4) << endl;cout << Add(3, 4.0) << endl;return 0;
}

3. 模板函数不允许自动类型转换，但普通函数可以自动类型转换

3. 类模板

3.1 类模板的定义格式

template<class T1, class T2, ...., class Tn>
class 类模板名
{};

3.2 类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

#include<iostream>using namespace std;template<class T>
class Date
{};int main()
{    Date<int> d1;Date<double> d2;return 0;
}

4. 非类型模板函数

模板参数分为类类型形参与非类型形参。

类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。

非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

#include<iostream>using namespace std;template<class T, size_t N = 10>
class Date
{};

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。

2. 非类型的模板参数必须在编译期就确认结果。

5. 模板的特化

5.1 概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来小于比较的函数模板。

#include<iostream>using namespace std;class Date
{
public:Date(int year, int month, int day):_year(year), _month(month), _day(day){ }bool operator<(const Date& d){if (_year < d._year){return true;}else if (_year == d._year && _month < d._month){return true;}else if (_year == d._year && _month == d._month){return _day < d._day;}return false;}private:int _year;int _month;int _day;
};template<class T>
bool Less(T a, T b)
{return a < b;
}int main()
{cout << Less(3, 4) << endl;// 可以比较，结果正确Date d1(2025, 5, 7);Date d2(2025, 5, 8);Date* p1 = new Date(2025, 5, 7);Date* p2 = new Date(2025, 5, 8);cout << Less(d1, d2) << endl;// 可以比较，结果正确cout << Less(p1, p2) << endl;// 可以比较，结果错误，结果在变化return 0;
}

可以看到，Less绝多数情况下都可以正常比较，但是在特殊场景下就得到错误的结果。上述示例中，p1指向的内容显然小于p2指向的内容，但是Less内部并没有比较p1和p2的内容，而比较的是p1和p2指针的地址，这就无法达到想要的结果。

此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

5.2 函数模板特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板。

2. 关键字template后面接一对空的尖括号<>。

3. 函数名后跟一对尖括号，尖括号中指定特化的类型。

4. 函数形参表必须要和模板函数的基础参数类型完全相同。

#include<iostream>using namespace std;class Date
{
public:Date(int year, int month, int day):_year(year), _month(month), _day(day){ }bool operator<(const Date& d){if (_year < d._year){return true;}else if (_year == d._year && _month < d._month){return true;}else if (_year == d._year && _month == d._month){return _day < d._day;}return false;}private:int _year;int _month;int _day;
};template<class T>
bool Less(T a, T b)
{return a < b;
}template<>
bool Less<Date*>(Date* a, Date* b)
{return *a < *b;
}int main()
{cout << Less(3, 4) << endl;// 可以比较，结果正确Date d1(2025, 5, 7);Date d2(2025, 5, 8);Date* p1 = new Date(2025, 5, 7);Date* p2 = new Date(2025, 5, 8);cout << Less(d1, d2) << endl;// 可以比较，结果正确cout << Less(p1, p2) << endl;// 可以比较，结果错误，结果在变化return 0;
}

5.3 类模板特化

5.3.1 全特化

全特化即是将模板参数列表中所有的参数都确定化。

#include<iostream>using namespace std;template<class T1, class T2>
class Data
{
public:Data(){cout << "Data<T1, T2>" << endl;}private:T1 _d1;T2 _d2;
};template<>
class Data<int, char>
{
public:Data(){cout << "Data<int, char>" << endl;}private:int _d1;char _d2;
};int main()
{Data<int, int> d1;Data<int, char> d2;return 0;
}

5.3.2 偏特化

偏特化：任何针对模板参数进一步进行条件限制设计的特化版本。比如对于以下模板类：

template<class T1, class T2>
class Data
{
public:Data(){cout << "Data<T1, T2>" << endl;}private:T1 _d1;T2 _d2;
};

偏特化有以下两种表现方式：

1. 部分特化

将模板参数类表中的一部分参数特化。

template<class T1>
class Data<T1, int>
{
public:Data(){cout << "Data<T1, int>" << endl;}private:T1 _d1;int _d2;
};

2. 参数进一步的限制

偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

#include<iostream>using namespace std;template<class T1, class T2>
class Data
{
public:Data(){cout << "Data<T1, T2>" << endl;}private:T1 _d1;T2 _d2;
};template<class T1>
class Data<T1, int>
{
public:Data(){cout << "Data<T1, int>" << endl;}private:T1 _d1;int _d2;
};template<class T1, class T2>
class Data<T1*, T2*>
{
public:Data(){cout << "Data<T1*, T2*>" << endl;}private:T1 _d1;T2 _d2;
};template<class T1, class T2>
class Data<T1&, T2&>
{
public:Data(const T1& d1, const T2& d2):_d1(d1),_d2(d2){cout << "Data<T1&, T2&>" << endl;}private:const T1& _d1;const T2& _d2;
};int main()
{Data<int, double> d1;// 调用第一个Data<double, int> d2;// 调用第二个Data<int*, int*> d3;// 调用第三个Data<int&, int&> d4(3, 4);// 调用第四个return 0;
}