模板进阶

1.非类型模板参数
模板参数分类类型形参和非类型形参
类型形参即：出现在模板参数列表中，跟在class或者typename之类的参数类型名称
非类型形参：就是用一个常量作为类（函数）模板的一个参数，在类（函数）模板中可将该参数当成常量来使用
注意：
1.浮点数、类对象以及字符串是不允许作为非类型模板参数的
2.非类型的模板必须在编译期就能确认结果
2.模板的特化
通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果

template<class T>
bool IsEqual(T& left, T& right)
{
	return left == right;
}
void Test()
{
	char* p1 = "hello";
	char* p2 = "world";
	if (IsEqual(p1, p2))
		cout << p1 << endl;
	else
		cout << p2 << endl;
}

这种的就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化分为函数模板特化与类模板特化
函数模板特化
函数模板特化步骤：
1.必须要先有一个基础的函数模板
2.关键字template后边接一对空的尖括号<>
3.函数名后跟一对尖括号，尖括号中指定需要特化的类型
4.函数形参表：必须要和模板函数的基础参数类型完全相同
类模板特化
全特化
全特化是将模板参数类表中所有的参数都确定化

template<class T1,class T2>

	class Data
	{
	public:
		Data()
		{
			cout << "Data<T1,T2>" << endl;
		}
	private:
		T1 _d1;
		T2 _d2;
	};
	template<>
	class Data<int, char>
	{
	public:
		Data()
		{
			cout << "Data<int, char>" << endl;
		}
	private:
		T1 _d1;
		T2 _d2;
	};
	void TestVector()
	{
		Data<int, int> d1;
		Data<int, char> d2;
	}

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

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

偏特化有 两种表现方式 ：
部分特化：
将模板参数类表中的一部分参数特化

//将第二个参数特化为int
	template<class T1>
	class Data<T1, int>
	{
	public:

		Data()
		{
			cout << "Data<T1,int>" << endl;
		}
	private:
		T1 _d1;
		int _d2;
	};

参数进一步限制
偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所涉及出来的一个特化版本
类模板特化应用之类型萃取
使用memcpy:虽然对于任意类型的空间都可以进行拷贝，但是如果拷贝自定义类型对象就可能会出错，因为自定义类型涉及到深拷贝，而memcpy属于浅拷贝，如果对象中涉及到资源管理，就只能用赋值
使用赋值方式拷贝:用循环赋值的方式虽然可以，但是效率较低，而c/c++程序最大的优势就是效率高。
如果遇到内置类型就用memcpy来拷贝，遇到自定义类型就用循环赋值方式这样就可以在一定程度上增大效率
如何区分内置类型和自定义类型？
1.增加bool类型区分自定义与内置类型

template<class T>
void Copy(T* dst, const T* src, size_t size, bool IsPODType)
{
	if (IsPODType)
		memcpy(dst, src, sizeof(T)*size);
	else
	{
		for (size_t i = 0; i < size; ++i)
			dst[i] = src[i];
	}
}

增加了一个参数，可以将两种拷贝的优势体现结合起来，缺陷是：用户需要根据拷贝元素的类型去传递第3个参数，那么出错的可能性就会增加
2.使用函数区分内置类型和自定义类型
因为内置类型的个数是确定的，可以将所有内置类型集合在一起，如果能够将所拷贝对象的类型确定下来，在内置类型集合中查找是否存在即可确定所拷贝类型是否为内置类型。

bool IsPODType(const char* strType)//是否是内置类型
{
	const char* arrType[] = { "char", "short", "int", "long", "long long", "float", "double", "long double" };
	for (size_t i = 0; i < sizeof(arrType) / sizeof(arrType[0]); ++i)
	{
		if (0 == strcmp(strType, arrType[i]))
			return true;
	}
	return false;
}
template<class T>
void Copy(T* dst, const T*src, size_t size)
{
	if (IsPODType(typeid(T).name()))
		memcpy(dst, src, sizeof(T)*size);
	else
	{
		for (size_t i = 0; i < size; ++i)
			dst[i] = src[i];
	}
}

通过typeid来确认所拷贝对象的实际类型，然后再在内置类型集合中枚举其是否出现过，即可确认所拷贝元素的类型为内置类型或者自定义类型。但缺陷是：枚举需要将所有类型遍历一遍，每次比较都是字符串的比较，效率较低
类型萃取
为了将内置类型 与自定义类型区分开，给出以下两个类分别代表内置类型与自定义类型

struct TrueType
{
	static bool Get()
	{
		return true;
	}
};
//代表自定义类型
struct FalseType
{
	static bool Get()
	{
		return false;
	}
};
template <class T>
struct TypeTraits
{
	typedef FalseType IsPODType;
};
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;
};
template<>
struct TypeTraits<double>
{
	typedef TrueType IsPODType;
};

template<>
struct TypeTraits<long long>
{
	typedef TrueType IsPODType;
}; template<>
struct TypeTraits<long double>
{
	typedef TrueType IsPODType;
};
template<class T>
void Copy(T* dst, const T* src, size_t size)
{
	if (TypeTraits<T>::IsPODType::Get())
		memcpy(dst, src, sizeof(T)*size);
	else
	{
		for (size_t i = 0; i < size; ++i)
			dst[i] = src[i];
	}
}
int main()
{
	int a1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	int a2[10];
	Copy(a2, a1, 10);
	string s1[] = { "1111", "2222", "3333", " 4444" };
	string s2[4];
	system("pause");
	return 0;

}

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

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

c/c++程序要运行，一般要经历以下步骤：
预处理-》编译-》汇编-》链接
编译：对程序按照语言特性进行词法、语法、语义分析，错误检查无误后生成汇编代码，头文件不参与编译，编译器对工程中的多个源文件是分离单独编译的。
链接：将多个obj文件合并成一个，并处理没有解决的地址问题
解决方法：
1.将声明和定义放到一个文件中
2.模板定义的位置显示实例化
使用模板的优点：
1.模板复用了代码，节省资源， 更快的迭代开发，c++的标准模板库（STL）因此而产生
2.增i强了代码的灵活性
使用模板的缺点：
1.模板会导致代码膨胀的问题，也会导致编译时间长
2.出现模板编译错误时，错误信息凌乱，不易定位错误