模板。。。。

1、函数模板

1.1、模板的实例化（隐式）

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

#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 = 10;
	int b = 20;
	double c = 1.1;
	double d = 2.2;
	swap(c,d);
	cout << c << " " << d << endl;
	Swap(a,b);
	cout << a << " " << b << endl;
}

1.2、显示实例化

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

//显示实例化
cout<<Add<int>(a,c)<<endl;

1.3、模板参数的匹配原则

当模板和非模板的都存在的时候而且与这两个都可以匹配上，那么优先选择非模板的

//通用加法函数
template<class T>
T Add(const T& a, const T& b)
{
	cout << "哈哈哈哈" << endl;
	return a + b;
}
//专门处理int的加法函数
int Add(int left,int right) {
	cout << "xxxxx" << endl;
	return left + right;
}

void test() {
	//当有通的模板和专门的类型的时候
	//你和专门处理的类型一样先调用这个
	//这里调用的是int Add(int left,int right)
	int a = 1;
	int b = 2;
	cout << Add(a,b) << endl;
	//这里强制用模板的
	/*Add<int>(a,b);*/

	//这里用的是普通的函数
	//因为模板不支持类型转换
	cout<<Add(a,1.2)<<endl;
}

2、模板类

注意：模板类的实例化必须是显示的调用不可以是隐式的必须指定类型

template<class T>
class stack {
public:
	stack(int capp=4) {
		a = new T[capp];
		size = 0;
		cap = capp;
	}
	~stack() {
		delete[]a;
		size = cap = 0;
	}
private:
	T* a;
	int size;
	int cap;
};
int main() {
	//类模板只能显示调用
	stack<int>st;//	这里是定义一个int的类
	stack<double>st;//这里是double的类
}

2.1、类模板的内部声明，类外定义

外部定义的部分记住也要写成一个模板（目前类模板的声明和定义尽量放到同一个文件）

注意：类模板和模板类不是同一个

类模板：是一种通用的类定义，它可以根据用户的需求来生成特定类型的类

模板类： 通过类模板定义的那个类叫做模板类

template<class T>
class stack {
public:
	//类内声明内外定义
	stack(int capp = 4);
	~stack() {
		delete[]a;
		size = cap = 0;
	}
private:
	T* a;
	int size;
	int cap;
};

//类外定义
template<class T>
stack<T>::stack(int capp) {
	a = new T[capp];
	size = 0;
	cap = capp;
}