1.非类型模板参数

模板参数分为类型形参 与 非类型形参

类型形参 ：出现在模板参数列表中，跟在class或者typedename之类的参数类型名称。

template<class T>
class Array {
private:
	T* _a;
	size_t _size;
public:
	Array(size_t size = 10)
		:_size(size)
	{
		_a = new T[size];
	}
	T& operator[](size_t index)
	{
		return _a[index];
	}
	const T& operator[](size_t index) const
	{
		return _a[index];
	}
	size_t size() const
	{
		return _size;
	}
};

非类型形参 ：用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。

template<class T, size_t N = 10>
class Array {
private:
	T _a[N];
	size_t _size;
public:
	Array(){}

	T& operator[](size_t index)
	{
		return _a[index];
	}
	const T& operator[](size_t index) const
	{
		return _a[index];
	}
	size_t size() const
	{
		return _size;
	}
};

非类型模板参数的优势：

有些容器需要在创建对象时固定好容器的大小 (如位图，在创建时需固定好有多少个位)或是传输一个值，来作为容器的标识 (如：有向图和无向图需传输一个表示符表示)

• 非类型模板参数虽然在某些场景下可以被替代，但它与使用其他方法相比效率是最优的。

注意：

1. 浮点数、类对象以及字符串是不允许作为非类型模板参数的。
2. 非类型的模板参数必须在编译期间九能确认结果。
3. 非类型模板参数为常量在类模板或是函数模板中不能修改。

array

template<class T,size_t N> class array;

#include<array>

int main()
{
    int a1[10];
    //传统数组判断越界问题是按照抽查的方式，只判断一小部分的范围，超出该范围，读写数组都不会报错。
    a1[15];
    a1[15] = 10;
    
    //array判断数组是否越界非常严格，只要越界便会报错
    array<int,10> a2;
    a2[15];
    a2[30] = 10;
    
    return 0;
}

2.模板的特化

2.1概念

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，需要特殊处理，比如：实现了一个专门用来进行小于比较的函数模板

template<class T>
bool Greater(T a, T b)
{
	return a > b;
}

int main()
{
	vector<int> a1(2, 1);
	vector<int> a2(2, 8);
	cout << Greater(a2, a1) << endl;

	vector<int>* pa1 = &a1;
	vector<int>* pa2 = &a2;
	cout << Greater(pa1, pa2) << endl;

	return 0;
}

可以看到，Greater在传输正常对象是可以正常比较，但在传递指针变量后得到了错误的结果。上述示例中pa1指向的a1对象明显小于pa2指向的a2对象，但在Greater内部并没有比较pa1和pa2指向的对象内容，而是比较pa1和pa2指针的地址，这就无法达到预期。

此时，需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式 。模板特殊化分为函数模板特化 与 类模板特化 。

2.2函数模板特化

特化：对某些类型进行特殊化处理

函数模板特化步骤如下：

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

//函数模板
template<class T>
bool Greater(T a, T b)
{
	return a > b;
}

//函数特化
template<>
bool Greater<vector<int>*>(vector<int>* a, vector<int>* b)
{
	return *a > *b;
}

int main()
{
	vector<int> a1(2, 1);
	vector<int> a2(2, 8);
	cout << Greater(a1, a2) << endl;

	vector<int>* pa1 = &a1;
	vector<int>* pa2 = &a2;
	cout << Greater(pa1, pa2) << endl;

	return 0;
}

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

bool Greater(vector<int>* a, vector<int>* b)
{
	return *a > *b;
}

这种实现简单明了，代码可读性高，容易书写，因为对于一些参数类型复杂的函数模板，特化时特别给出，因此函数模板不建议特化。

2.3类模板特化

不仅函数模板可以特化，类模板也可以，而且我们应用更多的是类模板的特化，类模板特化主要分为全特化 和 偏特化 。

1.全特化

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

对于下面的模板我们将之进行全特化：

template<class T1,class T2>
class Person {
private:
	T1 age;
	T2 name;
public:
	Person()
	{
		cout << "template<class T1,class T2> class Person " << endl;
	}
};

类模板的特化步骤：

1. 首先必须要有一个基础的类模板。
2. 关键字template后面接一对空的尖括号<>。
3. 类名后跟一对尖括号，尖括号中指定需要特化的类型，这里定义多少类模板参数，就需要全特化多少个。

template<>
class Person<int, char*> {
private:
	int age;
	char* name;
public:
	Person()
	{
		cout << "template<> class Person < int, char*> " << endl;
	}
};

int main()
{
	Person<int, int> p1;
	Person<int, char*> p2;

	return 0;
}

2.偏特化

偏特化：如何针对模板参数进一步进行条件限制设计的特化版本。

比如对于以下模板类：

template<class T1,class T2>
class Person {
private:
	T1 a1;
	T2 a2;
public:
	Person() {
		cout << "class Person<T1,T2>" << endl;
	}
};

偏特化有以下两种表现方式：

• 部分特化：

  // 将第二个参数特化为int
  template<class T1>
  class Person<T1,int> {
  private:
  	T1 a1;
  	int a2;
  public:
  	Person() {
  		cout << "class Person<T1,int>" << endl;
  	}
  };
  

