C++ | 模板（上）

最新推荐文章于 2023-05-22 19:44:26 发布

早凉

最新推荐文章于 2023-05-22 19:44:26 发布

阅读量450

点赞数 4

分类专栏： C++修炼秘籍文章标签： c++ c语言开发语言

本文链接：https://blog.csdn.net/m0_62824408/article/details/128892400

版权

C++修炼秘籍专栏收录该内容

14 篇文章 0 订阅

订阅专栏

【C++修炼秘籍】模板（上）

🌸心有所向，日复一日，必有精进

🌸专栏《C++修炼秘籍》

🌸作者：沂沐沐

4、简单使用模板模拟vector类（仅仅示例模板使用，不具体实现）

四、结束

一、泛型编程

假如，有这样一道题，请实现交换函数，能够完成如下变量的数据交换？

int main(){
	int a = 1;
	int b = 2;
	Swap(a, b);
	cout << a <<" "<< b << endl;
	double c = 1.1;
	double d = 2.2;
	Swap(c, d);
	cout << c << " " << d << endl;
	char e = 'e';
	char f = 'f';
	Swap(e, f);
	cout << e << " " << f << endl;
	double g = 1.1;
	int h = 2;
	Swap(g, h);
	cout << g << " " << h << endl;
	return 0;
}

首先，C++支持函数重载，所以我们可以这样实现：

void Swap(int& a, int& b){
	int tmp = a;
	a = b;
	b = tmp;
}
void Swap(double& a, double& b){
	double tmp = a;
	a = b;
	b = tmp;
}
void Swap(char& a, char& b){
	char tmp = a;
	a = b;
	b = tmp;
}
void Swap(double& a, int& b){
	int tmp = a;
	a = b;
	b = tmp;
}

确实，如果使用C语言，是不能有同名函数的，而C++的重载已经打破了这种限制；

but，仍然有问题：

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

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

函数模板：有时有两个或多个函数，其功能是相同的，仅仅是数据类型不同就可以使用函数模板

类模板：有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同就可以使用类模板

二、函数模板

1、什么是函数模板

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

2、函数模板格式

template<typename T1, typename T2,......,typename Tn>
返回值类型函数名(参数列表){}

template <class 类型参数1, class类型参数2, ...>
返回值类型  模板名(形参表)
{
    函数体
}

❗️ 注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

3、函数模板原理

函数模板是一个图纸，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

template<class T>
void Swap(T& a, T& b){
	T tmp = a;
	a = b;
	b = tmp;
}

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

4、函数模板的实例化

编译器由模板自动生成函数的过程叫模板的实例化。在某些编译器中，模板只有在被实例化时，编译器才会检查其语法正确性。如果程序中写了一个模板却没有用到，那么编译器不会报告这个模板中的语法错误。

例如：

template<class T>
void Swap(T& a, T& b){
	T tmp = c;
	a = b;
	b = tmp;
}
int main(){
	int a = 1;
	int b = 2;
	Swap(a, b);
	return 0;
}

编译器报错：

当屏蔽下列语句：

//Swap(a,b);

编译通过！

4.1隐式实例化

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

template<class T>
void Swap(T& a, T& b){
	T tmp = a;
	a = b;
	b = tmp;
}
int main(){
	int a = 1;
	int b = 2;
	Swap(a, b);
	cout << a <<" "<< b << endl;
	double c = 1.1;
	double d = 2.2;
	Swap(c, d);
	cout << c << " " << d << endl;
	char e = 'e';
	char f = 'f';
	Swap(e, f);
	cout << e << " " << f << endl;
	double g = 1.1;
	int h = 2;
	Swap(g, h);//此处报错
	cout << g << " " << h << endl;
	return 0;
}

该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
通过实参g将T推演为int，通过实参h将T推演为double类型，但模板参数列表中只有一个T，
编译器无法确定此处到底该将T确定为int 或者 double类型而报错，此时，用户可以自己强制类型转换，也可以采用如下方案：

template<class T,class K>
void Swap(T& a, K& b){
	T tmp = a;
	a = b;
	b = tmp;
}

也能编译通过；

❗️ 注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅

4.2. 显式实例化

显式实例化：在函数名后的<>中指定模板参数的实际类型

