【C++初阶】函数模板与类模板

引言.泛型编程

泛型编程可以实现通过书写模板,让编译器利用模板套用在不同类型上,从而生成不同类型所对应的代码

模板分为:
1.函数模板
2,类模板

一.函数模板

1.基本使用

或许我们还满足于C++的函数重载能够使用同名函数实现不同类型变量的交换

但是大佬们不这么想,有了函数重载的确解决了C语言的大部分问题,但是函数重载有两个不太方便的地方:

1. 对于我提前已知的类型,函数重载实现的代码,复用性不够好,代码逻辑几乎完全一样,显得冗余
2. 对于我提前未知的类型,得临时函数重载,改巴改巴形成一个该类型的重载函数

于是,大佬心里就在想,能不能像铸铁一样,刻出一个模子(模板),然后通过浇筑不同的材料(不同的类型),从而锻造成不同材料制成的宝刀(不同类型的目标代码)

函数重载版本:

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}

int main()
{
	int a = 1, b = 2;
	Swap(a, b);

	
	double c = 1.1, d = 2.2;
	Swap(c, d);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

函数模板版本：

class A
{
	friend ostream& operator<<(ostream& out, const A& a);
public:
	A(int a = 10)
		:_a(a)
	{
		;
	}
private:
	int _a;
};

//template
template
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

inline ostream& operator<<(ostream& out, const A& a)
{
	out << a._a << endl;
	return out;
}

int main()
{
	//提前已知的类型1.
	int a = 1, b = 2;
	Swap(a, b);
	
	//2.
	double c = 1.1, d = 2.2;
	Swap(c, d);

	//提前未知的类型
	A a1(12), a2(23);
	Swap(a1, a2);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

通过函数模板我们可以看到泛型编程的优点:

1. 提高代码的复用性
2. 万变不离其宗,对于提前未知的类型也可以灵活应对

ps:通过单步调试,我们可以看到三次都能进入void Swap(T& left, T& right),但是他们调用的并非是这个模板,而是由这个模板实例化出来的函数,这能进到模板,那是编译器为了方便展示特意地.

这个模板是写给编译器的,编译器会根据你传入的类型自动推演并实例化出对应类型的函数代码

ps:关于模板参数的问题:

3个，4、6、7正确，声明模板的格式为：template<类型 形参名1，类型 形参名2…>，类型有class和typename。

2.拔高训练

2-1自动推演实例化和显式实例化

那如果我想用一个同类型的Swap模板实例化出来的函数交换两个不同类型的实参,可以吗?

答案:不可以,没办法完成类型的转换,因为函数得先被推演出来才能发生类型转换,但是这次是函数在推演得时候就出现问题了.

另外就算不是用函数推,这里也行不通,那是因为这是传引用传参,传引用传参的话,发生类型转换的时候就会产生一个临时变量,这个时候就会出现临时变量是const试图传给形参是非const引用的问题,也不能完成隐式类型转换.(因为要交换,也不能在形参上加const修饰)

template
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

int main()
{
	int a = 10;
	double c = 1.1;
	Swap(a, c);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

那如果我就是想这样不同类型实参之间进行逻辑业务(比如求和),我们可以采取下面3种方法:

1.新建一个不同类型参数的函数模板

这样的话,不同类型和同一类型的实参都可以随意调用

template
T2 Add(const T1& left, const T2& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 1.1, d2 = 2.2;
    //同一类型之间
	cout << Add(a1, a2) << endl;
	cout << Add(d1, d2) << endl;

    //不同类型之间
	cout << Add(a1, d2) << endl;
	cout << Add(d1, a2) << endl;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.实参处强制类型转换使得自动推演实例化能作用

3.调用和函数处显式推演实例化

2.3一起演示:

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

	int a = 10;
	double c = 1.1;
	//2.自动推演实例化
	cout << Add(a, (int)c) << endl;
	cout << Add((double)a, c) << endl;

	//3.显式实例化
	cout << Add(a, c) << endl;
	cout << Add(a, c) << endl;
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

ps:模板参数的书写方式和函数参数很像,但是模板参数定义的是类型,函数参数定义的是形参变量

//正确写法:
// template
//错误写法:
//template
//template
1
2
3
4
5

2-2优先选择自己写的“加法”函数

template

//通用的加法函数
T Add(const T& left, const T& right)
{
	return left + right;
}

//专门处理int的加法函数
int Add(const int& left, const int& right)
{
	return left + right;
}

int main()
{
	int a1 = 1, a2 = 2;
	cout << Add(a1, a2) << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

通过调试我们发现:

编译器也是一个懒狗,当模板生成的通用加法函数和自己写的某类型的加法函数同时存在时,(盲猜可能是函数名修饰规则不一样,所以能同时存在)

编译器会优先选择我们自己写的某类型的加法函数,而不是采用模板生成的.

那假如我就是想编译器能调用模板生成的加法函数:

使用模板的显式实例化:

Add< int>(a1,a2)

二.类模板

1.基本使用

先来看看我们之前用类型重命名写的栈类：

//这里使用了typedef类型重命名

//类型重命名
typedef int STDateType;

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (STDateType*)malloc(sizeof(STDateType) * _capacity);
		_capacity = capacity;
		_size = 0;
	}
	~Stack()
	{
		_a = nullptr;
		_size = _capacity = 0;
	}
	void Push(STDateType x)
	{
		_a[_size++] = x;
	}
private:
	STDateType* _a;
	int _capacity;
	int _size;
};

int main()
{
	Stack St1(100);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

这typedef似乎也能满足我实现不同类型的栈的需求,但是这typedef有一个不足的地方:

假如我在一份代码里想实现两个存放不同类型变量的栈,typedef就无法满足.

	Stack St1(100);
	Stack St2('a');
1
2

实际上,typedef完成的是代码的可维护性,而非我们今天所讲的泛型编程,我们今天要讲的类模板才是真正的泛型编程!

template

class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = (T*)malloc(sizeof(T) * _capacity);
		_capacity = capacity;
		_size = 0;
	}
	~Stack()
	{
		_a = nullptr;
		_size = _capacity = 0;
	}
	void Push(const T& x)
	{
		_a[_size++] = x;
	}
private:
	T* _a;
	int _capacity;
	int _size;
};

int main()
{
	//函数模板可以根据实参传递形参,推演模板参数
	//类模板一般没有推演时机,所以只能显式实例化
	Stack St1(100);
	St1.Push(1);

	//他们都是一个类实例化出来的
	//但是模板参数不同,他们就是不同类
	Stack St2(200);
	St2.Push(2.2);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

ps:

1. 类模板一般没有推演时机(比如栈类,构造函数只传个数,没有栈内元素),所以只能显式实例化
2. 模板参数不同,就是不同类(和函数模板参数不一样,就是不同函数)

//类模板的显式实例化
Stack St1(10);
//函数模板的实例化
add(1, 2);
1
2
3
4

大胆的尝试:一个模板参数能同时用在类模板和函数模板上或不同的两个函数模板上吗?—不可以

2.小试牛刀

用类模板模拟实现一个数组类(这里好多写的很有启发性的语法代码)

#include

#define N 10
//4.命名空间域:解决与库中array的冲突问题
namespace song
{
	template
	class array
	{
	public:
		//1.inline内联
		//2.assert断言:越界100%检查
		//3.引用作返回值的两个好处
		inline T& operator[](size_t i)
		{
			assert(i < N);
			return _a[i];
		}
	private:
		T _a[N];
	};
}

int main()
{
	song::array a;
	for (int i = 0; i < N; i++)
	{
		a[i] = i;
		++a[i];
		cout << a[i] << endl;
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

写的好的几个地方:

	//1.inline内联
	//2.assert断言:越界100%检查
	//3.引用作返回值的两个好处
	//4.命名空间域:解决与库中array的冲突问题
1
2
3
4

这里只讲第3点两个好处:

首先一定得采用传引用返回(出了作用域,_a[i]还是存在),在这里传引用返回行不通

至于两个好处:

1. 传引用返回可以修改(在auto讲过)—–传值行不通的原因
2. 减少拷贝