C++：模板精讲

熬夜敲代码的猫2026-04-25 8:31

泛型编程

当我们实现一个交换函数，想要实现不同类型的交换，可以使用函数重载：

c 复制代码 
#include<iostream>

using namespace std;

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

但是这样有几个不好的地方：

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

所以在C++中，就出现了模板这个概念，编写与类型无关的代码，是代码复用的一种基础，模板是泛型编程的基础。

函数模板

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

被参数化的这个过程叫做函数模板的示例化。

函数模板的格式

cpp 复制代码 
template<typename T1,typename T2>

即返回类型 + 函数名（参数列表）{}

cpp 复制代码 
#include<iostream>

using namespace std;

template<typename T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}
int main()
{
	char a = 'x';
	char b = 'c';
	Swap(a, b);
	cout << a << " " << b << endl;
	return 0;
}

注意 ：

typename 是用来定义模板参数关键字，也可以使用class，切记，不能使用struct代替class。typename和class 只有一种情况不能等价，

（比如 T::iterator 前面）：只能用 typename，说明这是一个类型

cpp 复制代码 
template<class T>
void func()
{
    // 这里必须写 typename！不能写 class！
    typename T::iterator it;
}

函数模板的原理

函数模板是一个标准复制件，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的摸具。所以模板就是将本来我们要重复做的事交给了编译器。

在编译器阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。

函数模板的实例化

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

  • 隐式实例化：
cpp 复制代码 
#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 b1 = 5.2, b2 = 13.14;
	cout << Add(a1, a2) << endl;
	cout << Add(b1, b2) << endl;
	return 0;
}
  • 显式实例化：
cpp 复制代码 
#include<iostream>

using namespace std;

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a = 10;
	double b = 20.0;
	//显示实例化
	cout << Add<int>(a, b) << endl;
	return 0;
}

注意：如果在实例化中，类型不匹配，编译器一般不会进行类型转化操作，因为一旦转化出现问题，编译器就需要背锅。

模板参数的匹配机制

  • 1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被示例化为这个非模板函数。
cpp 复制代码 
#include<iostream>

using namespace std;

int Add(int left, int right)
{
	return left + right;
}

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	Add(1, 2);
	Add<int>(1, 2);
}
  • 2.对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调动非模板函数而不会从该模板产生一个实例。如果模板可以产生一个具有更好匹配的函数，那么选择该模板。
cpp 复制代码 
#include<iostream>

using namespace std;

int Add(int left, int right)
{
	return left + right;
}

template<class T1,class T2>
T1 Add(const T1& left, const T2& right)
{
	return left + right;
}
int main()
{
	Add(1, 2);
	Add(1, 2.0);
	return 0;
}

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

类模板

类模板的定义格式

cpp 复制代码 
template<class T1,clasT2,......classTn>
class 类模板名
{
//类内成员变量
}
cpp 复制代码 
#include<iostream>

using namespace std;

template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};
int main()
{
	Stack<int> st1;
	Stack<double>st2;
	return 0;
}

类模板的实例化

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

非类型模板参数

模板参数分类：

类型形参和非类型形参
类型形参 ：出现在模板参数列表中，跟在class 或者typename之类的参数类型名称之后。
非类型形参：就是用一个常量作为类（函数）模板的一个参数，在类（函数）模板中可以将该参数当成常量来使用。

cpp 复制代码 
#include<iostream>

using namespace std;

namespace yjjh
{
	template<class T,size_t N=10>
	class array
	{
	public:
		array()
		{
			for (int i = 0; i < N; i++)
			{
				_array[i] = T();
			}
			_size = N;
		}
		T& operator[](size_t index)
		{
			return _array[index];
		}
		const T&operator[](size_t index) const
		{
			return _array[index];
		}
		size_t size()const
		{
			return _size;
		}
		bool empty()const
		{
			return 0 == _size;
		}
	private:
		T _array[N];
		size_t _size;
	};
}

int main()
{
	yjjh::array<int ,5>a1;
	cout << a1[4] << endl;
	return 0;
}

注意：

  • 浮点数，类对象以及字符串是不允许作为非类型模板参数的
  1. 浮点数在计算机里是二进制近似存储，模板要求：不同值必须生成不同类
    浮点数因为精度问题，做不到绝对安全区分
  2. 类对象太复杂，有构造、析构、成员变量编译器无法在编译期把一个完整对象编码进类型
  3. 字符串是数组 / 指针，地址不确定，编译器无法把不确定地址当作模板常量
  • 非类型模板参数必须在编译期间就确认结果

模板的特化

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

cpp 复制代码 
#include<iostream>

using namespace std;
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator<(const Date& d2)
	{
		if (_year > d2._year)
		{
			return false;
		}
		else if (_year == d2._year)
		{
			if (_month > d2._month)
			{
				return false;
			}
			else if (_month == d2._month)
			{
				return _day < d2._day;
			}
		}
		return true;
	 }
private:
	int _year;
	int _month;
	int _day;
};
template<class T>
bool Less(T left, T right)
{
	return left < right;
}
int main()
{
	cout << Less(1, 2) << endl;
	Date d1(2026, 4, 23);
	Date d2(2025, 6, 7);
	cout << Less(d1, d2) << endl;
	cout << Less(p1, p2) << endl;
	return 0;
}

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

所以我们需要模板特化

模板特化

