C++模板入门

最新推荐文章于 2026-06-22 20:34:05 发布

原创最新推荐文章于 2026-06-22 20:34:05 发布 · 775 阅读

27 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#c++

C++模版入门

一、泛型编程

在c语言中，写一个int类型的Swap交换函数是这样的

void Swap(int* left, int* right) {
	int tmp = *left;
	*left = *right;
	*right = tmp;
}

使用这个函数时，还需要&地址，而cpp中，新增了引用，因此在写这种类似的函数时，参数可以直接使用引用，不需要指针这么麻烦的东西

void Swap(int& left, int& right) {
	int tmp = left;
	left = right;
	right = tmp;
}

这里只实现了int类型的，当需求实现double、float、char等内置类型的交换时，可以使用函数重载，来适应不同的数据类型

void Swap(double& left, double& right) {
	double tmp = left;
	left = right;
	right = tmp;
}

void Swap(float& left, float& right) {
	float tmp = left;
	left = right;
	right = tmp;
}

void Swap(char& left, char& right) {
	char tmp = left;
	left = right;
	right = tmp;
}


int main() {
    
	//double
	double d1 = 2.12;
	double d2 = 3.14;
	cout << d1 << d2 << endl;
	Swap(d1, d2);
	cout << d1 << d2 << endl;

	//float
	float f1 = 5.20;
	float f2 = 9.99;
	cout << f1 << f2 << endl;
	Swap(f1, f2);
	cout << f1 << f2 << endl;

	//char
	char c1 = 'A';
	char c2 = 'B';
	cout << c1 << c2 << endl;
	Swap(c1, c2);
	cout << c1 << c2 << endl;

	return 0;
}

虽然函数重载的方法很好用，但是还是有几个缺点：

重载的函数的功能是一样的，但是类型不同，当有新的类型需求时，还需要用户手动添加对应的函数
代码的可维护性低，一个出错可能导致重载都出错

那么，有没有更方便的方法，把这些功能一样，但是数据类型不同的函数统一起来

有的有的，这个就是cpp的模版

在cpp中，也可以存在这样一个模具，只需要填充不同的材料，来获取不同材料的铸件（也就是具体生成的代码），那将会解放双手

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

二、函数模板

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

格式

template<typename T1,typename T2, typename T3, typename Tn>
返回值类型 函数名 (参数列表){
    
}

其中typename可以换成class，由于处于入门阶段，可以认为这两个是一致的（不能用struct代替class）

示例

template<typename T>
void Swap(T& left, T& right) {
	T tmp = left;
	left = right;
	right = tmp;
}

int main() {
	//int
	int i1 = 100;
	int i2 = 20;
	cout << i1 << i2 << endl;
	Swap(i1, i2);
	cout << i1 << i2 << endl;

	//double
	double d1 = 1.23;
	double d2 = 5.22;
	cout << d1 << d2 << endl;
	Swap(d1, d2);
	cout << d1 << d2 << endl;

	//char
	char c1 = 'B';
	char c2 = 'D';
	cout << c1 << c2 << endl;
	Swap(c1, c2);
	cout << c1 << c2 << endl;


	return 0;
}

运行结果

模板示意图

原理

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

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应的函数以供调用。比如：当使用int类型时，传入int类型参数，编译器会根据实参进行推演，将T确定为int类型，然后产生一份专门处理int类型的代码，其他内置类型也是一样的

实例化

实例化就是使用不同类型的参数使用函数模板。分别为：隐式实例化和显式实例化

隐式实例化：让编译器根据实参推演的实际类型

正确使用

template<typename T>
void Swap(T& left, T& right) {
	T tmp = left;
	left = right;
	right = tmp;
}

int main() {
	//int
	int i1 = 100;
	int i2 = 20;
	cout << i1 << i2 << endl;
	Swap(i1, i2);
	cout << i1 << i2 << endl；
	return 0;
}

错误使用

template<typename T>
void Swap(T& left, T& right) {
	T tmp = left;
	left = right;
	right = tmp;
}

int main() {

	int a1 = 5, a2 = 10;
	double d1 = 2.13, d2 = 3.14;
	Swap(a1,d1);

	return 0;
}

错误原因：在编译时就不能通过，因为在编译时，将a1推演为int，将d1推演为double，但是参数列表只有一个T，编译器无法识别导致报错

解决方法

一、用户手动强制类型转换

template<typename T>
T ADD(const T& left, const T& right) {
	return left + right;
}