template<class T>
T Add(T a, T b){
	return a + b;
}
int main(){
	double g = 1.1;
	int h = 2;
	Add<int>(g, h);//显示实例化
	return 0;
}

如果不显示实例化，上述代码亦会出现模板参数列表中只有一个T，编译器无法确定此处到底该将T确定为int 或者 double类型而报错；

当然我们也可以采用用户强制类型转换，也可：

template<class T,class M>
T Add(T a, M b){
	return a + b;
}

这里涉及类型转换，请按需使用，这里只是举例说明；

隐式实例化中的案例像如下方式是报错的：

template<class T>
void Swap(T& a, T& b){
	T tmp = a;
	a = b;
	b = tmp;
}
int main(){
	double g = 1.1;
	int h = 2;
	Swap<int>(g, h);//此处报错
    Swap<int&>(g, h);//此处报错
	return 0;
}

但是可以如下显示实例化,编译通过：

template<class T,class M>
void Swap(T a, M b){
	T tmp = a;
	a = b;
	b = tmp;
}
int main(){
    double g = 1.1;
	int h = 2;
	Swap<double,int>(g, h);
    return 0;
}

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

5、模板参数的匹配原则

一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

template<class T>
T Add(T a, T b){
	return a + b;
}

int Add(int a, int b){
	return a + b;
}

int main(){
	int a = 1;
	int b = 2;
	Add<int>(a, b);//调用编译器特化的Add版本
	Add(a, b);//与非模板函数匹配，编译器不需要特化
    return 0；
}

这里也看出，有最合适的就不用模板了，确实，有现成的编译器不用，还要生成多麻烦；

对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板

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

三、类模板

1、类模板的定义格式

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

2、类模板的实例化

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

int main(){
    vector<int> s1;
    vector<double> s2;
	return 0;
}

3、类模板使用注意

类模板的类型参数可以有一个或多个，每个类型前面都必须加class，
使用类模板时要注意其作用域，只能在其作用域内定义对象。

4、简单使用模板模拟vector类（仅仅示例模板使用，不具体实现）

template<class T>
	class vector
	{
	public:

		// Vector的迭代器是一个原生指针

		typedef T* iterator;
			// construct and destroy

			vector() :_start(nullptr),
			_finish(nullptr),
			_endOfStorage(nullptr)
		{}

		vector(int n, const T& value = T())
			:_start(nullptr),
			finish(nullptr),
			_endOfStorage(nullptr)
		{
			reserve(n);
			if (size_t i = 0; i < n; ++i){
				push_back(value);
			}
		}
		// 使用析构函数演示：在类中声明，在类外定义
		~vector();
		size_t size() const {
			return _finish - _start;
		}

		size_t capacity() const{
			return _endofstorage - _start;
		}
		void push_back(const T& x){
			if (_finish == _endofstorage)
			{
				size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);
			}

			*_finish = x;
			++_finish;
		}

		void pop_back();

			//……

		void reserve(size_t n){
			//如果n>capacity()就需要开辟空间
			if (n > capacity()){
				//需要把原来的数据进行深度拷贝
				size_t oldSize = size();
				T* tmp = new T[n];
				if (_start){
					//memcpy(tmp, _start, sizeof(T)*oldSide);
					if (size_t i = 0; i < oldSize; ++i){
						tmp[i] = _start[i];
					}
					//不为空
					delete[] _start;
				}

				_start = tmp;
				_finish = tmp + oldSize;
				_endofstorage = _start + n;
			}
		}

	private:

		iterator _start; // 指向数据块的开始

		iterator _finish; // 指向有效数据的尾

		iterator _endOfStorage; // 指向存储容量的尾

	};
	// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
	template <class T>
	vector<T>::~vector()
	{
		delete[] _start;
	}

实例化时：

int main(){
    vector<int> s1;
    vector<double> s2;
	return 0;
}

四、结束

模板初阶完成，到此为止我们能简单运用模板来完成我们的代码了，模板进阶会有更多干货，敬请期待|

如果觉得有帮助的话，可以点赞 + 收藏 + 评论支持一下哦！这对我的帮助很大~:)

早凉

关注

4
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
C++ | 模板（上）

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

扫一扫

专栏目录