一、类模板的泛化、偏特化和全特化 

1.类模板的泛化

//类模板 
template<class T1,class T2> 
class People
{
	public:
	void func(T1 a, T2 b)
	{
		cout << "(T1 a, T2 b)" << endl;
	}
};
 
 
int main(int argc, char** argv) {
	
	People<int,bool> p1;
	p1.func(12, true);
 
    system("pause");
    return 0;
}

2.类模板的偏特化（个数的偏特化）

        上面对主版本模板和全特化进行了定义，那么偏特化就是介于二者之间的模板，它的模板名与主版本模板名相同，但是它的模板型中，有被明确化的部分和没有被明确化的部分。那么这个类就叫做偏特化类。

注意：偏特化的条件：1.必须有一个主模板   2.模板类型被部分明确化

//先声明类模板
template<class T1,class T2> class People;
 
//类的偏特化 
template<class T1> 
class Peopleint> {
public:
	void func(T1 a, int b)
	{
		cout << "(T1 a, int b)" << endl;
	}
}; 
 
int main(int argc, char** argv) {
	People<bool,int> p2;
	p2.func(true, 12);
 
    system("pause");
    return 0;
}

3.类模板的偏特化（范围的偏特化）

注意：偏特化的条件：1.必须有一个主模板   2.模板类型被部分明确化 

//本来T1可以是任意类型，现在范围类型缩小为指针类型
template<class T1> 
class Peopleint> {
public:
	void func(T1* a, int b)
	{
		cout << "(T1* a, int b)" << endl;
	}
}; 
 
int main(int argc, char** argv) 
{	
	People<char*,int> p3;
	p3.func(const_cast<char*>(string("Hello,World!").c_str()), 12);
 
    system("pause");
    return 0;
}

4.类模板的全特化

        特化其实就是特殊化的意思，在模板类里，所有的类型都是模板（template），而一旦我们将所有的模板类型T都明确化，并且写了一个类名与主模板类名相同的类，那么这个类就叫做全特化类。C++模板全特化之后已经失去了Template的属性了。

注意：一个模板被称为全特化的条件：1.必须有一个主模板类  2.模板类型被全部明确化

//先声明类模板
template<class T1,class T2> class People;
 
//类的全特化 
template<> 
class People<double, int> {
public:
	void func(double a, int b)
	{
		cout << "(double a, int b)" << endl;
	}
};
 
 
int main(int argc, char** argv) {
	
	People<double, int> p4;
	p4.func(12.34, 12);
 
    system("pause");
    return 0;
}

二、函数的泛化、偏特化和全特化

1. 函数模板（泛化）

//模板函数
template<typename T, typename N> void func(T num1, N num2)
{
    cout << "num1:" << num1 << ", num2:" << num2 <
}

2. 函数的偏特化（个数的偏特化）

//模板函数
template<typename T, class N> void func(T num1, N num2)
{
    //cout << "num1:" << num1 << ", num2:" << num2 <
}
 
//偏特化，模板函数
template<typename T> void funcint>(T num1, int num2)
{
    cout << "num1:" << num1 << ", num2:" << num2 <
}

3. 函数的偏特化（范围的偏特化）

//模板函数
template<typename T, class N> void func(T num1, N num2)
{
    //cout << "num1:" << num1 << ", num2:" << num2 <
}
 
//偏特化，模板函数
template<typename T> void funcint>(T* num1, int num2)
{
    cout << "num1:" << num1 << ", num2:" << num2 <
}

4. 函数的全特化

//模板函数
template<typename T, class N> void func(T num1, N num2)
{
    //cout << "num1:" << num1 << ", num2:" << num2 <
}
 
//全特化，模板函数
template<> void func<double, int>(double num1, int num2)
{
    cout << "num1:" << num1 << ", num2:" << num2 <
}

三、模板类的调用优先级

        对主版本模板类、全特化类、偏特化类的调用优先级从高到低进行排序是：【全特化类>偏特化类>主版本模板类】。这样的优先级顺序对性能也是最好的。

        但是模板特化并不只是为了性能优化，更多是为了让模板函数能够正常工作，最典型的例子就是STL中的iterator_traits。algorithm中大多数算法通过iterator对象来处理数据，但是同时允许以指针代替iterator对象，这是为了支持C-Style Array。如果直接操作iterator，那么为了支持指针类型，每个函数都需要进行重载，因为指针没有::value_type类型。为了解决这个问题，STL使用了iterator_traits，并为指针类型进行转化，算法通过它来操作iterator，不需要知道实际操作的是iterator对象还是指针。

template<typename IteratorClass> class iterator_traits
...
template<typename ValueType> class iterator_traits
...
template<typename ValueType> class iterator_traitsconst*>
...