C++初阶—模版进阶

最新推荐文章于 2025-05-09 11:29:32 发布

Awkwardx

最新推荐文章于 2025-05-09 11:29:32 发布

阅读量907

点赞数 27

文章标签： c++ java 开发语言

本文链接：https://blog.youkuaiyun.com/Awkwardx/article/details/146396569

版权

第一章：非类型模板参数

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

下面方法导致每个栈的空间都固定为10

#define N 10 
template <class T>
class Stack {
public:

private:
	T _a[N];
};

使用非类型模版参数

template <class T, size_t N> //size_t N 是非类型模版参数(需要是常量)
class Stack {
public:

private:
	T _a[N];
};

int main() {
	Stack<int, 10> st1;
	Stack<int, 1000> st2;
    //非类型模版参数只能传整形，主要用于定义静态栈、顺序表、数组等

	下方错误，必须使用常量。非类型的模板参数必须在编译期就能确认结果。
	//int n;
	//cin >> n;
	//Stack<int, n> st3;

	//使用非类型模版参数的容器array
	//C++11初衷期望array替代静态数组，但未初始化
	array<int, 10> a1;//a1存储在栈或是堆取决于开辟方式
	int a2[10];
	cout << sizeof(a1) << " " << sizeof(a2) << endl;//40 40
	a2[15] = 1;//未报错，但不正确。数组的越界检查是一种抽查。本质是指针解引用
	//a1[15] = 1;//报错。本质是函数调用。运算符重载有断言
	vector<int> v(10, 0);//array有些鸡肋，因为vector既能开空间，又能检查越界，还能初始化
	return 0;
}

注意：

浮点数、类对象以及字符串是不允许作为非类型模板参数的。
非类型的模板参数必须在编译期就能确认结果。

第二章：模版特化

2.1 概念

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

// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right) {
	return left < right;
}
int main() {
	
	cout << Less(1, 2) << endl; // 可以比较，结果正确
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 8);
	cout << Less(d1, d2) << endl; // 可以比较，结果正确
	
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl; // 可以比较，结果错误
	return 0;
}

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

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

2.2 函数模板特化

函数模板的特化步骤：

必须要先有一个基础的函数模板
关键字template后面接一对空的尖括号<>
函数名后跟一对尖括号，尖括号中指定需要特化的类型
函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

// 函数模板 -- 参数匹配
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(2022, 7, 7);
	Date d2(2022, 7, 8);
	cout << Less(d1, d2) << endl;
	
	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了
	return 0;
}

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

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

补充示例

//比较参数1是否小于参数2
//template <class T>
//bool Less(T left, T right) { return left < right; }
//
//template <>
//bool Less<Date*>(Date* left, Date* right) { return *left < *right; }

//如果待比较对象是自定义类型，那么会发生拷贝，所以通常参数是const T&
template <class T>
bool Less(const T& left, const T& right) { return left < right; }

//报错
//本意是想让const修饰引用，但该写法const修饰的是指针
//const在*左边修饰指向内容，在*右边修饰指针本身(这里是引用)
//template <>
//bool Less<Date*>(const Date*& left, const Date*& right) { return left < right; }

//正确版本，但是很别扭，可读性差
//原模版const修饰的是引用。在这个例子中，特化以后也要对Date*的引用进行const修饰。
//对指针的引用进行const修饰，就是不能修改指针本身。
//如果写成const Date*&，这里的const修饰的是Date*指向的内容。即Date*指向内容不能修改。
//所以改为Date* const &，const在*右边就是对Date*的修饰，即Date*本身不能修改，然后在对它进行引用。
//template <>
//bool Less<Date*>(Date* const & left, Date* const & right) { return *left < *right; }

//根据上方原因，函数不建议特化
//如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。
bool Less(Date* left, Date* right) { return *left < *right; }

int main() {
	Date* d1 = new Date(2023, 10, 8);
	Date* d2 = new Date(2023, 10, 9);
	cout << Less(d1, d2) << endl;//未提供特化时，结果可能是1，可能是0
	return 0;
}

2.3 类模板特化

2.3.1 全特化

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

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<T1, T2>
	Data<int, char> d2;//Data<int, char>

	return 0;
}

2.3.2 偏特化

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

template<class T1, class T2>
class Data {
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

偏特化有以下两种表现方式：
部分特化
将模板参数类表中的一部分参数特化。

// 将第二个参数特化为int
template <class T1>
class Data<T1, int> {
public:
	Data() { cout << "Data<T1, int>" << endl; }
private:
	T1 _d1;
	int _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(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<double, int> d1; // 调用特化的int版本
	Data<int, double> d2; // 调用基础的模板 
	Data<int*, int*> d3; // 调用特化的指针版本
	Data<int&, int&> d4(1, 2); // 调用特化的指针版本
	return 0;
}

2.3.3 类模板特化应用示例

有如下专门用来按照小于比较的类模板Less：

#include<vector>
#include <algorithm>
template<class T>
struct Less {
	bool operator()(const T& x, const T& y) const {
		return x < y;
	}
};
int main() {
	Date d1(2022, 7, 7);
	Date d2(2022, 7, 6);
	Date d3(2022, 7, 8);
	vector<Date> v1;
	v1.push_back(d1);
	v1.push_back(d2);
	v1.push_back(d3);
	// 可以直接排序，结果是日期升序
	sort(v1.begin(), v1.end(), Less<Date>());
	vector<Date*> v2;
	v2.push_back(&d1);
	v2.push_back(&d2);
	v2.push_back(&d3);

	// 可以直接排序，结果错误日期还不是升序，而v2中放的地址是升序
	// 此处需要在排序过程中，让sort比较v2中存放地址指向的日期对象
	// 但是走Less模板，sort在排序时实际比较的是v2中指针的地址，因此无法达到预期
	sort(v2.begin(), v2.end(), Less<Date*>());
	return 0;
}

通过观察上述程序的结果发现，对于日期对象可以直接排序，并且结果是正确的。但是如果待排序元素是指针，结果就不一定正确。因为：sort最终按照Less模板中方式比较，所以只会比较指针，而不是比较指针指向空间中内容，此时可以使用类版本特化来处理上述问题：

// 对Less类模板按照指针方式特化
template<>
struct Less<Date*> {
	bool operator()(Date* x, Date* y) const {
		return *x < *y;
	}
};

特化之后，在运行上述代码，就可以得到正确的结果。

第三章：模板分离编译

3.1 什么是分离编译

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

3.2 模板的分离编译

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

// 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其实也是可以的。推荐使用这种。
2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。

显示实例化示例

//a.h
template<class T>
T Add(const T& left, const T& right);

//a.cpp
//显示实例化
template
int Add<int>(const int& left, const int& right);
//此方法有个巨大缺陷，只支持int加法


//为什么声明和定义都放在.h就没问题了？
//ChatGPT 
//声明与定义分离的问题： 当模板的声明和定义分开时，编译器在处理源文件时，只能看到模板的声明，而无法看到其定义。
//由于模板实例化是在编译阶段根据实际类型参数生成代码的过程，编译器需要在实例化模板时能够访问到完整的定义。
//如果定义不可见，编译器将无法生成所需的实例，导致链接器无法找到相应的符号，从而引发链接错误。

//DeepSeek
//模板需要在编译时看到完整的定义，因为编译器需要根据使用情况生成具体的实例。
//当模板的定义在另一个源文件时，编译器在编译`main.cpp`的时候，只能看到声明，无法生成具体的代码，
//而源文件`example.cpp`里又没有实际用到的类型的实例，所以链接的时候找不到实现。

第四章：模板总结

【优点】

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

【缺陷】

模板会导致代码膨胀问题，也会导致编译时间变长
出现模板编译错误时，错误信息非常凌乱，不易定位错误

作业

1. 下列的模板声明中，其中几个是正确的（）

1)template
2)template<T1,T2>
3)template<class T1,T2>
4)template<class T1,class T2>
5)template<typename T1,T2>
6)template<typename T1,typename T2>
7)template<class T1,typename T2>
8)<typename T1,class T2>
9)template<typename T1, typename T2, size_t N>
10)template<typename T, size_t N=100, class _A=alloc<T>>
11)template<size_t N>

答案：D
分析:正确的定义为：4 6 7 9 10 11，一共6个，故答案为D

2. 以下程序运行结果正确的是( )

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

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(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<double, int> d1;
	Data<int, double> d2;
	Data<int*, int*> d3;
	Data<int&, int&> d4(1, 2);

	return 0;
}

A.Data<T1, T2> Data<T1, int> Data<T1*, T2*> Data<T1&, T2&>
B.Data<T1, int> Data<T1, T2> Data<T1&, T2&> Data<T1*, T2*>
C.Data<T1, int> Data<T1, T2> Data<T1*, T2*> Data<T1&, T2&>
D.Data<T1, T2> Data<T1, T2> Data<T1*, T2*> Data<T1&, T2&>

答案：C
分析:Data<double, int> d1; // 调用特化的int版本
Data<int, double> d2; // 调用基础的模板
Data<int*, int*> d3; // 调用特化的指针版本
Data<int&, int&> d4(1, 2); //调用特化的引用版本

3. 以下程序运行结果正确的是( )

template<typename Type>
Type Max(const Type& a, const Type& b) {
	cout << "This is Max<Type>" << endl;
	return a > b ? a : b;
}

template<>
int Max<int>(const int& a, const int& b) {
	cout << "This is Max<int>" << endl;
	return a > b ? a : b;
}

