在模板学习（一）中，简单的介绍了一下模板的运用，下面，将进一步的介绍模板运用过程中的几种形式以及可能出现的问题：

非类型模板参数

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

#include<iostream>
using namespace std;
#include<assert.h>
//定义一个模板类型的静态数组
template<class T, size_t N = 10>  //非类型模板参数N
class array
{
public:
    //插入元素，尾插
	void push_back(const T& data)
	{
		arr[size++] = data;
	}
	//下标运算符重载
	T& operator[](size_t index)
	{
	    //断言下标位置的合法性
		assert(index < size);
		return arr[index];
	}
	//判空
	bool empty()const
	{
		return size == 0;
	}
	//求大小
	size_t size()const
	{
		return size;
	}
private:
	T arr[N];  //T类型的静态数组
	size_t size;
};

int main()
{
	array<int> arr;
	arr.push_back(1);

	return 0;
}

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

模板的特化

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到错误的结果。例如，char* 类型(string)类就可能导致浅拷贝问题，导致内存被重复释放，以及内存泄漏等的问题
为了避免这些情况的发生，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化分为函数模板特化和类模板特化

函数模板特化

步骤：
1、必须有一个基础的函数模板
2、template后的<>内没有参数，为空
3、函数名后跟<>，尖括号中指定需要特化的类型
4、函数参数表：必须要和模板函数的基础参数类型完全相同，如果不同，编译器可能会报一些奇怪的错误

template<class T>
T& Max(const T& a, const T& b)
{、、、}

template<char *>
char *Max(char*& a, char*& b)
{、、、}

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

类模板特化

全特化

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

template<class T1, class T2>
class Date
{、、、};

template<>
class Date<int, char>
{、、、};

偏特化

偏特化是任何针对模板参数进一步进行条件限制设计的特化版本
偏特化有两种表现方式：
1、部分特化：将模板参数类表中的一部分参数特化

template<class T1, class T2>
class Date
{、、、};
//部分特化
template<T1, int>
class Date
{、、、};

2、参数更进一步的限制：针对模板参数更进一步的条件限制设计的特化版本

template<class T1, class T2>
class Date
{、、、};
//两个参数偏特化为指针类型
template<typename T1, typename T2>
class Date<T1*, T2*>
{、、、};
//两个参数偏特化为引用类型
template<typename T1, typename T2>
class Date<T1&, T2&>
{、、、};

类模板特化应用值类型萃取

问题：如何实现一个通用的拷贝函数？

思路一：使用memcpy拷贝

template<class T>
void copy(T* des, const T* src, size_t size)
{
    memcpy(des, src, sizeof(T)*size);
}

分析：memcpy对任意类型的空间中内容都可以进行拷贝，且对于内置类型的拷贝效率很高，但是，这样就不可避免的涉及到深浅拷贝的问题（当拷贝一个指向已开辟空间的指针时，拷贝指针空间中的内容----该片空间的起始地址，使得多个指针指向同一片空间释放时多次释放，且可能存在内存泄漏等的问题），所以memcpy属于浅拷贝，如果对象中涉及到资源管理，显然memcpy行不通

思路二：使用赋值方式拷贝

template<class T>
void copy(T* des, const T* src, size_t size)
{
    for(size_t i = 0; i < size; ++1)
    {
        des[i] = src[i];
    }
}

分析：循环赋值的方式可以实现拷贝，但若是内置类型也用这种方式进行拷贝，效率未免太低，所以单纯的循环赋值也不推荐

对两种思路比较：
1、memcpy对内置类型效率高，但会引起浅拷贝
2、循环赋值可以对所有类型的拷贝都适用，但相比memcpy对内置类型的效率未免有点低。

那么，能不能有一种方式将内置类型和自定义类型区分开来，内置类型用memcpy，自定义类型用循环赋值，这样效率会大大提升。下面，就引出了类型萃取

类型萃取

< 区分内置类型和自定义类型

//内置类型
struct TrueType
{
    struct bool Get()
    {
        return true;
    }
};
//自定义类型
struct FalseType
{
    struct bool Get()
    {
        return false;
    }
};

< 给出模板

template<class T>
struct TypeTraits
{
    Typedef FalseType ISPODType;
};

< 对TypeTraits类模板的实例化

template<>
struct TypeTraits<char>
{
    Typedef TrueType ISPODType;
};

template<>
struct TypeTraits<short>
{
    Typedef TrueType ISPODType;
};

template<>
struct TypeTraits<int>
{
    Typedef TrueType ISPODType;
};

template<>
struct TypeTraits<long>
{
    Typedef TrueType ISPODType;
};
、、、

< 通过对TypeTraits类的实例化，调用get()方法便可确认T的类型

template<class T>
void copy(T* des, const T* src, size_t size)
{
    if(TypeTraits<T>::ISPODType::Get())
    {
        memcpy(des, src, sizeof(T)*size);
    }
    else
    {
        for(size_t i = 0; i < size; ++i)
        {
            des[i] = src[i];
        }
    }
}

模板分离编译

分离编译：

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

模板的分离编译：

若在一个程序（项目）中，模板的声明与定义分离开，在头文件中进行声明，源文件中完成定义，在链接时就会报错

分析：

C/C++程序要运行，一般经过：预处理---->编译---->汇编---->链接
    编译：对程序按照语言特性进行词法，语法，语义分析，错误检查无误后生成汇编代码，期间头文件不参与编译，编译器对工程中的多个源文件是分离开单独编译的
    链接：将多个.obj文件合并成一个，并处理没有解决的地址问题
在源文件的定义中，编译器并没有看到对模板函数的实例化，因此不会生成具体的函数
在编译后的obj文件中调用函数，编译器在链接时才会找函数的地址，但是函数没有实例化没有生成具体的代码，因此链接时报错

解决办法：
1、将声明和定义放到一个文件中，以避免这种报错，这种方法值得推荐
2、模板定义的位置显式实例化，这就意味着每一次使用函数模板就需要对它在声明的文件中进行实例化，或者在报错之后根据错误进行排查，很显然，这种方法并不实用

总结

模板优点：
1、模板复用代码，节省资源，更快的迭代开发，C++的标准模板库因此产生
2、增强了代码的灵活性
模板缺陷：
1、模板会导致代码膨胀问题，也会导致编译时间变长
2、出现模板编译错误时，错误信息非常凌乱，不容易定位错误

THE END