关于C++模板的初阶学习(函数模板和类模板)总结于我的另一篇博客：
https://blog.csdn.net/hansionz/article/details/83827329

类模板的特化及类型萃取

1.非类型模板参数
2.模板的特化

2.1 函数模板特化
2.2 类模板的特化

a. 全特化
b.偏特化

3.类型萃取

3.1 memcpy拷贝
3.2 赋值方式拷贝
3.3 类型萃取实现

3.模板不支持分离编译

3.1 什么是分离编译
3.2 模板为什么不支持分离编译

1.非类型模板参数

模板参数可以分为类型模板参数和非类型模板参数。

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

//T为类型形参，N为非类型形参
template<class T, size_t N = 10>
class Array
{
public:
	T& operator[](size_t index)
	{
		return _array[index];
	}

	size_t Size() const
	{
		return _size;
	}
private:
	T _array[N];
	size_t _size;
};

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

2.模板的特化

使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果。例如：当我们比较字符串是否相等时，我们想要比较的是字符串的值是否相同，但是编译器其实会比较的是地址，所以此时我们应该对char*类型进行特化。

template<class T>
bool IsEqual(T& x1, T& x2)
{
	return x1 == x2;
}
void Test()
{
	char* s1 = "hello";
	char* s2 = "world";

	if (IsEqual(s1, s2))
		cout << "Equal" << endl;
	else
		cout << "No Equal" << endl;
}

2.1 函数模板特化

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

//对上边的模板函数进行特化
template<>
bool IsEqual<char*>(char*& x1, char*& x2)
{
	if (strcmp(x1, x2) == 0)
		return true;
	return false;
}

注：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出而不是进行特化，模板匹配时自动会匹配类型严格的函数。

2.2 类模板的特化

a. 全特化

全特化是指将类模板参数列表中的全部参数都特化。

template<typename T1, typename T2>
class A
{
public:
	A()
	{
		cout << "(T1,T2)"<< endl;
	}
private:
	T1 _x1;
	T2 _x2;
};
//全特化
template<>//此处加template<>是为了说明正在定义一个特例化版本
class A<int, char>
{
public:
	A()
	{
		cout << "(int ,char)"<< endl;
	}
private:
	int _x1;
	char _x2;
};

b.偏特化

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

部分特化，将模板参数类表中的一部分参数特化

//部分特化
template<class T1>
class A<T1, int>
{
public:
	A()
	{
		cout << "(T1,int)" << endl;
	}
private:
	T1 _x1;
	int _x2;
};

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

//参数更近一步限制
//1.两个参数偏特化为指针类型
template<class T1, class T2>
class A<T1*, T2*>
{
public:
	A()
	{
		cout << "(T1*, T2*)" << endl;
	}
private:
	T1 _x1;
	T2 _x2;
};
//2.两个参数偏特化为引用类型
template<class T1,class T2>
class A<T1&, T2&>
{
public:
	A()
	{
		cout << "(T1&, T2&)" << endl;
	}
private:
	 T1 _x1;
	 T2 _x2;
};
void Test1()
{
	A<int, double> a4;//(T1,T2)
	A<int, char> a3;//(int ,char)
	A<int*, int*> a2;//(T1*, T2*)
	A<double, int> a1;//(T1,int)
	A<int&, int&> a;//(T1&, T2&)
}

3.类型萃取

实现一个通用的拷贝函数？

3.1 memcpy拷贝

template<class T>
void Copy(T* dst, T* src, size_t size)
{
	memcpy(dst, src, sizeof(T)*size);
}

上边使用memcpy实现的拷贝函数，可以对所有的内置类型进行拷贝，是一种浅拷贝。但是如果对一些自定义类型，存在资源管理进行拷贝，就会出现问题，因为这是一种深拷贝。

3.2 赋值方式拷贝

template<class T>
void Copy(T* dst, T* src, size_t size)
{
	for (int i = 0; i < size; i++)
	{
		dst[i] = src[i];
	}
}
void Test()
{
		string arr1[3] = { "hehe", "good", "math" };
		string arr2[3];
		Copy(arr2, arr1, 3);
		cout << arr2 << endl;
}

上述的代码对于拷贝存在资源管理的对象可以很容易解决，但是该代码效率不是很高。我们可以想办法遇到内置类型使用memcpy拷贝，遇到自定义类型使用赋值方式拷贝，我们可以增加一个标识参数类型的参数：

template<class T>
//Pod( plain old data )--基本类型
vois Copy(T* dst, T* src, size_t size, bool IsPodType)
{
	if (IsPodType)
	{
		memcpy(dst, src, sizeof(T)*size);
	}
	else
	{
		for (int i = 0; i < size; i++)
		{
			dst[i] = src[i];
		}
	}
}

上边的代码又存在一个问题用户需要根据所拷贝元素的类型去传递第四个参数，那出错的可能性就增加。那我们能否让函数自动去识别所拷贝类型是内置类型还是自定义类型：