template<>
char Max<char>(const char& a, const char& b) {
	cout << "This is Max<char>" << endl;
	return a > b ? a : b;
}

int Max(const int& a, const int& b) {
	cout << "This is Max" << endl;
	return a > b ? a : b;
}

int main() {
	Max(10, 20);
	Max(12.34, 23.45);
	Max('A', 'B');
	Max<int>(20, 30);

	return 0;
}

A.This is Max This is Max<Type> This is Max<char> This is Max<int>
B.This is Max<int> This is Max<Type> This is Max<char> This is Max<int>
C.This is Max This is Max<int> This is Max<char> This is Max<int>
D.This is Max This is Max<Type> This is Max<char> This is Max

答案：A
分析:Max(10, 20); //能够直接匹配int参数，调动非模板函数
Max(12.34, 23.45); //double类型参数没有最佳匹配函数，此时只能调动模板函数
Max('A', 'B'); //能够直接匹配char参数,调动非模板函数
Max<int>(20, 30); //由于直接实例化了函数，因此要调动模板函数，但是，由于进行函数的int特化，所以会调动特化版本的模板函数

4. 关于模板的编译说法错误的是( )

A.模板在.h文件中声明，在.cpp里面实现
B.模板程序一般直接在一个文件里面进行定义与实现
C.不久的将来，编译器有望支持export关键字，实现模板分离编译
D.模板不能分离编译，是因为模板程序在编译过程中需要经过两次编译

答案：A
A.模板不支持分离编译，所以不能在.h声明，在.cpp实现
B.由于不支持分离编译，模板程序一般只能放在一个文件里实现
C.不支持分离编译并不是语法错误，而是暂时的编译器不支持，不久将来，或许会被支持
D.模板程序被编译两次，这是不能分离编译的原因所在

5. 以下说法正确的是( )

A.cin为缓冲流，键盘输入的数据一次性全部提取至对象中
B.针对输入流对象cin,输入的数据类型无需像C语言一样要求数据类型一致
C.cin如果要提取具有空格的整体字符串，需使用getline()方法
D.cin可以进行数据重定向，例如把数据写入文件

答案：C
A.cin只提取空格或者换行分隔得数据，不一定提取一次性输入的数据
B.输入数据的类型必须跟保存数据的变量类型要一致
C.正确
D.cin为标准输入流对象，不能从定向，其次写入数据是输出文件流对象的功能

6. 以下关于IO的相关特性说法错误的是( )

A.输入输出缓冲区可以屏蔽掉低级IO的实现
B.cout是标准输出流对象，应对屏幕，cin是标准输入流对象，应对键盘
C.输入输出缓冲区可以实现内容的“行”读取
D.IO中cerr是错误输出流对象，具有缓冲区

答案：D
A.输入输出缓冲区一定程度上屏蔽掉了低级IO的实现
B.cout、cin分别为标准输出和输入流对象，对应屏幕和键盘
C.输入输出缓冲区实现了行读取功能
D.发生错误时，系统需要立即输出以提醒用户，因此错误输出流对象cerr不具备缓冲区，故错误

7. 以下的各种说法错误的是( )

A.文件操作分为文本文件和二进制文件
B.文件的读写有顺序读写也有随机读写
C.文件操作一般需要经过 1.定义文件流2.打开文件3.对文件读写操作4.关闭文件
D.打开的文件对象可以不需要手动关闭，因为C++对象结束后会释放

答案：D
A.文件分为文本和二进制文件，因此对应的操作也分两种
B.文件读写有顺序和随机读写两种
C.这四个步骤为文件操作一般步骤
D.打开的文件对象在不需要时需要手动关闭，否则会占用资源，其次不关闭，数据不会主动从缓冲区写入文件

8. 以下说法错误的是( )

A.文件读写在文件缓冲区中进行
B.文件读写是顺序的，即从文件头开始进行，不能随机读写
C.读写数据时可用C++的提取运算符（>>）和插入运算符（<<）进行；也可以用读字符的get() 读字符串的getline()等函数进行
D.文件操作结束后，应该显式地关闭该文件，与打开文件相对应

答案：B
A.为了效率，文件的数据读写都放在缓冲区进行
B.文件可以进行随机读写，故错误
C.文件流对象可以通过提取符或者插入符，以及相关函数进行数据读写
D.如果不关闭，数据一般不会主动从缓冲区写入文件，因此结束时需要关闭文件流对象

9. 以二进制可写方式打开一个文件的方法是( )

A.ifstream obj("text.bin", ios::in|ios::binary);
B.ofstream obj("text.bin", ios::in|ios::out);
C.ifstream obj("text.bin", ios::out|ios::binary);
D.ofstream obj("text.bin", ios::out|ios::binary);

答案：D
A.可写方式要使用输出文件流，A错
B.二进制方式需要使用ios::binary标志
C.可写方式要使用输出文件流
D.正确