模板初阶

1.泛型编程

编写与类型无关的代码，提高代码的复用性，模板是泛型编程的基础。

2.函数模板

2.1函数模板的概念

函数模板相当于一个模具，在使用时根据参数实例化成不同的函数。

2.2函数模板的格式

template<typename T>

返回值  函数名 （形参列表）{ }

注意：

typename是定义模板参数类型的关键字，也可以用class代替

每一个模板参数前都需要有关键字  但可以混用

比如：template<class T1,typename T2>

template<typename T>
void Swap(T& x, T& y)
{
	T temp = x;
	x = y;
	y = temp;
}
template<typename T1,typename T2>
//template<typename T1, class T2>    也是对的，但是两个虚拟类型前面都需要有声明  class 或者 typename 
void func(const T1& x,const T2& y)
{
	cout << x << " " << y << endl;
}

2.3函数模板的原理

 编译器通过对实参类型的推演，生成一份对应的函数。

2.4函数模板的实例化

用不同类型的参数推演出对应的函数模板叫做函数模板的实例化。

1.隐式实例化:编译器根据实参类型推导

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

int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.2;
	//隐式实例化
	cout << Add(a1, a2) << endl;
	cout << Add(d1, d2) << endl;

	return 0;
}

2.显式实例化：通过  函数名<类型> 实例化

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

int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.2;

	//用户自己强行转化
	cout << Add(a1, (int)d2) << endl;
	cout << Add((double)a1, d2) << endl;

	//显式实例化：在后面加上< >
	cout << Add<int>(d1, a2) << endl;
	cout << Add<double>(a1, a2) << endl;

	return 0;
}

2.5模板参数的匹配原则

1.函数模板可以与同名的非模板函数共存，而且可以转化成这个类型的函数模板。

// 专门处理int的加法函数
int Add(int left, int right)
{
 return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
 return left + right;
}
void Test()
{
 Add(1, 2); // 与非模板函数匹配，编译器不需要特化
 Add<int>(1, 2); // 调用编译器特化的Add版本
}

2. 在调用时如果非模板函数可以满足要求且与模板函数没有区别，则优先调用非模板函数而不会用模板生成一个实例。

但如果用函数模板实例化出的函数能更好的匹配，则调用实例化出来的函数。

// 专门处理int的加法函数
int Add(int left, int right)
{
 return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
 return left + right;
}
void Test()
{
 Add(1, 2); // 与非模板函数完全匹配，则不需要将模板函数实例化
 Add<int>(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器将根据实参生成更加匹配的Add函数
}

3.类模板

3.1类模板的定义格式

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

3.2类模板的定义实例化

类模板无法推演类型，必须要通过 类名<类型> 的方式实例化。

template<class T>
class Stack
{
public:
	Stack(size_t capacity = 3);
	void Push(const T& data);
	~Stack()
	{
		if (_array)
		{
			//delete _array;
			free(_array);
			_capacity = 0;
			_size = 0;
		}
	}
private:
	T* _array;
	int _capacity;
	int _size;
};

//类模板中函数放在类外定义时，需要加函数模板参数列表
//类模板无法推演实例化 都是显示实例化
template<class T>
Stack<T>::Stack(size_t capacity)//函数的缺省值只能在定义和声明中出现一次 一般放在声明
{
	_array = new T[capacity];
	_capacity = capacity;
	_size = 0;
}
//惠普实验室 STL 标准模板库——实现数据结构和算法的库
// 普通类：类型和类名一样
// 模板类：类型和类名不一样
// 类名：Stack
// 类型：Stack<T>
template<class T>
void Stack<T>::Push(const T& data)
{

	_array[_size] = data;
	_size++;
}

int main()
{
	Stack<int> s1;    // int
	Stack<double> s2; // double
	Stack<char> s3;   // char

	return 0;
}

普通类的类型就是类名

模板类的类型是  类名<  >