前言
一、非类型模板参数
- 使用方法
- 使用场景
二、模板特化
- （一）函数模板特化
- （二）类模板特化
- - 1.全特化
  - 2.偏特化
- 使用场景
三、模板分离编译
- - 1. 什么是分离编译
  - 2.模板的分离编译
  - 3.解决方法
四、模板总结

前言

打怪升级：第42天

一、非类型模板参数



#define CNT1 10
#define CNT2 60

const int cnt1 = 10;
const int cnt2 = 60;

void Test_const1()
{
	int arr[CNT1];
	float arr[CNT1];
	double arr[CNT1];
	int arr[CNT2];

	int arr[cnt1];
	int arr[cnt2];
}

使用方法

模板参数分为：类型模板和非类型模板；
类型模板：类（函数）模板参数列表中跟在 class、typename之后的参数，eg:template<calss T>
非类型模板：类（函数）模板参数列表中的整形类型的常量，egtemplate<size_t n = 10>

#include<iostream>
using namespace std;
#include<vector>
#include<array>

//template<class T = int, size_t n = 10>
template<class T = vector<int>, char n = 10>
class AA
{
public:
	T at(size_t i)
	{
		return _arr[i];
	}

private:
	T _arr[n];
};

void Test_AA1()
{
	AA<int> a1;

	AA<int, 5>a2;

	cout << a2.at(5) << endl;
}

注意一点：非类型模板参数作为常量使用，但是在模板参数列表中进行声明时并没有加 const ，
咱们祖师爷当时就是这么设定的，我们使用的时候就牢牢记住：的屁股-> 龟定。

使用场景

虽然这个array模板第一次看起来感觉：欧呦，不错呦~，
但是，如果了解stl的朋友应该会想到另外一个容器：vector，既然我们已经有vector并且已经流行了30多年了，为什么还要再去使用那个array，而且vector还支持自动扩容等等，比array要方便太多，
因此，这个array容器属实是有些鸡肘了的。

不过非类型模板参数并非只有这一个使用场景，以后遇到我们再了解即可。

二、模板特化

通常情况下，使用模板可以实现很多与类型无关的代码，这确实提高了我们代码的复用性，但是在使用过程中我们会遇到一些特殊的数据类型，会带给我们意想不到的结果：

示例：

template<class T>
bool _less(const T& t1, const T& t2)
{
	return t1 < t2;
}

void Test_less()
{
	int a = 20;
	int b = 10;
	cout << _less(a, b) << endl;
	cout << _less(b, a) << endl;

	int* pa = &a;
	int* pb = &b;
	cout << _less(pa, pb) << endl;
	cout << _less(pb, pa) << endl;
}

运行实例：

此时就可以对模板进行特化：既在原模板类的基础上，针对特殊类型所进行的特殊化的实现方式。
模板特化分为：函数模板特化和类模板特化。

（一）函数模板特化

函数模板特化步骤：

必须要先有一个基础的函数模板；
template后面跟一对空的尖括号；
函数名后跟一对尖括号，尖括号内指定特化类型；
函数形参表：必须要和模板函数的基础参数类型完全相同。

补充：

对指针类型的特化：

当然，如果再有什么二级指针，我们就再特化一个二级指针的实例出来。

template<class T>
bool _less(T t1, T t2)
{
	return t1 < t2;
}

template<>
bool _less<int*>(int* t1, int* t2) // 1.1 特化一个 int*
{
	return *t1 < *t2;
}

bool _less(int* t1, int* t2)  //  1.2     直接写一个函数
{
	return *t1 < *t2;
}

template<typename T>
bool _less(T* t1, T* t2) //  2.1  写一个新的模板
{
	return *t1 < *t2;
}

void Test_less()
{
	int a = 20;
	int b = 10;
	cout << _less(a, b) << endl;
	cout << _less(b, a) << endl;

	int* pa = &a;
	int* pb = &b;
	cout << _less(pa, pb) << endl;
	cout << _less(pb, pa) << endl;
}

由此我们可以看出：特化在函数模板里的应用不仅使用不方便，而且效果也没有再写一个新的模板来的好，所以函数模板的特化很少使用。

（二）类模板特化

1.全特化

全特化：将模板参数列表里的所有模板全部确定化；

示例：


template<class T1, class T2>
class Print
{
public:
	void Output()
	{
		cout << "Print<T1, T2>" << endl;
	}
private:
	T1 _data1;
	T2 _data2;
};

template<>  
class Print<int, char>  //  T1,T2全部特化
{
public:
	void Output()
	{
		cout << "Print<int, char>" << endl;
	}
private:
	int _data1;
	char _data2;
};

void Test_Print1()
{
	Print<int, int>d1;
	d1.Output();

	Print<int, double>d2;
	d2.Output();

	Print<int, char>d3;
	d3.Output();
}

运行实例：

2.偏特化

偏特化分为两种形式：

部分特化

template<class T1, class T2>
class Print
{
public:
	void Output()
	{
		cout << "Print<T1, T2>" << endl;
	}
private:
	T1 _data1;
	T2 _data2;
};

template<>
class Print<int, char>  // 全特化
{
public:
	void Output()
	{
		cout << "Print<int, char>" << endl;
	}
private:
	int _data1;
	char _data2;
};

