模板详解-优快云博客

模板参数分为类类型形参和非类型形参。

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

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

注意：

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

模板的特化

通常情况下，使用模板可以实现一些与类型无关的代码，但一些特殊类型的可能会得到一些错误的结果，此时，就需要对模板进行特化。即：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。模板特化中分为函数模板特化与类模板特化。

函数模板特化

函数模板的特化步骤：
1. 必须要先有一个基础的函数模板

2. 关键字template后面接一对空的尖括号<>

3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型

4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报错误。

//函数模板的特化
template<class T>
bool IsEqual(T& left,T& right)
{
	return left == right;
}
template<>
bool IsEqual<char*>(char*& left, char*& right)
{
	if (strcmp(left, right) == 0)
	{
		return true;
	}
	return false;
}
void Test() 
{
	char* p1 = "hello";
	char* p2 = "world";

	cout << IsEqual(p1, p2) << endl;
}
int main()
{
	Test();
 	return 0;
}

类模板特化

类模板特化分为全特化和偏特化

全特化：全特化即是将模板参数类表中所有的参数都确定化。例如：

//函数模板的全特化
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:
	int _d1;
	char _d2;
};
void Test()
{
	Data<char, 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;
};
template<class T1>
//将第二个参数特化为char
class Data<T1, char>
{
public:
	Data()
	{
		cout << "Data<T1,char>" << endl;
	}
private:
	T1 _d1;
	char _d2;
};

参数更进一步的限制

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

template<typename T1, typename T2>
//两个参数特化为指针类型
class Data<T1*, T2*>
{
public:
	Data() { cout << "Data<T1*,T2*>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};
//两个参数特化为引用类型
template<typename T1, typename T2>
class Data<T1&, T2&>
{
public:
	Data(const T1& d1, const T2& d2)
		:_d1(d1)
		, _d2(d2)
	{
		cout << "Data<T1&,T2&>" << endl;
	}
private:
	const T1& _d1;
	const T2& _d2;
};
void Test()
{
	Data<double, char> d1;//调用特化的char版本
	Data<int, int> d2;//调用基础的模板
	Data<int*, char*> d3;//调用特化的指针版本
	Data<int&, int&> d4(2,4);//嗲用特化的引用版本
}
int main()
{
	Test();
	return 0;
}

类模板特化应用中的类型萃取

实现一个通用的拷贝函数，请看下面的实现有没有问题？

template<class T>
void Copy(T* dst, const T* src, size_t size)
{
	memcpy(dst, src, sizeof(T)*size);
}
int main()
{
	string strarr1[3] = { "111", "222", "333" };
	string strarr2[3];
	Copy(strarr2, strarr1, 3);
	return 0;
}

当我们运行程序时会发现程序崩溃，此代码虽然对于任意类型的空间都可以进行拷贝，但是如果拷贝自定义类型对象就可能会出错，因为自定义类型对象有可能会涉及到深拷贝(比如string)，而memcpy属于浅拷贝。如果对象中涉及到资源管理，就只能用赋值的方式进行拷贝。

void Copy(T* dst, const T* src, size_t size)
{
	for (size_t i = 0; i < size; ++i)
	{
		dst[i] = src[i];
	}
}

用循环赋值的方式代码的效率比较低，而C/C++程序最大的优势就是效率高。所以我们就要想一个办法，遇到内置类型就用memcpy来拷贝，遇到自定义类型就用循环赋值方式。

增加bool类型区分自定义与内置类型

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

我们可以使用函数区分内置类型和自定义类型

bool IsPODType(const char* strType)
{
	const char* arrType[] = { "int", "char", "short", "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, bool IsPODType)
{
	if (IsPODType(typeid(T).name()))
	{
		memcpy(dst, src, sizeof(T)*size);
	}
	else
	{
		for (size_t i = 0; i < size; ++i)
			dst[i] = src[i];
	}
}
//代表内置类型
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<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];    
	Copy(s2, s1, 4);
	return 0; 
}

当T为int时，TypeTraits<int>已经特化过，程序运行时就会使用已经特化过的TypeTraits<int>, 该类中的 IsPODType刚好为类TrueType，而TrueType中Get函数返回true，内置类型使用memcpy方式拷贝。

当T为string：TypeTraits<string>没有特化过，程序运行时使用TypeTraits类模板, 该类模板中的IsPODType 刚好为类FalseType，而FalseType中Get函数返回true，自定义类型使用赋值方式拷贝。

分离编译

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

C/C++程序要运行起来，一般要经历以下几个步骤：

1.预处理：展开头文件、进行宏替换、条件编译、去掉注释。生成main.i

2.编译：检查语法错误，生成汇编代码。main.s

3.汇编：将汇编代码转换成二进制的机器码。main.o

4.链接：生成可执行程序。a.out

注意分离编译可能会导致编译出错，例如在下面的情况下：

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

编译器会报以下错误: