【C++】模板（进阶）

文章目录

模板（初阶）
上文链接
一、非类型模板参数
- [1. 什么是非类型模板参数](#1. 什么是非类型模板参数)
- [2. 非类型模板参数的特点](#2. 非类型模板参数的特点)
二、模板的特化
- [1. 什么是模板的特化](#1. 什么是模板的特化)
- [2. 函数模板特化](#2. 函数模板特化)
- [3. 类模板特化](#3. 类模板特化)
- - [(1) 全特化](#(1) 全特化)
  - [(2) 偏特化（半特化）](#(2) 偏特化（半特化）)
三、模板分离编译
- [1. 分离编译模式](#1. 分离编译模式)
- [2. 模板的分离编译引发的问题](#2. 模板的分离编译引发的问题)
- [3. 解决方案](#3. 解决方案)
四、模板总结

模板（初阶）

【C++】模板（初阶）

上文链接

【C++】优先队列简介与模拟实现 + 仿函数

一、非类型模板参数

1. 什么是非类型模板参数

假如说我们要定义了一个栈，即一个 stack 类如下：

cpp 复制代码

#define N 10;

template<class T>
class stack
{
public:
	// ...
private:
	T _a[N];
	size_t top;
};

如果我们要用这个类来实例化出两个对象 st1 和 st2，我想让 st1 的 N 是 10，想让 st2 的 N 是 100，这是做不到的，因为宏只能有一个。那么这个时候怎么办呢？

cpp 复制代码

stack<int> st1; // 10
stack<int> st2; // 100

C++ 的模板中设计了一种非类型模板参数，它就灵活地对 stack 中的 N 进行替换。

cpp 复制代码

//               非类型模板参数
template<class T, size_t N>
class stack
{
public:
	// ...
private:
	T _a[N];
	size_t top;
};

于是我们在定义类对象的时候，就直接指定这个 N 的大小即可。并且它在编译时就对 N 进行了替换。

cpp 复制代码

stack<int, 10> st1; // 10
stack<int, 100> st2; // 100

2. 非类型模板参数的特点

在编译阶段就会将类中的该参数进行替换。

非类型模板参数可以给缺省值。

浮点数、类对象以及字符串是不允许作为非类型模板参数的。(C++20 才支持)

二、模板的特化

1. 什么是模板的特化

我么先来看下面这个例子，我们写了一个用于比较的函数模板，用它来比较一些值或者类对象。

cpp 复制代码

template<class T>
bool Less(T left, T right)
{
	return left < right;
}

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

	Date d1(2025, 7, 3);
	Date d2(2025, 7, 4);
	cout << Less(d1, d2) << endl;  // 可以比较，结果正确

	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl;  // 可以比较，结果错误

	return 0;
}

上述例子中，如果我们传入的是指针的话，我们希望这个函数比较的是指针所指的对象，但是由于函数内部的逻辑原因，实际比较的是指针的地址关系，也就无法比较它们所指向的日期。

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

2. 函数模板特化

函数模板的特化步骤：

必须要先有一个基础的函数模板；

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

函数名后跟一对尖括号，尖括号中指定需要特化的类型；

函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

cpp 复制代码

// 基础的函数模板
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

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

这样一来，当我们再次传入 Date 类的指针的时候，就会优先调用特化的版本，比较的结果就能正确了。但是，函数模板的特化用得比较少，一般情况下如果函数模板遇到不能处理或者处理有误的类型，我们直接另外写一份普通函数即可，调用的时候也会优先调用这个函数。

cpp 复制代码

bool Less(Date* left, Date* right)
{
	return *left < *right;
}

3. 类模板特化

(1) 全特化

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

cpp 复制代码

// 普通类模板
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;
}

输出

cpp 复制代码

Data<T1, T2>
Data<int, char>

(2) 偏特化（半特化）

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

【偏特化一】部分特化

cpp 复制代码

// 偏特化
// 将第二个参数特化为 int, 剩下的不变
template <class T1>
class Data<T1, int>
{
public:
	Data() { cout << "Data<T1, int>" << endl; }
private:
	T1 _d1;
	int _d2;
};

【偏特化二】参数更进一步的限制

cpp 复制代码

// 两个参数偏特化为指针类型 
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, char> d1;         // 调用全特化的版本
	Data<double, int> d2;       // 调用偏特化的int版本
	Data<int, double> d3;       // 调用基础的模板    
	Data<int*, int*> d4;        // 调用特化的指针版本
	Data<int&, int&> d5(1, 2);  // 调用特化的引用版本
	
    return 0;
}

输出

cpp 复制代码

Data<int, char>
Data<T1, int>
Data<T1, T2>
Data<T1*, T2*>
Data<T1&, T2&>

三、模板分离编译

1. 分离编译模式

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

2. 模板的分离编译引发的问题

在之前的 vector 的模拟实现中我们提到过不要将模板的声明与定义分离到两个文件，那么这是为什么？

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

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;
}

分析：

一个程序要运行，需要经历以下步骤：

预处理：展开头文件、宏替换、条件编译、去掉注释......，对应的 .cpp 文件生成对应的以 .i 为后缀的文件。如 a.cpp 经过预处理后就会生成一个 a.i 的文件。

编译：检查语法、生成汇编代码 (符号指令)。生成 .s 为后缀的文件。

汇编：将汇编代码转换成二进制代码。生成 .obj 为后缀的文件。

链接：将 .o 文件链接在一起，生成可执行程序 (xxx.exe) 。

由此可知，C++ 编译器不支持模板的分离式编译，是因为在编译时，编译器需要知道模板的定义来实例化，而模板只在使用时实例化。当编译单独的 .cpp 文件时，若模板实现未被引用，编译器就不会生成对应的二进制代码，导致链接器无法找到符号地址，引发错误。

3. 解决方案

将模板的声明和定义放到同一个文件里，荐使用这种。
在模板定义的位置显式实例化，这种方法不实用，不推荐使用。

四、模板总结

【优点】

模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生；

增强了代码的灵活性。

【缺陷】

模板会导致代码膨胀问题，也会导致编译时间变长；

出现模板编译错误时，错误信息非常凌乱，不易定位错误。