C++ 模板_c++模板-CSDN博客

本文链接：https://blog.csdn.net/qq_70793373/article/details/128990424

文章目录

一、泛型编程
二、函数模板
三、类模板

一、泛型编程

泛型编程：编写与类型无关的通用代码，代码复用的一种方法

在 C++ 中，我们可以通过函数重载实现通用的交换函数 Swap ，但是有一些缺点

重载函数只有类型不同，使得代码复用率不好，需要使用新类型时，就必须自己写该类型的重载函数
当有一个重载函数出错时，可能需要检查所有的函数

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

于是 C++ 中引入了模板，可以给函数或类设置模板类型参数，模板类型参数在函数或类中表示广泛的类型，在使用时会替换为正在使用的这个类型

//class 关键字可以换成 typename 关键字，注意：这里不能使用 struct 关键字
template<class T1, class T2,...> //T1、T2,... 是模板类型参数，表示广泛的类型

模板是泛型编程的基础，给函数或类添加模板类型参数，就称为函数模板和类模板

模板是与具体类型无关的通用代码，当我们使用模板并填充某种类型时，编译器就会根据该类型实例化出该模板样式的代码

二、函数模板

函数模板是与具体类型无关的函数代码，当我们调用模板函数时，编译器会根据实参的类型实例化出该函数模板样式的代码

于是交换函数的通用版本就可以用函数模板简单的实现了

#include <iostream>

using namespace std;

//T 代表广泛的类型，是调用该模板函数时实参的类型
template<class T> void Swap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

int main()
{
	int a1 = 1, b1 = 2;
	Swap(a1, b1); //向 Swap 模板函数填充 int，编译器自动生成 int 版 Swap
	cout << a1 << " " << b1 << endl;	//输出 2 1

	double a2 = 1.11, b2 = 2.22;
	Swap(a2, b2); //向 Swap 模板函数填充 double，编译器自动生成 double 版 Swap
	cout << a2 << " " << b2 << endl;	//输出 2.22 1.11

	char a3 = 'a', b3 = 'b';
	Swap(a3, b3); //向 Swap 模板函数填充 char，编译器自动生成 char 版 Swap
	cout << a3 << " " << b3 << endl;	//输出 b a

	return 0;
}

在编译阶段，编译器根据实参的类型实例化出该函数模板样式的函数代码
在这里插入图片描述
在调用模板函数时：

编译器根据实参类型填充模板，然后实例化出实参类型的函数模板样式的代码，这种方式称为 隐式实例化
在函数名和参数之间加上 <type>，指定类型 type 填充模板，然后实例化出 type 类型的函数模板样式的代码，这种方式称为 显示实例化

#include <iostream>

using namespace std;

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

int main()
{
	int a = 1, b = 2;
	Swap<int>(a, b); //指定 int 类型填充模板函数 Swap，编译器自动生成 int 版 Swap
	cout << a << " " << b << endl;	//输出 2 1

	return 0;
}

其实库中已经实现了通用的交换函数 swap，以后直接使用即可
在这里插入图片描述

非模板函数可以和函数模板同名，并且允许函数模板实例化出的函数和非模板函数一样

#include <iostream>

using namespace std;

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

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

int main()
{
	//默认调用非模板函数
	cout << Add(1, 2) << endl; //输出 3

	//可以实例化出和非模板函数一样的函数
	//调用函数模板实例化的 int 版
	cout << Add<int>(1, 2) << endl; //输出 3

	return 0;
}

调用普通函数时，如果实参和形参数类型不同，可以隐式类型转换，但在以隐式实例化的方式调用模板函数时，如果实参和形参类型不同，不会隐式类型转换

当普通函数和模板函数重名时，并且函数调用传递的实参类型和普通函数的形参类型不匹配时，如果函数模板可以实例化出更匹配参数类型的函数，则会调用函数模板实例化的函数，否则调用普通函数

#include <iostream>

using namespace std;

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

template<class T1, class T2>
T1 Add(const T1& left, const T2& right)
{
	return left + (T1)right;
}

int main()
{
	//当函数模板可以实例化出更匹配参数的函数时，调用函数模板实例化的函数
	Add(1, 2.2);

	return 0;
}

三、类模板

类模板是与具体类型无关的类代码，用模板类实例化对象时，需要在类名后加上 <type>，指定类型 type 填充模板，然后实例化出 type 类型的类模板样式的代码

于是 Stack 类的通用版本就可以用类模板简单的实现了

#include <iostream>

using namespace std;

template<class T> class Stack
{
public:
	Stack(int capacity = 4)
		: _a(new T[capacity])
		, _top(0)
		, _capacity(capacity)
	{

	}

	~Stack();

private:
	T* _a;
	int _top;
	int _capacity;
};

//当成员函数在类外定义时，需要加上模板类型参数列表
//注意：Stack<T>(T 表示广泛的类型) 才是模板类的类名
template<class T>  Stack<T>::~Stack()
{
	if (_a)
	{
		delete[] _a;
		_a = nullptr;
		_top = _capacity = 0;
	}
}
 
int main()
{
	//Stack<int> 为存储整形元素的栈类的类型名
	Stack<int> s1; //指定 int 类型填充模板类 Stack，编译器自动生成 int 版 Stack

	//Stack<char> 为存储字符元素的栈类的类型名
	Stack<char> s2;//指定 char 类型填充模板类 Stack，编译器自动生成 char 版 Stack

	return 0;
}