C++模板进阶

BS_Li2025-07-27 8:15

模板进阶

  • [1. 非类型模板参数](#1. 非类型模板参数)
  • [2. 模板的特化](#2. 模板的特化)
    • [2.1 概念](#2.1 概念)
    • [2.2 函数模板特化](#2.2 函数模板特化)
    • [2.3 类模板特化](#2.3 类模板特化)
      • [2.3.1 全特化](#2.3.1 全特化)
      • [2.3.2 偏特化](#2.3.2 偏特化)
  • [3. 模板分离编译](#3. 模板分离编译)
    • [3.1 什么是分离编译](#3.1 什么是分离编译)
    • [3.2 模板的分离编译](#3.2 模板的分离编译)
    • [3.3 解决方法](#3.3 解决方法)
  • [4. 模板总结](#4. 模板总结)

1. 非类型模板参数

模板参数分为类型模板参数和非类型模板参数

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

cpp 复制代码 
#define N 100

template<class T>
class Stack
{
private:
	T a[N];
	int _top;
	int _capacity;
};

int main()
{

	Stack<int> s1; // 10
	Stack<int> s2; // 1000

	return 0;
}

现在Stack类中数组的默认大小是100，那我即想要一个数组大小是10的 s1 又想要一个数组大小是1000的 s2 怎么办？

我们发现它们不能同时满足，除非N取最大的1000，但这样s1会有大量空间浪费。

所以我们引入了非类型模板参数

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

cpp 复制代码 
// 整形做非类型模板参数
template<class T = int, size_t N = 100>
class Stack
{
	T a[N];
	int _top;
	int _capacity;
};

// C++20才支持浮点数和自定义类型做非类型模板参数
//template<double X>
//class B
//{};
//
//template<string X>
//class C
//{};

int main()
{
	Stack<int, 10> s1; // 10
	Stack<int, 1000> s2; // 1000
	Stack<int> s3; // 100
	Stack<> s4; // 100

	// 第二个模板参数只能是常量
	// x在运行时才在键盘中获取值
	//int x; cin >> x;
	//Stack<int, x> s5; //err

	cout << sizeof(s1) << endl;
	cout << sizeof(s2) << endl;

	return 0;
}

注意：
1. 浮点数以及自定义类型在C++20才支持作为非类型模板参数。
2. 非类型的模板参数必须在编译期就能确认结果，所以不能传变量。

下面我们介绍一个用非类型模板参数的容器 array

上面介绍说：array 是固定大小的顺序表容器，就是静态数组。

那么 array 和 我们学的 int a[N] 这种数组有什么区别呢？

cpp 复制代码 
int main()
{
	// 越界读写都可以查出来
	array<int, 10> a1;

	// 越界写抽查结束邻近位置
	// 越界读查不了
	//int a1[10]; 

	a1[0] = 10;
	a1[9] = 100;

	// 对于array是调用operator()[]，可以对越界断言报错
	// 对于int a1[10]是 a1[10] -> *(a1+10)，去访问
	//cout << a1[10] << endl; // 越界读
	//a1[10] = 10; // 越界写
	//a1[14] = 14; // 越界写

	for (auto e : a1)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

总结：
1. array的越界读写可以查出来，而数组越界写抽查，不查越界读。
2. 对于 [ ] ，array是调用operator()[]，数组是转换成指针解引用。

我们已经有了 vector 了，而且vector想开多少空间就开多少，更加灵活，那为什么还要 array 容器呢？

cpp 复制代码 
int main()
{
	// 默认是随机值
	array<int, 10> a1;
	// 可以将数组中的元素都初始化成1
	a1.fill(1); 

	for (auto e : a1)
	{
		cout << e << " ";
	}
	cout << endl;

	vector<int> a2(10, 1); 

	for (auto e : a2)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

上述的 array 和 vector 都可以很方便的完成工作，但对于固定大小的工作，array效率更高。


总结：array 是 "编译期固定大小的栈上容器"，以性能和简洁性为核心；vector 是 "运行期动态大小的堆上容器"，以灵活性和扩展性为核心。

2. 模板的特化

2.1 概念

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

cpp 复制代码 
// 函数模板
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

int main()
{
	// 可以比较，结果正确
	cout << Less(1, 2) << endl;

	// 下面的两个比较结果都是错误的，因为它们都是拿地址比较的，与指针指向的对象无关
	double* p1 = new double(1.1);
	double* p2 = new double(2.2);
	cout << Less(p1, p2) << endl;
	
	string* p3 = new string("111");
	string* p4 = new string("222");
	cout << Less(p3, p4) << endl;

	return 0;
}

对于上述的那种用指针比较的错误行为就需要对模板进行特化。即在原函数（类）模版的基础上，针对特殊类型所进行特殊化的实现方式 。模板特化分为函数模板特化 和类模板特化。

2.2 函数模板特化

函数模板的特化步骤：

  1. 必须要先有一个基础的函数模板
  2. 关键字template后面接一对空的尖括号<>
  3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
  4. 函数形参表：必须要和模板函数的基础参数类型完全相同，如果不同，编译器可能会报一些奇怪的错误。
cpp 复制代码 
// 函数模板
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

// 函数模板的特化
template<>
bool Less<double*>(double* left, double* right)
{
	return *left < *right;
}

template<>
bool Less<string*>(string* left, string* right)
{
	return *left < *right;
}

int main()
{
	cout << Less(1, 2) << endl;
	
	// 下面两个比较，都会调用特化之后的版本，而不走模板生成了
	double* p1 = new double(1.1);
	double* p2 = new double(2.2);
	cout << Less(p1, p2) << endl;
	
	string* p3 = new string("111");
	string* p4 = new string("222");
	cout << Less(p3, p4) << endl;

	return 0;
}

上述函数模板和函数模板的特化的代码虽然能解决问题，但是不稳定、效率低，所以我们进行了改写。

cpp 复制代码 
// 函数模板
template<class T>
bool Less(const T& left, const T& right)
{
	return left < right;
}

// 函数模板的特化
template<>
bool Less<double*>(double* const & left, double* const & right)
{
	return *left < *right;
}

上述函数模板的写法是一个标准的写法，但是函数模板的特化中的形参为什么要那样写呢？

知识点：

假如对于 double* & left

const 加在 * 的左边修饰的是 *left

const 加在 * 的右边修饰的是 left

上面的函数模板中const修饰的是对象本身，所以函数模板的特化中const也要修饰对象本身。

如果要比较很多种不同类型的这种情况的话，就要写很多种不同类型的函数模板的特化，太麻烦了。因此，一般情况下如果函数模板遇到不能处理或者有误的类型，为了实现简单通常都是将该函数直接给出。

cpp 复制代码 
// 函数模板和普通函数的匹配
template<class T>
bool Less(const T& left, const T& right)
{
	return left < right;
}

// 普通函数
bool Less(double* left, double* right)
{
	return *left < *right;
}

int main()
{
	cout << Less(1, 2) << endl;

	double* p1 = new double(1.1);
	double* p2 = new double(2.2);
	cout << Less(p1, p2) << endl;

	return 0;
}

2.3 类模板特化

2.3.1 全特化

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

cpp 复制代码 
// 类模板
template<class T1, class T2>
class Date
{
public:
	Date() { cout << "Date<T1, T2>" << endl; }
	
	void f1(){}
private:
	T1 _d1;
	T2 _d2;
};

// 类模板的全特化
template<>
class Date<int, char>
{
public:
	Date() { cout << "Date<int, char>" << endl; }
};

int main()
{
	Date<int, int> d1;
	d1.f1();
	Date<int, char> d2;
	//d2.f1(); // 调用不到f1，也就意味着特化相当于写一个全新的类

	return 0;
}

2.3.2 偏特化

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

偏特化分为：特化部分参数和对参数进一步限制

  1. 特化部分参数：将模板参数类表中的一部分参数特化
  2. 对参数进一步限制：偏特化并不仅仅是指特化部分参数，也有针对模板参数更进一步的条件限制所设计出来的一个特化版本。
cpp 复制代码 
// 类模板
template<class T1, class T2>
class Date
{
public:
	Date() { cout << "Date<T1, T2>" << endl; }
	
	void f1(){}
private:
	T1 _d1;
	T2 _d2;
};

// 类模板的偏特化
// 特化部分参数
template<class T2>
class Date<char, T2>
{
public:
	Date() { cout << "Date<char, T2>" << endl; }
};

// 对参数进一步限制
template<class T1, class T2>
class Date<T1*, T2*>
{
public:
	Date() { cout << "Date<T1*, T2*>" << endl; }

	void f1()
	{
		T1 x1;
		cout << typeid(x1).name() << endl;
		T1* x2;
		cout << typeid(x2).name() << endl;
	}
};

template<class T1, class T2>
class Date<T1&, T2&>
{
public:
	Date() { cout << "Date<T1&, T2&>" << endl; }
};

template<class T1, class T2>
class Date<T1*, T2&>
{
public:
	Date() { cout << "Date<T1*, T2&>" << endl; }
};

int main()
{
	Date<char, char> d3; // 调用特化的char版本
	Date<double*, double*> d4; 
	d4.f1(); // 验证 T1 和 T1* 的类型
	Date<double&, double&> d5;
	Date<double*, double&> d6;

	return 0;
}

3. 模板分离编译

3.1 什么是分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

3.2 模板的分离编译

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

cpp 复制代码 
// a.h
template<class T>
T Add(const T& left, const T& right);


// a.cpp
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}


// main.cpp
#include"a.h"
int main()
{
	Add(1, 2);
	Add(1.0, 2.0);
}
return 0;

3.3 解决方法

1. 将声明和定义放到一个文件"xxx.hpp"里面或者"xxx.h"里面。推荐使用这种。

cpp 复制代码 
// a.h
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。

cpp 复制代码 
// a.h
template<class T>
T Add(const T& left, const T& right);


// a.cpp
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

// 显式实例化
template // 告诉编译器这是一个模板的显式实例化声明
T Add(const int& left, const int& right);

template
T Add(const double& left, const double& right);


// main.cpp
#include"a.h"
int main()
{
	Add(1, 2);
	Add(1.0, 2.0);
}
return 0;

【分离编译扩展阅读】

为什么C++编译器不能支持对模板的分离式编译

4. 模板总结

【优点】

  1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库（STL）因此而产生。
  2. 增强了代码的灵活性。

【缺陷】

  1. 模板会导致代码膨胀问题，也会导致编译时间变长。
  2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误。
相关推荐
小徐不徐说35 分钟前
动态规划：从入门到精通
数据结构·c++·算法·leetcode·动态规划·代理模式
程序员编程指南2 小时前
Qt 网络编程进阶：RESTful API 调用
c语言·网络·c++·qt·restful
程序员编程指南2 小时前
Qt XML 与 JSON 数据处理方法
xml·c语言·c++·qt·json
Algebraaaaa3 小时前
【C++基础】指针常量 | 常量指针 | int* p | const int* p | int* const p| const int* const p
c++
祁同伟.3 小时前
【C++】类和对象（中）构造函数、析构函数
开发语言·c++
郝学胜-神的一滴4 小时前
C++ 类型萃取：深入理解与实践
开发语言·c++·程序人生
程序员编程指南4 小时前
Qt 网络编程进阶：网络安全与加密
c语言·网络·c++·qt·web安全
GOATLong5 小时前
传输层协议TCP
c语言·开发语言·网络·c++·网络协议·tcp/ip
天若有情6736 小时前
从一个“诡异“的C++程序理解状态机、防抖与系统交互
开发语言·c++·交互·面向对象·状态机
bilin_jam6 小时前
C++查询mysql数据
数据库·c++·mysql
热门推荐
01Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code02vue数据变化但页面不变03全球最强模型Grok4，国内已可免费使用！（附教程）04KGG转MP3工具|非KGM文件|解密音频05干翻 Typora！MilkUp：完全免费的桌面端 Markdown 编辑器！06【2025.7.18】更新vscode后所有.vue文件template标签后报红的临时解决办法，Vue - Official 插件3.0.2导致07扣子开源本地部署教程 丨Coze智能体小白喂饭级指南08ChatGPT Agent 完全使用指南：2025年7月最新功能详解09《魔兽世界》提示lua警告的含义及解决方法10这次领先Cursor！体验了Trae 2.0 SOLO 模式，超酷！