C++primer 学习笔记 -第16章 模板与泛型编程(模板的偏特化与全特化)

1. 特化的概念

模板特化（template specialization）不同于模板的实例化，模板参数在某种特定类型下的具体实现称为模板特化。模板特化有时也称之为模板的具体化，分别有函数模板特化和类模板特化。

1.1 模板偏特化

模板偏特化（Template Partitial Specialization）是模板特化的一种特殊情况，指显示指定部分模板参数而非全部模板参数，或者指定模板参数的部分特性分而非全部特性，也称为模板部分特化。与模板偏特化相对的是模板全特化，指对所有模板参数进行特化。模板全特化与模板偏特化共同组成模板特化。

模板偏特化主要分为两种，一种是指对部分模板参数进行全特化，另一种是对模板参数特性进行特化，包括将模板参数特化为指针、引用或是另外一个模板类。

1.1 函数重载和特化的差别

（1）如果使用普通重载函数，那么不管是否发生实际的函数调用，都会在目标文件中生成该函数的二进制代码。而如果使用模板的特化版本，除非发生函数调用，否则不会在目标文件中包含特化模板函数的二进制代码。这符合函数模板的“惰性实例化”准则。

（2）如果使用普通重载函数，那么在分离编译模式下，需要在各个源文件中包含重载函数的申明，否则在某些源文件中就会使用模板函数，而不是重载函数。
（3）重载会改变匹配优先度，而特例化则不会。会优先选择重载。

2. 函数模板特化(只有全特化，)

2.1 全特化

例子:

#include <iostream>
using namespace std;

using CCHAR = const char*;

template <typename T> T Max(const T& t1, const T& t2)
{
	cout << "T Max" << endl;
	return t1 > t2 ? t1 : t2;
}

template <> CCHAR Max<CCHAR>(CCHAR const& t1, CCHAR const& t2)
{
	cout << "const char* Max" << endl;
	return strcmp(t1, t2) > 0? t1 : t2;
}

int main(int argc, char** argv)
{
	cout << Max(1, 2) << endl;
	cout << Max<const char*>("abc", "abc") << endl;
}

结果:

2.2 重载

template<class T,class N> void f(T，N);          
template<class T> void f( int, T,double ); 

3. 类模板特化

3.1全特化

例子:

#include <iostream>
using namespace std;

template <typename T> class A
{
	T num;
public:
	A() {
		num = T(6.6);
	}
	void print() {
		cout << "A'num:" << num << endl;
	}
	~A() {};
};
template <> class A<const char *>
{
	const char*  str;
public:
	A() {
		str = "AAAAAAAAAAAAAA";
	}
	void print() {
		cout << "A'str:" << str << endl;
	}
	~A() {};
};
int main(int argc, char** argv)
{
	A<int> a;
	A<const char*> cstr;
	a.print();
	cstr.print();
	return 0;
}

结果:

3.2偏特化

3.2.1类模板部分特例化

例子:

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

using CCHAR = const char*;

template <typename T, class N> class  TestClass
{
public:
	static bool comp(T num1, N num2)
	{
		cout << "standard class template" << endl;
		return (num1 < num2) ? true : false;
	}
};

// 对部分模板参数进行特化
template <class N> class  TestClass<int,N>
{
public:
	static bool comp(int num1, N num2)
	{
		cout << "partitial specialization template" << endl;
		return (num1 < num2) ? true : false;
	}
};

// 将模板参数特化为指针
template <typename T, class N> class  TestClass<T*, N*>
{
public:
	static bool comp(T* num1, N* num2)
	{
		cout << "new partitial specialization template" << endl;
		return (*num1 < *num2) ? true : false;
	}
};

// 将模板参数特化为另一个模板类
template <typename T, class N> class  TestClass<vector<T>, vector<N>>
{
public:
	static bool comp(vector<T> &vecLeft, vector<N>& vecRight)
	{
		cout << "to vector partitial  specialization template" << endl;
		return (vecLeft.size() < vecRight.size()) ? true : false;
	}
};
int main(int argc, char** argv)
{
	cout << TestClass<char, char>::comp('0', '1') << endl;
	cout << TestClass<int, char>::comp(30, '1') << endl;
	int a = 30 ,b =21;
	cout << TestClass<int*, int*>::comp(&a, &b) << endl;
	vector<int> vecLeft{ 0 };
	vector<int> vecRight{1,2,3};
	cout << TestClass<vector<int>, vector<int>>::comp(vecLeft, vecRight) << endl;
}

结果:

特例化成员函数

例子:

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

template <typename T, class N> class  TestClass
{
public:
	 bool comp(T num1, N num2)
	{
		cout << "standard class template" << endl;
		return (num1 < num2) ? true : false;
	}
};
template<>
bool TestClass<int, int>::comp(int num1, int num2) {
	cout << "int partitial  class template" << endl;
	return (num1 < num2) ? true : false;
}
int main(int argc, char** argv)
{
	TestClass<char, char> a; 
	TestClass<int, int> aint;
	cout<< a.comp('0', '1') << endl;
	cout << aint.comp(0, 1) << endl;
	
}

结果：