使用函数区分内置类型还是自定义类型： 因为内置类型的个数是确定的，可以将所有内置类型集合在一起，如果能够将所拷贝对象的类型确定下来，在内置类型集合中查找其是否存在即可确定所拷贝类型是否为内置类型

template<class T>
vois Copy(T* dst, T* src, size_t size)
{
	//typeid函数可以进行运行时类型识别，返回类型是type_info的标准库类型的引
	//用，该类中的成员函数name可以返回C类字符串类型的类型名
	if (IsPodType(typeid(T).name())
	{
		memcpy(dst, src, sizeof(T)*size);
	}
	else
	{
		for (int i = 0; i < size; i++)
		{
			dst[i] = src[i];
		}
	}
}
bool IsPodType(const char* strType)
{
	//列举出来所有的内置类型
	const char* arrType[] = { "char", "int", "double", \
		"short", "float", "long", "long long", "long double" };
	for (int i = 0; i < sizeof(arrType) / sizeof(arrType[0]); i++)
	{
		if (0 == strcmp(arrType[i], strType))
			return true;
	}
	return false;
}

注：关于typeid：http://www.cppblog.com/smagle/archive/2010/05/14/115286.aspx

3.3 类型萃取实现

定义两个类，为了区分内置类型和自定义类型：

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

定义一个模板类，里边包含对自定义类型的重命名，并将所有的内置类型都特化。

//定义一个模板类，里边包含对自定义类型和内置类型的重命名
template<class T>
class TypeTraits
{
public:
	typedef FalseType IsPodType;
};
//使用所有内置类型对该模板特化
template<>
class TypeTraits<int>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<short>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<char>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<float>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<double>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<long>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<long long>
{
public:
	typedef TrueType IsPodType;
};

template<>
class TypeTraits<long double>
{
public:
	typedef TrueType IsPodType;
};

通过对TypeTraits类模板重写改写Copy函数模板，来确认所拷贝对象的实际类型：

template<class T>
void Copy(T* dst, T* src, size_t size)
{
	if (TypeTraits<T>::IsPodType::Get())
		memcpy(dst, src, sizeof(T)*size);
	else
	{
		for (int i = 0; i < size; i++)
		{
			dst[i] = src[i];
		}
	}
}

如果T为int，TypeTraits<int>已经特化过，程序运行时就会使用已经特化过的TypeTraits<int>，该类中的IsPodType刚好为类TrueType，而TrueType中Get函数返回true，内置类型使用memcpy方式拷贝。所有的内置类型都是这样。
如果T为string，TypeTraits<string>没有特化过，程序运行时使用TypeTraits类模板, 该类模板中的IsPodType 刚好为类FalseType，而FalseType中Get函数返回false，自定义类型使用赋值方式拷贝。所有的自定义类型都是这样。

STL中一些类型萃取方法：

//让_Copy函数因最后一个参数(内置类型和自定义类型)形成函数重载
//在写一个通用的Copy函数，根据不同的参数调用重载的两个_Copy函数
template<class T>
//第4个参数乐意不提供名字，只要构成重载即可
void _Copy(T* dst, T* src, size_t size, TrueType t)
{
	memcpy(dst, src, sizeof(T)*size);
}

template<class T>
void _Copy(T* dst, T* src, size_t size, FalseType f)
{
	for (int i = 0; i < size; i++)
	{
		dst[i] = src[i];
	}
}
template<class T>

void Copy(T* dst, T* src, size_t size)
{
	_Copy(dst, src, size, TypeTraits<T>::IsPodType);
}

注：在特化TypeTraits模板类的时候，必须将所有的类型有符号、无符号全部特化(int、unsigned int signed int)

3.模板不支持分离编译

3.1 什么是分离编译

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

//sum.h
int Sum(int x,int y);

//sum.c
#include "sum.h"
int Sum(int x,int y)
{
	return x+y;
}

//main.c
#include <stdio.h>
#include "sum.h"

int main()
{
	Sum(1,2);
	return 0;
}

3.2 模板为什么不支持分离编译

假设我们将模板的声明和实现分离，在头文件声明，在源文件定义：

//Add.h
template<class T>
int Add(int x,int y);

//Add.cpp
template<class T>
int Add(int x,int y)
{
	return x+y;
}

//Main.cpp
#include "Add.h"
int main()
{
	Add(1,2);
}

要了解模板为什么不支持分离编译，我们先要了解编译原理。
关于编译原理：https://blog.csdn.net/hansionz/article/details/80067803

程序的编译过程：预处理–编译–汇编–链接

预处理：头文件包含、条件编译、宏替换、注释删除等
编译：词法分析、语法分析、符号汇总等
汇编：将源代码转为汇编代码
链接：符号表的生成和重定位、合并段表

在这里插入图片描述

解决方法：

将声明和定义放到一个文件 xxx.hpp 里面或者xxx.h
模板定义的位置显式实例化，不常用，因为这样做就降低了模板的好处
使用过程中不要将声明和定义分离

关于分离编译参考： http://blog.csdn.net/pongba/article/details/19130

【C++】类模板的特化及类型萃取