C++模板的原因、函数模板、类模板等的介绍

---

前言

C++模板的原因、函数模板、类模板等的介绍

---

一、C++模板的原因

void Swap(int& x1, int& x2)
{
	int tmp = x1;
	x1 = x2;
	x2 = tmp;
}

void Swap(double& x1, double& x2)
{
	double tmp = x1;
	x1 = x2;
	x2 = tmp;
}

void Swap(char& x1, char& x2)
{
	char tmp = x1;
	x1 = x2;
	x2 = tmp;
}

• 如上述交换函数，每个交换函数只有参数的类型不同，但是需要写三份代码，不是很高效。
• C++ 使用模板来解决上述问题。

二、函数模板

C++ 模板包括 函数模板 和 类模板。

1. 函数模板的概念

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

2. 函数模板的格式

• 函数模板的格式为： template<typename T1, typename T2,…,typename Tn>
• 使用模板来书写函数的格式为： 返回值类型 函数名(参数列表){}

template <typename T>
void Swap(T& x1, T& x2)
{
	T tmp = x1;
	x1 = x2;
	x2 = tmp;
}

• 本质上来说，函数模板是定义了函数参数的类型。

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

#include <iostream>
using namespace std;

 // 模板
template <typename T>
void Swap(T& x1, T& x2)
{
	T tmp = x1;
	x1 = x2;
	x2 = tmp;
}

int main()
{
	int a = 0, b = 1;
	Swap(a, b);
	cout << "a = " << a << "b = " << b << endl;
	double c = 3.14, d = 6.28;
	Swap(c, d);
	cout << "c = " << c << "d = " << d << endl;
	char e = 'm', f = 'n';
	Swap(e, f);
	cout << "e = " << e << "f = " << f << endl;



	return 0;
}

3. 函数模板的原理

template <typename T>
void Swap(T& x1, T& x2)
{
	T tmp = x1;
	x1 = x2;
	x2 = tmp;
}
int main()
{
	int a = 0, b = 1;
	double c = 3.14, d = 6.28;
	char e = 'm', f = 'n';
	Swap(a, b);
	Swap(c, d);
	Swap(e, f);

	return 0;
}

上述Swap调用的不是同一个函数。

函数模板在调用时，函数模板会进行推演。如下：

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

4. 函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

（1）隐式实例化

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

#include <iostream>
using namespace std;

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

int main()
{
	int a1 = 1, a2 = 2;
	double d1 = 1.1, d2 = 2.2;

	cout << Add(a1, a2) << endl;
	cout << Add(d1, d2) << endl;

	return 0;
}

• 在编译时，当编译器看到该实例化时，推演其实参类型。

（2）显式实例化

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

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

int main()
{
	int a1 = 1, a2 = 2;
	double d1 = 1.1, d2 = 2.2;

	Add(a1, d2); // 两者参数不一样，编译器无法推导，返回值类型无法确定

	return 0;
}

• 解决上述问题一般有两种方法

1. 用户自己强制转换类型

	int a1 = 1, a2 = 2;
	double d1 = 1.1, d2 = 2.2;

	//Add(a1, d2);

	Add(a1, (int)d2);
	Add((double)a1, d2);

2. 使用显式实例化

	int a1 = 1, a2 = 2;
	double d1 = 1.1, d2 = 2.2;

	Add<int>(a1, d2);
	Add<double>(a1, d2);
	
	cout << Add<int>(a1, d2) << endl;
	cout << Add<double>(a1, d2) << endl;

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

5. 模板参数的匹配原则

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

#include <iostream>
using namespace std;


// 通用加法
template<typename T>
T Add(const T& left, const T& right)
{
	return left + right;
}

// 专门int的加法
int Add(int left, int right)
{
	return left + right;
}

int main()
{
	Add(1, 2);
	Add<int>(1, 2);

	return 0;
}

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

#include <iostream>
using namespace std;


// 通用加法
template<typename T>
T Add(const T& left, const T& right)
{
	cout << "T Add(const T& left, const T& right)" << endl;
	return left + right;
}

// 专门int的加法
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}

int main()
{
	Add(1, 2); // 与非函数模板完全匹配，不调会进行函数模板的实例化

	Add(1.1, 2.2); // 模板更匹配，进行函数模板实例化

	return 0;
}

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

三、类模板

1. 类模板的定义格式

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

---

#include <iostream>
using namespace std;

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


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

	void push(const T& data)
	{
		// 检查扩容
		_array[_top] = data;
		_top++;
	}

	~Stack()
	{
		delete[] _array;

		_top = 0;
		_capcity = 0;
	}
private:
	T* _array;
	int _top;
	int _capacity;
};

int main()
{
	Stack<int> s1;

	Stack<double> s2;

	Stack<char> s3;

	return 0;
}

注意： 类模板中函数放在类外进行定义时，需要加模板参数列表

template<class T>
class Stack
{
public:
	Stack(int capacity = 4);

	void push(const T& data)
	{
		// 检查扩容
		_array[_top] = data;
		_top++;
	}

	~Stack()
	{
		delete[] _array;

		_top = 0;
		_capcity = 0;
	}
private:
	T* _array;
	int _top;
	int _capacity;
};

template<class T>
Stack<T>::Stack(int capacity)
{
	_array = new T[capacity];
	_top = 0;
	_capacity = capacity;
}

2. 类模板的实例化

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

普通的类，类名也是类型。
类模板， 类名和类型不一样。

• Stack是类名。
• Stack是类型。

---

总结

C++模板的原因、函数模板、类模板等的介绍