int main() {
	int a = 10;
	double d = 5.12;
	ADD(a, (int)d);

	return 0;
}
//以下的强制类型转换是无法编过的，因为是可更改对象
template<typename T>
void Swap(T& left, T& right) {
	T tmp = left;
	left = right;
	right = tmp;
}

int main() {

	int a1 = 5, a2 = 10;
	double d1 = 2.13, d2 = 3.14;
	Swap(a1,(int)d1);
	
	return 0;
}

问题出在Swap函数的调用上。Swap函数的参数是非const引用，尝试传递一个临时对象（通过强制类型转换(int)d1）给它。这在C++中是不允许的，因为非const引用不能绑定到临时对象。

原因分析

非const引用：

非const引用要求绑定到一个可修改的左值（即一个具名变量或可修改的对象）。

临时对象（如通过强制类型转换生成的对象）是右值，不能绑定到非const引用。

const引用：

const引用可以绑定到右值（包括临时对象），因为它承诺不修改所引用的对象。

解决方案

将Swap函数的参数改为const引用，编译器将允许绑定到临时对象，但这会使Swap函数失去其原有的交换功能，因为const引用不能修改其引用的对象。

最次要的原因：

参数列表只有一个T，需要多加一个参数，就不需要强制类型转换了，也不产生临时对象，仅仅是传值传递
template<typename T1,typename T2>
void Swap(T1 &left, T2 &right) {
	T1 temp = left;
	left = right;
	right = temp;
}

int main() {
	int a1 = 10;
	double d1 = 1.22;
	Swap(a1, d1);

	return 0;
}
这种情况下，编译器会进行如下操作：

类型推断：

T1被推断为int，T2被推断为double。

隐式类型转换：

当left = right;执行时，right（double类型）会被隐式转换为int类型。

当right = temp;执行时，temp（int类型）会被隐式转换为double类型。

问题分析

虽然编译器允许这种操作，但它并没有实现真正的交换。以下是具体原因：

数据丢失：当double类型的d1被转换为int时，小数部分会丢失。

不对称交换：由于类型不同，交换操作并不对称，可能导致数据不一致。

结果

在这种实现中，a1和d1的值不会被正确交换。a1会被赋值为1（d1的整数部分），而d1会被赋值为10.0（a1的值转换为double）。

二、显示实例化：在函数名后面的<>中指定模板参数的实际类型

int main() {
	int a = 10;
	double d = 5.12;
	/*ADD(a, (int)d);*/
	ADD<int>(a, d);//在<>中规定实际类型
	ADD<double>(a, d);
	return 0;
}

匹配原则

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

//适用于int类型的加法函数
int ADD(int left, int right) {
	return left + right;
}

//通用类型的加法函数
template<typename T>
int ADD(const T& left, const T& right) {
	return left + right;
}

int main() {
	int a = 10;
	int b = 20;
	cout << ADD(a, b) << endl;//与非模板函数匹配，使用的是int类型的加法函数
	cout << ADD<int>(a, b) << endl;//指定用模板函数推演出的int类型的加法函数

	return 0;
}

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

//适用于int
int ADD(int left, int right) {
	return left + right;
}

//通用
template<class T>
T ADD(T left, T right) {
	return left + right;
}

int main() {
	
	ADD(1, 2);//与int类型匹配，会优先选适用int
	ADD(1, 2.22);//函数模板可以生成更匹配的版本，编译器会根据实际，选择更合适的通用

	return 0;
}

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

总结：出现条件差不多的函数，编译器会自动选择合适的

类模板

格式

template<class T1,class T2,class T3,....,class Tn>
class 类名
{
	//类成员定义
};

例如，STL库中的容器vector支持这么多类型，其实是通过模板来写的

template<class T>
class Vector {
public:
	Vector(size_t capacity = 10)
		:_Date(T new[capacity])
		,_size(0)
		,_capacity(capacity)//初始化列表
	{
	}
	//使用析构函数演示：在类中声明，在类外面定义
	~Vector();

	void PushBack(const T& date);
	void PopBack();
	//....

	size_t Size() {
		return _size;
	}

	//重载[]，能通过[]访问自定义类型下标
	T& operator[](size_t pos) {
		//下标不能超过本身的大小
		assert(pos < _size);
		//返回数据的下标
		return _Date[pos];
	}

	private:
	T* _Date;
	size_t _size;
	size_t _capacity;
};

//注意：类模板中函数在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector() {
	if (_Date)
		delete[] _Date;
	_size = _capacity = 0;
}

类模板实例化

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

int main() {

	Vector<int> v1;
	Vector<double> v2;

	return 0;
}

总之，有了模板，用户可以节省很多重复的工作，实现一个通用类型的函数或者类，能够提高代码复用性