模板的进阶

一、非类型模板参数

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

//非类型模板参数---整型常量(只能)
template<class T = int，size_t N=8>
class Array
{
public:
	void f()
	{
		N = 1000;
	}
private:
	T _a[N];
};

int main()
{
	Array<int,100> aa1; // 100
	Array<int,1000> aa2;  //1000
	Array<int> aa3;  //没给就默认
	Array<> aa4;
	aa1.f();
	return 0;
}

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
2. 非类型的模板参数必须在编译期就能确认结果。

二、模板特化

1.模板特化

编译默认函数模板或者类模板不能正确处理需要逻辑，需要针对一些情况进行特殊化处理，就叫做模板的特化

template<class T>
bool IsEqual(const T& left,const T& right)
{
	return left == right;
}
int main() 
{
	cout << IsEqual(1, 2) << endl;
	cout << IsEqual(1.1, 1.1) << endl;

	//实际上都不对，字符串比较要用ASCII码
	char p1[] = "hello";//数组，地址不一样
	char p2[] = "hello";
	cout << IsEqual(p1, p2) << endl;   //若不用特化，输出为1

	char* p3 = "hello";//存在常量区同一空间，同一地址
	char* p4 = "hello";
	cout << IsEqual(p3, p4) << endl;  // 若不用特化，输出为0
	return 0;
}

编译去实例化我们所要的函数或者类

2.函数模板的特化

函数模板的特化步骤：
（1）必须要先有一个基础的函数模板
（2）关键字template后面接一对空的尖括号<>
（3）函数名后跟一对尖括号，尖括号中指定需要特化的类型
（4）函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

template<class T>
bool IsEqual(const T& left,const T& right)
{
	return left == right;
}


//针对字符串类型要特殊化处理
//写一份函数模板的特殊出来
template<>
bool IsEqual<const char*>(const char* const& left, const char* const& right)
{
	return strcmp(left,right) == 0;
}

//这也可以
bool IsEqual(const char* const& left, const char* const& right)
{
	return strcmp(left, right) == 0;
}
int main() 
{
	cout << IsEqual(1, 2) << endl;
	cout << IsEqual(1.1, 1.1) << endl;

	//实际上都不对，字符串比较要用ASCII码
	char p1[] = "hello";//数组，地址不一样
	char p2[] = "hello";
	cout << IsEqual(p1, p2) << endl;   //若不用特化，输出为1

	char* p3 = "hello";//存在常量区同一空间，同一地址
	char* p4 = "hello";
	cout << IsEqual(p3, p4) << endl;  // 若不用特化，输出为0
	return 0;
}

3.类模板的特化

特化本质：显示指定实例化的模板

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

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

3.1全特化

全特化即是将模板参数列表中所有的参数都确定化。

//假设针对T1  T2是int int想做一些特殊化怎末办？
//——类模板特化
template<>
class Data<int,int>
{
public:
	Data()
	{
		cout << "Data<int,int>" << endl;
	}
};
int main()
{
	Data<int, int> d1;
	Data<int, double> d2;
	return 0;
}

3.2 偏特化

偏特化（类似部分缺省参数）：任何针对模版参数进一步进行条件限制设计的特化版本。
函数模板也有全特化，偏特化

//将第二个参数特化为int ——偏特化
template<class T1>
class Data<T1, int>
{
public:
	Data()
	{
		cout << "Data<T1,int>" << endl;
	}
private:
	T1 _d1;
	int _d2;
};

//偏特化，如果模板参数是指针，就使用这个
template<class T1,class T2>
class Data<T1*, T2*>
{
public:
	Data()
	{
		cout << "Data<T1*,T2*>" << endl;
	}
};


template<class T1, class T2>
class Data<T1&, T2&>
{
public:
	Data()
	{
		cout << "Data<T1&,T2&>" << endl;
	}
};

template<class T1, class T2>
class Data<T1*, T2&>
{
public:
	Data()
	{
		cout << "Data<T1*,T2&>" << endl;
	}
};


int main()
{
	Data<int, int> d1;  //调用两个参数特化为int的模板
	Data<int, double> d2;  //调用原始模板
	Data<double, int> d3;  //调用第二个参数特化为int的模板
	Data<int*, int*> d4;//调用指针的模板
	Data<double*, int*> d5;  //调用指针的模板
	Data<int&, int&> d6;//调用引用的模板
	Data<int*, int&> d7;  //调用指针和应用混用的模板

	return 0;
}

三、模板分离编译

1.分离编译

一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链
接起来形成单一的可执行文件的过程称为分离编译模式。

2.模板的分离编译

// a.h
template<class T>
T Add(const T& left, const T& right);

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

// main.cpp
#include"a.h"
int main()
{
	Add(1, 2);
	Add(1.0, 2.0);
	return 0;
}

模板不支持分离编译，普通函数支持
原因： 编译只有声明，没有定义，只能确定函数的名称，检查参数匹配等，但是没有函数的地址，地址链接时再去找
函数模板没有实例化，即：定义的地方没有实例化，实例化的地方没有定义，只有声明

解决方法：
方法一：显示实例化，模板定义函数时指定类型，比较麻烦
方法二：模板不分离编译

四、总结：

模板优点：
（1）复用了代码，很多交给了编译器
（2）模板让代码很灵活
模板缺点：
（1）看起来节省了代码，但编译后存在代码膨胀的问题
（2）模板出现语法错误后，有时报错混乱且不准确，有时容易定位错误
（3）模板不支持分离编译