【模板】

1、泛型编程

编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础

2、模板分为函数模板和类模板
（1）函数模板

• 什么是函数模板？
  解：代表了一个函数族，该模板与类型无关，在使用时被参数化，根据**实参类型产生函数的特定类型版本。

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

注：template是定义模板的关键字，typename可以换成class

• 函数模板的原理是什么？
  a)模板本身并不是函数，我们写了模板，编译器根据不同的使用方式产生的特定具体类型函数的模具。

b)编译器编译阶段，编译器根据传入的实参类型来推演生成对应类型的函数以备调用。

• 函数模板的实例化
  a)用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化
  b)隐式实例化
  int a1 = 10, a2 = 20; double d1 = 10.0, d2 = 20.0; Add(a1, a2);
  c)显式实例化
  int a = 10; double b = 20.0; Add<int>(a, b);//两个参数类型不一致的时候
• 函数模板参数匹配原则
  a)非模板函数可以和一个同名函数模板同时存在，且函数模板可以被实例化为这个非模板函数。
  b)对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
  （谁的参数匹配度高，就调用谁，参数匹配度相同，调用非模板函数）
  c)模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

（2）类模板

a)类模板定义格式

template <class numtype>
class Compare
{
	numtype x, y;
public:
	Compare(numtype a, numtype b)
	{
		x = a;
		y = b;
	}
	numtype max()
	{
		return(x > y) ? x : y;
	}
	numtype min()
	{
		return (x > y) ? y : x;
	}

};

b)类模板实例化
Compare<int>cmpl(3, 7); //定义对象cmpl，用于两个整数的比较 cout << cmpl.max() << endl;

3、非类型模板参数

模板参数分类型形参与非类型形参。
（1）类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
（2）非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用

template<class T, size_t N = 10>
class Array
{
public:
T& operator[](size_t index)
{
return _array[index];
}
const T& operator[](size_t index)const
{
return _array[index];
}
size_t Size()const
{
return _size;
}
bool Empty()const
{
return 0 == _size;
}
private:
T _array[N];
size_t _size;
}；

注：
（1）类对象和字符串不允许作为非类型模板参数
（2）非类型模板参数必须在编译期就确定结果。

4、模板特化

• 在原模版类的基础上，针对特殊类型进行特殊化实现方式。

（1）函数模板特化

template<>
bool IsEqual<char*>(char*& left, char*& right)
{
if(strcmp(left, right) > 0)
return true;
return false;
}

步骤：
a)有基础模板函数
b)关键字template后面接一对空尖括号
c)函数名后跟一对尖括号，尖括号里指定需要特化类型
d)函数形参类型与模板函数的基础参数类型相同

（2）类模板特化
a)全特化

template<>
class Data<int, char>
{
public:
Data() {cout<<"Data<int, char>" <<endl;}
private:
T1 _d1;
T2 _d2;
};

b)偏特化
1.部分特化

template <class T1>
class Data<T1, int>
{
public:
Data() {cout<<"Data<T1, int>" <<endl;}
private:
T1 _d1;
int _d2;
};

2.参数进一步限制
（对参数的进一步限制：为指针类型、引用类型等）

template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
Data() {cout<<"Data<T1*, T2*>" <<endl;}
private:
T1 _d1;
T2 _d2;
};

5、类型萃取

将内置类型和自定义类型分开（内置类型使用memcpy,自定义类型使用赋值方式拷贝）
STL底层用过这种方式

6、模板分离编译

（1)分离编译
一个程序由若干个源文件共同实现，每个源文件单独编译生成目标文件，最后将所有目标文件进行连接形成一个可执行文件即可。
（2)模板的声明和定义分开了

注：
因为是分离编译，则编译器在a.cpp里面没有看到模板函数实例化，故不会产生实例加法函数；
而在main.cpp里面，调用Add和Add,编译器在链接时会找其地址，但是由于两个函数没有生成实例化具体代码，所以链接时报错；
故一般模板的定义和实例化应该放在同一个文件里面

7、模板优缺点

• 优点：
  代码复用，节省资源、增强代码灵活性
• 缺点：
  1、模板编译错误时，错误信息凌乱，不易定位。
  2、模板导致代码膨胀，编译时间长（使用模板时， 同一模板生成不同的模板实类后会是多份代码，称为代码膨胀）

注：
类内声明，类外定义（需要加上template ）

//类外定义
template<class T>
void vector<T>::push_back(const T& x)
{
	cout << "push_back" << endl;
}