模板特化 ：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。
函数模板特化步骤

  • 1.必须要先有基础的函数模板
  • 2.关键字template后面接一对尖括号<>
  • 3.函数名后跟一对尖括号，尖括号中指定需要特化的类型
  • 4.函数形参表：必须要和模板函数的基础函数类型完全相同，如果不同编译器可能会报一些奇怪的错误
cpp 复制代码 
#include<iostream>

using namespace std;
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	bool operator<(const Date& d2)
	{
		if (_year > d2._year)
		{
			return false;
		}
		else if (_year == d2._year)
		{
			if (_month > d2._month)
			{
				return false;
			}
			else if (_month == d2._month)
			{
				return _day < d2._day;
			}
		}
		return true;
	 }
private:
	int _year;
	int _month;
	int _day;
};
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

//对Less模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}

int main()
{
	cout << Less(1, 2) << endl;
	Date d1(2026, 4, 23);
	Date d2(2025, 6, 7);
	cout << Less(d1, d2) << endl;
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl;
	return 0;
}

注意 ：

一般情况下，如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。该实现简单明了，对于一些参数类型复杂的函数模板，特化后代码可读性不强。

类模板特化

  • 必须要先有基础的函数模板
  • 关键字template后面接一对尖括号<>
  • 类名后面接一对尖括号<>，填上类型
全特化

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

cpp 复制代码 
#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<T1,T2>" << endl;
	}
private:
	int _d1;
	char _d2;
};
  • 偏特化
    偏特化：任何针对模板参数进一步进行条件限制设计的特化版本。
    1.部分特化
cpp 复制代码 
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;
};

2.参数更进一步的限制

cpp 复制代码 
#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<typename T1, typename T2>
class Data<T1*,T2*>
{
public:
	Data()
	{
		cout << "Data<T1*,T2*>" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};
template<typename T1,typename T2>
class Data<T1&,T2&>
{
public:
	Data()
	{
		cout << "Data<T1&,T2&>" << endl;
	}
private:
	T1 _d1;
	T2 _d2;
};

类模板特化的应用

有如下专门按照小于补交的类模板Less:

cpp 复制代码 
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class Date
{
	friend ostream& operator<<(ostream& out, const Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	bool operator<(const Date& d2)const
	{
		if (_year > d2._year)
		{
			return false;
		}
		else if (_year == d2._year)
		{
			if (_month > d2._month)
			{
				return false;
			}
			else if (_month == d2._month)
			{
				return _day < d2._day;
			}
		}
		return true;
	 }
	
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator << (ostream & out, const Date & d)
{
	out << d._year << "-" << d._month << "-" << d._day ;
	return out;
}
template<class T>
struct Less
{
	bool operator()(const T& x, const T& y)const
	{
		return x < y;
	}
};

模板的分离编译

假如有一下场景，模板的声明与定义分离开，在头文件中进行声明，在源文件中完成定义：会直接报错

cpp 复制代码 
// a.h
template<class T>
void func(T a);  // 声明

// a.cpp
template<class T>
void func(T a)
{
}
  • 普通函数 / 类：编译.cpp就生成具体机器码，声明放头文件、定义放源文件，支持分离编译。
  • 模板（函数 / 类）本质是代码蓝图，没有具体类型，不会主动生成实体代码。
    模板只有在 被指定类型使用（实例化） 时，才会替换类型、生成对应代码。
  • 若分离编译：
    模板定义写在.cpp，外部文件只引入头文件声明；
    编译各自文件时，两边都没法实例化生成代码，链接阶段找不到函数实体，报错。

解决方法：

  • 将声明和定义放到一个.h文件中
  • 模板定义的位置显示实例化（不推荐使用）

模板总结

优点

  • 模板复用了代码，节省资源，更快的迭代开发
  • 增强了代码的灵活性

缺点

  • 模板会导致代码膨胀问题，也会导致编译时间变长
  • 出现模板编译错误时，错误信息非常凌乱，不一定位错误
相关推荐
tankeven1 小时前
C++ 学习杂记04：std::vector 类
c++
兩尛1 小时前
C++面向对象和类相关
java·c++·面试
MegaDataFlowers2 小时前
3.无重复字符的最长子串
算法
凯瑟琳.奥古斯特2 小时前
C++变量命名进阶技巧
开发语言·c++
人道领域2 小时前
【LeetCode刷题日记】20.有效的括号
算法·leetcode·职场和发展
生信研究猿2 小时前
#P3492.第1题-基于决策树预判资源调配优先级
python·算法·决策树
贾斯汀玛尔斯2 小时前
每天学一个算法--缓存淘汰策略（LRU / LFU · 结构与复杂度）
算法·缓存
大熊背2 小时前
一套为硬件加速设计的经典边缘检测流水线(一)----边缘细化原理
人工智能·算法·计算机视觉·梯度计算
MicroTech20252 小时前
微算法科技（NASDAQ ：MLGO）基于线检测掩模的量子算法与新型增强量子表示（NEQR）技术
科技·算法·量子计算
热门推荐
012026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元02GitHub 镜像站点03近期有什么ai的新消息，新动态？ 2026.4月042026年4月AI大事件深度解读：大模型竞争进入“深水区“05codex app每次打开重连5次Reconnecting问题解决06AI Weekly | 2026年4月第二周 · GitHub热门项目与AI发展趋势深度解析072026年AI前瞻：量子AI、具身智能与科学发现的新纪元08CC-Switch & Claude 基于 Linux 服务器安装使用指南092026 年 AI 编程助手全面对比评测：Cursor vs Copilot vs Claude Code vs GitHub Copilot Free10从限购到畅通：GLM-5.1 Coding Plan接入攻略