• 参数更进一步限制：

  偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

  //两个参数偏特化为指针类型
  template<class T1,class T2>
  class Person<T1*, T2*> {
  private:
  	T1* a1;
  	T2* a2;
  public:
  	Person() {
  		cout << "class Person<T1*, T2*>" << endl;
  	}
  };
  
  //两个参数偏特化为引用类型
  template<class T1, class T2>
  class Person<T1&, T2&> {
  private:
  	const T1& _a1;
  	const T2& _a2;
  public:
  	Person(const T1& a1,const T2& a2) 
  		:_a1(a1)
  		,_a2(a2)
  	{
  		cout << "class Person<T1&, T2&>" << endl;
  	}
  };
  
  int main()
  {
  	Person<int, char> p1;
  	Person<char, int> p2;
  	Person<int*, char*> p3;
  	Person<int&, int&> p4(1, 2);
  
  	return 0;
  }
  

  
  像上面的例子，利用模板的偏特化，我们可以解决特殊情况（如指针类型）下无法使用模板的尴尬，从而提高工作效率

注意： 若一个参数可以被两个模板（一个常规模板，一个全特化模板），那一定是运行全特化的哪一个，这样可以更快运行出结果，若上面的Person<int*, char*> p3; 调用的是"class Person<T1*, T2*> 而不是class Person<T1,T2> ，编译器会选择更加匹配的模板。

3.类模板特化应用示例

在标准函数库中有如下按照小于比较的类模板Less：

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

template<class T>
struct Less
{
    bool operator()(const T& x, const T& y) const
    {
        return x < y;
    }
};

int main()
{
    vector<int> v1(2, 4);
    vector<int> v2(2, 8);
    cout << Less<vector<int>>()(v1, v2) << endl;

    vector<int>* pv1 = &v1;
    vector<int>* pv2 = &v2;
    cout << Less<vector<int>*>()(pv1, pv2) << endl;

    return 0;
}

通过运行上述代码，我们发现正常对象是可以正常运行的，而到了指针对象结果却不正确，因为指针比较的是两个指针的地址大小，而不是指向空间内的内容，我们可以将其变为全特化模板参数，如下：

template<class T>
struct Less<T*>
{
    bool operator()(T* x, T* y) const
    {
        return *x < *y;
    }
};

特化之后，在运行上述代码，就得到了正确的结果

3.模拟分离编译

3.1什么是分离编译

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

3.2模板的分离编译

1.问题：

有如下场景，模板的声明和定义分离，在头文件add.h 中进行声明，源文件add.cpp 中完成定义，源文件main.cpp 中调用该函数，我们会发现这样的程序会出错：

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

// add.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;
}

2.原因

这是因为C/C++程序要运行，一定要经历以下几个步骤：

预处理——编译——汇编——链接

而其中：

预处理： 头文件的展开、宏替换、去注释和条件编译等等。(经过了预处理，main文件内的头文件被展开，模板函数的定义显现)

编译： 对程序按照语言特性进行词法、语法、语义分析，错误检查无误后，并对不同的文件分别汇总各自的变量、函数地址，生成汇编代码。(注意：头文件不参与编译，编译器对工程中的多个源文件是分离开单独编译的)

汇编： 把编译阶段生成的文件转成目标文件。

链接： 将多个obj文件合并成一个，并进行符号表的合并与重定位。(将不同的文件中的相同地址和并，即一个函数的声明、实现、调用合并，函数才能正常运行)

而对于上述代码，进行编译是没有问题的，代码并没有错误，但是在生成函数的地址时会出现问题，因为函数模板以及类模模板是没有地址的，需要在生成对象或调用函数的时候根据给出的类型的大小，来分配所需的空间，此时才会有地址产生，意味着在编译阶段不会生成函数模板的地址。

而到了链接阶段，因为函数模板的地址没有生成，表示此时只有调用函数时的地址存在，没有函数的地址，自然就会报错。

3.解决方法

1. 将声明和定义放到一个文件xxx.hpp，或者xxx.h 中即可

   xxx.hpp 和xxx.h 没有区别，xxx.hpp 是将xxx.h 文件名修改后的，其实就是将声明和定义放在一个头文件中，只是有些地方上喜欢把存放声明和定义分离的头文件改为.hpp 格式。

   深入理解： 当放在一个头文件中时，调用该头文件，在预处理阶段，头文件展开，函数的声明和定义都可以找到，所以不用担心没有函数地址的情况。

2. 模板定义的位置显示实例化

   //当需要传递int类型参数时，显示实例化格式如下，其它类型的参数也是相同的
   // add.cpp
   template
   T Add<int>(const int& left, const int& right)
   {
   	return left + right;
   }
   

   • 不推荐使用显示实例化，这样丧失模板优势。

注意： 一般我们将较大的函数做分离处理，而对于较小的函数则是声明和定义放在一起，较小的函数为了提高运算速度编译器会将其变为内联函数，直接在调用的地方展开。

4.模板总结

优点：

1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生
2. 增强了代码的灵活性

缺点：

1. 模板会导致代码膨胀问题，也会导致编译时间变长。

2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误。

   一般出现模板错误，滑倒问题的第一行，第一行为源头问题，源头问题解决，其它的都会解决。