掌握模板与内存管理，你就是下一个 C++ 编程大神！代码冗余？内存泄漏？不存在的！

本文讲解 C++模板，包括函数模板和类模板，介绍其定义、用法及实例化。

2301_78847073

1525人浏览 · 2025-07-21 14:30:22

2301_78847073 · 2025-07-21 14:30:22 发布

掌握模板与内存管理，你就是下一个 C++ 编程大神！代码冗余？内存泄漏？不存在的！

模板
函数模板
类模板
总结

💻作者简介：曾与你一样迷茫，现以经验助你入门 C++。
💡个人主页：@笑口常开xpr 的个人主页
📚系列专栏：C++ 炼魂场：从青铜到王者的进阶之路

✨代码趣语：swap 模板藏着偷懒的智慧：与其给每个类型写交换代码，不如让编译器按类型 ‘ 抄作业 ’，抄得又快又准。
💪代码千行，始于坚持，每日敲码，进阶编程之路。
📦gitee 链接：gitee

在这里插入图片描述
在 C++ 的编程世界里，内存管理与代码复用始终是开发者绕不开的核心话题。今天，我们聚焦于 C++ 模板这一强大工具，它宛如代码世界的 “ 万能模具 ”，打破类型束缚，让同一份逻辑能适配多样数据类型；同时也会结合 new/delete 底层，帮你贯通内存管理与通用编程的关键脉络，一起解锁更高效的 C++ 编程姿势。

模板

交换函数

实现通用的交换函数

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

缺点

重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。
代码的可维护性比较低，一个出错可能所有的重载均出错

定义

模板是一个 “代码蓝图”，可以根据传入的类型 “生成” 对应版本的具体代码。

核心价值

解决 “同逻辑、不同类型” 的代码冗余问题。

函数模板

定义

定义一个通用函数，参数类型通过模板参数指定，编译器会根据传入的实参类型自动生成对应版本的函数。

格式

template<typename T>

使用 template 和 typename 来声明模板，这里的 typename 也可以使用 class 来代替，不可以使用 struct。T 是参数类型，可以是内置类型或者自定义类型，可以作为函数的参数或者返回值。

多个类型

template<typename T1,typename T2>

代码示例

#include<iostream>
using namespace std;
template<typename T>//T是模板参数,类似于形参,定义的是类型
void Swap(T& x1, T& x2)
{
	T tmp = x1;
	x1 = x2;
	x2 = tmp;
}
int main()
{
	int a = 0;
	int b = 1;
	double c = 1.1, d = 2.2;
	Swap(a, b);
	cout << a << " " << b << endl;
	Swap(c, d);
	cout << c << " " << d << endl;
	return 0;
}

在这里插入图片描述
上面的代码中，2 个 Swap 调用的不是同一个函数，编译器通过类型自动推导出函数。

函数模板的原理

编译器根据参数类型推导出具体函数。
在这里插入图片描述
可以直接使用库里面的 swap 模板，库里面的 swap 是小写。

#include<iostream>
using namespace std;
int main()
{
	int a = 1;
	int b = 2;
	cout << a << " " << b << endl;
	swap(a, b);
	cout << a << " " << b << endl;
	return 0;
}

在这里插入图片描述

函数模板的实例化

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

#include<iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.2;
	cout << Add(a1, d1) << endl;
	return 0;
}

在这里插入图片描述
代码报错是因为 a1 和 d1 的类型不同，模板参数列表中只有一个 T，编译器无法确定此处到底该将 T 确定为 int 或者 double 类型而报错，在模板中，编译器一般不会进行类型转换操作。 下面有两种解决方法。

方法 1
在参数前面添加强制类型转换。

#include<iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.2;
	cout << Add(a1, (int)d1) << endl;
	cout << Add((double)a1, d1) << endl;
	return 0;
}

在这里插入图片描述
不同的强制类型转换，得到的结果是不一样的。

方法 2
显示类型转换，在函数名后的 < > 中指定模板参数的实际类型

#include<iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.2;
	//cout << Add(a1, a2) << endl;
	//cout << Add(d1, d2) << endl;
	
	//强制类型转换
	//cout << Add(a1, (int)d1) << endl;
	//cout << Add((double)a1, d1) << endl;
	
	//显示实例化
	cout << Add<int>(a1, d2) << endl;//隐式类型转换
	cout << Add<double>(a1, d2) << endl;
	return 0;
}

在这里插入图片描述
Add 函数中，使用 const 是因为隐式类型转换会产生临时变量，临时变量具有常性。

特殊情况
有些函数无法自动推导，只能显示实例化。

#include<iostream>
using namespace std;
template<typename T>
T* Alloc(int n)
{
	return new T[n];
}
int main()
{
	double* p1 = Alloc<double>(10);
	return 0;
}

泛型编程

使用模板来完成的，代码针对 广泛的类型。

类模板

格式

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

类模板可以定义多个模版参数。

代码示例

类模板只能显示实例化，不能传递参数。

#include<iostream>
using namespace std;
template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "StackInt(size_t capacity = 3)" << endl;
		_array = new T[capacity];//只需要个数
		_capacity = capacity;
		_size = 0;
	}
	void Push(const T& data)
	{
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		cout << "~StackInt()" << endl;
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	T* _array;
	int _capacity;
	int _size;
};
int main()
{
	Stack<int> s1;//int
	Stack<double> s1;//double
	return 0;
}