template<class T1>
class Print<T1, char> //  特化第二个参数
{
public:
	void Output()
	{
		cout << "Print<T1, char>" << endl;
	}
private:
	T1 _data1;
	char _data2;
};

void Test_Print1()
{
	Print<int, int>d1;
	d1.Output();

	Print<int, double>d2;
	d2.Output();

	Print<int, char>d3;
	d3.Output();

	Print<char, char>d4;
	d4.Output();
}

参数进一步限制
特化不仅指上面的：将模板替换为确定了类型，也可以增加对模板类型的限制：如指定为指针或者引用等。


template<class T1, class T2>
class Print
{
public:
	void Output()
	{
		cout << "Print<T1, T2>" << endl;
	}
private:
	T1 _data1;
	T2 _data2;
};

template<class T1, class T2>
class Print<T1*, T2*>     //  T1，T2都特化为指针类型 -- 指针类型时走本特化模板
{
public:
	void Output()
	{
		cout << "Print<T1*, T2*>" << endl;
	}
private:
	T1 _data1;
	T2 _data2;
};

template<class T1, class T2>
class Print<T1&, T2&>     //  T1，T2都特化为引用类型 -- 引用类型时走本特化模板
{
public:
	void Output()
	{
		cout << "Print<T1&, T2&>" << endl;
	}
private:
	T1 _data1;
	T2 _data2;
};

void Test_Print2()
{
	Print<int, int>p1;
	p1.Output();

	Print<int*, int*>p2;
	p2.Output();

	Print<char*, char*>p3;
	p3.Output();

	Print<int**, int**>p4;
	p4.Output();

	Print<int&, int&>p5;
	p5.Output();
}

使用场景

template<class T>
class Greater
{
public:
	bool operator()(const T& e1, const T& e2)
	{
		return e1 > e2;
	}

};

void Test_sort()
{
	int a1 = 10;
	int a2 = 16;
	int a3 = 5;
	int a4 = 12;

	vector<int>a;
	a.push_back(a1);
	a.push_back(a2);
	a.push_back(a3);
	a.push_back(a4);

	sort(a.begin(), a.end());
	for (auto x : a)
		cout << x << ' ';
	cout << endl << endl;

	sort(a.begin(), a.end(), Greater<int>());  // 排降序
	for (auto x : a)
		cout << x << ' ';
	cout << endl << endl;
}

void Test_sort()
{
	int a1 = 10;
	int a2 = 16;
	int a3 = 5;
	int a4 = 12;

	vector<int*>pa;
	pa.push_back(&a1);
	pa.push_back(&a2);
	pa.push_back(&a3);
	pa.push_back(&a4);

	sort(pa.begin(), pa.end());
	for (auto x : pa)
		cout << *x << ' ';
	cout << endl << endl;

	sort(pa.begin(), pa.end(), Greater<int*>());
	for (auto x : pa)
		cout << *x << ' ';
	cout << endl << endl;
	
}

template<class T>
class Greater
{
public:
	bool operator()(const T& e1, const T& e2)
	{
		return e1 > e2;
	}

};

template<class T>
class Greater<T*>
{
public:
	bool operator()(T* e1, T* e2)
	{
		return *e1 > *e2;
	}

};

void Test_sort()
{
	int a1 = 10;
	int a2 = 16;
	int a3 = 5;
	int a4 = 12;

	vector<int*>pa;
	pa.push_back(&a1);
	pa.push_back(&a2);
	pa.push_back(&a3);
	pa.push_back(&a4);

	sort(pa.begin(), pa.end());
	//  	sort(pa.begin(), pa.end(), Less<int*>());  // 改进 -- 在写一个小于仿函数
	for (auto x : pa)
		cout << *x << ' ';
	cout << endl << endl;

	sort(pa.begin(), pa.end(), Greater<int*>());
	for (auto x : pa)
		cout << *x << ' ';
	cout << endl << endl;
	
}

三、模板分离编译

1. 什么是分离编译

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

2.模板的分离编译

我们上面的实现都是在Test.cpp里面进行的，上面写到一起就可以，我们应该都知道：标准情况下我们本就推荐函数声明和实现分离的，但是为什么这里分开就不行了呢？

下面我们一起来一探究竟：
首先，我们来更加详细地理一理分离编译的过程：预处理、编译、汇编、链接。
预处理阶段做什么工作？
— 头文件展开、条件编译、宏替换、以及注释清除；

编译阶段：
— 语法检查、生成汇编指令；

汇编阶段：
— 生成二进制代码；

链接阶段：
— 将多个目标文件链接称为单一的可执行文件。

3.解决方法

在模板定义的位置显示实例化，（这种方法可以，但是使用麻烦，而且有时候会出问题，不推荐）。

**将模板和定义放到一个文件中，如"xxx.hpp", 或者 “xxx.h”。**推荐这种。

四、模板总结

优点

提高了代码的复用性，减少冗余，缩短了编程周期；
增强了代码的灵活性；
这里的模板和之后的继承都是提高复用的很牛B的方法。

缺点

模板会导致代码膨胀，导致编程时间变长（其实这不算缺点，因为如果不使用模板，我们就需要自己手写多份类似的代码，所以这些所谓的代码膨胀是必不可少的消耗）；
出现模板编译错误时，提示信息非常凌乱，不易定位错误。（一有问题就会报一大堆错误 – 不过一般解决了最前面的几个就好了，这一点刚开始练习模板的朋友们会深有体会的）