模板

void Swap(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void Swap(double* x, double* y)
{
	double tmp = *x;
	*x = *y;
	*y = tmp;
}

void Swap(char* x, char* y)
{
	char tmp = *x;
	*x = *y;
	*y = tmp;
}

如上述所示，我们在实现函数的时候，有很多函数会像上述一样，实现过程差不多，但是由些许不同，那么我们都把这些实现出来会显得很呆，C++祖师爷也想到了，所以设计了模板。

函数模板

 像上述的三个函数，算法相同，只是 参数的类型不同，那么我们就可以定义 函数模板，这样不管是什么类型，都可以使用这个函数模板，来实现相同的 算法。

语法：

template<typename T1, typename T2,......,typename Tn>

返回值类型 函数名(参数列表){}

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

其实就是在模板出来的早期用的就是 clsss ，但是后面觉得不好区分就重写定义了 typename 这个关键字。

像上述交换变量的 函数我们就不用写 三个了，写一个就行了：

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

我们不管使用内置类型还是自定义类型都可以实现上述的 算法：

 而且，模板函数并不是调用的 这个模板，而是 编译器帮我们实现了 这些重载函数，然后去调用这些重载函数：

 我们发现上述 两个 Swap 函数的地址不同。

 编译器会根据我们 传入的参数来推演，推演出参数的类型：

 编译器推导出之后，就会自己实现这个模板当前对应类型的 实例化函数。

 这里其实就是 模板的 实例化，和对象的实例化有点类似。

 而且，这里推导的类型，可以是任意类型，不管是内置类型 还是 自定义类型都可以推导出来，也就是说不管是什么类型都可以使用 模板推导出来。

像上述这样使用 模板来实现的 编程，也被称为是 泛型编程，因为这里的 函数并不是针对某一种 类型，而是针对 很多的类型。

 模板的  " <> "  当中其实和 函数的参数列表差不多，我们可以指定多个参数类型，同时 模板当中的参数也可以是 函数的返回值类型：

 对于 template 函数模板的作用范围就是这个函数。

 模板函数的实例化

 模板函数的实例化分为两种：

隐式实例化，这是编译器自己去推导出来的实例化函数，但是有的时候，对应的模板参数并不能实现 我们想要的参数类型，如下例子：

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.0, d2 = 20.0;
	cout << Add(a1, a2) << endl;
	cout << Add(d1, d2) << endl;

    cout << Add(a1 , d1 ) << endl; // 不能编译通过

	return 0;
}

我们在模板当中只定义了 一个 T 的模板参数，但是我们传入的参数确是 int 和 double 类型的，这样做编译器就很为难，他不知道应该 使用哪一个 类型作为推导出来的类型，报错：
 

 当我们遇到这种问题的时候，有两种解决方式，第一种就是进行强制类型转换，像上述例子就是把其中一个参数 强转成 另一个参数的类型：

	cout << Add(a1, (int)d1) << endl;
	cout << Add((double)a1, d1) << endl;

  而且向上述 使用 强制转换的方式 实现传参的时候要注意，上述是 传入的是引用：因为强制转换会产生临时变量，像上述的强制转换的 变量传参，不是直接传这个 d1 或者是 a1 这个变量引用给函数形参，而是把强制类型转换所产生的临时变量 赋值传给 函数形参，而 临时变量具有常性，所以，如果我们在函数形参位置不加 const 修饰的话，就会发生权限的放大 ，就会报错：

第二种，就是我们模板实例化的 第二种形式：显式实例化。

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

这个时候就不需要 编译器自己去进行参数类型的推演了，向上述代码，第一种就直接实例化为了 int ，第二种就是直接实例化为了 double。

显式实例化的 使用的场景最多是如下的 这种形式：

 有些函数不能自动推导 参数类型，只能使用显示实例化。

template<typename T>
T* Carray(int n)
{
	return new T[n];
}

int main()
{
	Carray(10);

	return 0;
}

 编译器进行推导的时候，必须通过参数进行推导，返回值，或者是函数其中的 算法来推导等等的这些方式都是不行的。

所以这里就要使用 显示实例化：

	Carray<double>(10);

通过显示实例化，在指定 模板当中的参数的类型，这样就可以实现上述函数的调用。

类模板

 C++当中想到，在类当中也有类似的，和上述函数算法相同，但是参数类型不同的问题，所以在C++ 当中 有类模板来解决上述问题。

语法：

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

我们在C当中实现 栈的时候，是把存储的数据类型 用 typedef 来重新命名，这样做的好处是以后我们想要栈存储其他类型的 数据的时候，只需要修改 typedef 这一行代码就行了，但是这样做只能修改一个 栈的实现。当我现在想要同时实现多个 存储不同数据类型的栈的时候，typedef 就不能实现了。

像上述功能，在C++当中使用 类模板就可以很方便的实现：

template<class T>
class Stack
{
public:
	Stack(size_t a = 3)
	{
		cout << "Stack(size_t a = 1)" << endl;

		_array = new T[capacity];
		if (_array == NULL)
		{
			perror("malloc fail");
			return;
		}

		_capacity = a;
		_size = 0;

	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}

protected:
	T* _array;
	int         _size;
	int         _capacity;
};

那么对于上述实现的类模板，我们就可以这样来使用 这些类了：

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

	return 0;
}

因为我们上述类的构造函数，没有使用 T 这个模板参数，所以，构造函数不一定都要 使用 类模板当中 参数，其实构造函数就不一定需要 使用 推演，像上述的初始化方式函数很香的。

 那么类模板当中也可以传入多个参数，如果我们有需求的话。

 对于 template 类模板的作用范围就是这个类。

 如果类模板当中的成员函数在类外面 定义的话，和普通类的 类外定义有些许不一样。

•  首先，因为 对于 template 类模板的作用范围就是这个类  那么当我们类外定义的时候，编译器就不认识函数当中的 T 这个模板参数了。所以我们在类外进行 定义成员函数的时候，需要给这个函数重新声明这个 T 模板参数。
• 其次，对于普通类，类名就是类型，我们在调用普通类的时候，都是直接使用 类名来作为这个 对象的 类的类型的；但是 模板类的类名不是类型，类模板的类型是 类名<模板类型> 这样的形式。所以，我们在 用 " :: " 来指明 这个函数是哪一个 域当中函数的时候，需要使用 类名<模板类型>  这样的方式来表明这个函数的域。

 那么根据上述两点，我们在类模板外声明 其中的成员函数的时候，应该这样来实现：

template <class T>
Stack<T>::Stack()
{
	cout << "Stack(size_t a = 1)" << endl;

	_array = new T[capacity];
	if (_array == NULL)
	{
		perror("malloc fail");
		return;
	}

	_capacity = a;
	_size = 0;
}