【C++模板】类模板的全部特例化和局部特例化(偏特化-partial specialization)

前言

本专栏所有的文章都需要一定的基础知识。在文中对于基础的概念将会一带而过，或者在其他文章有讲，会贴出对应的链接而不再进行赘述。

类模板的Stack实现

为了方面下面的使用，这里我们需要手动实现一个Stack类。由于实现的较为简单，这里就直接放出源码了。

头文件MyStack.h

#pragma once

#include 
#include 
#include 

using std::vector;
using std::string;

template<class  T>
class MyStack
{
public:
	void Push(T const& t);
	void Pop();
	T Top() const;
	inline bool Empty() const
	{
		return elems.empty();
	}

private:
	std::vector<T> elems;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

源文件MyStack.cpp

#include "MyStack.h"

template<class T>
void MyStack<T>::Push(T const& t)
{
	elems.push_back(t);
}

template<class T>
void MyStack<T>::Pop()
{
	if (false == elems.empty())
	{
		throw std::out_of_range("Stack<>::Pop(): empty stack!");
	}

	elems.pop_back();
}

template<class T>
T MyStack<T>::Top() const
{
	if (false == elems.empty())
	{
		throw std::out_of_range("Stack<>::Pop(): empty stack!");
	}

	return elems.back();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

类模板的全部特例化(偏特化)

通过特例化（偏特化）类模板，可以优化基于某种特定类型的实现，还可以为特定类型提供特殊的操作。

写法

当我们需要特例化一个类模板时，我们必须在最开始的地方添加template<>尖括号中间没有任何内容，然后还需要在函数头的地方指明特例化的类型。

tempate<>
class ClassName<特例化的类型>
{
]
1
2
3
4

特例化MyStack

对比基本MyStack类，其实我们就是把原本为T类型该为你特例化的类型就好了。最主要的我们在特例化的实现中可以修改原本基本类模板的实现，基本类模板中用的是vector，而特例化string类型中用的是list。

template<>
class MyStack<string>
{
public:
	void Push(string const& t);
	void Pop();
	string Top() const;
	inline bool Empty() const
	{
		return elems.empty();
	}

private:
	std::list<string> elems;
};

void MyStack<string>::Push(string const& t)
{
	elems.push_back(t);
}


void MyStack<string>::Pop()
{
	if (false == elems.empty())
	{
		throw std::out_of_range("Stack<>::Pop(): empty stack!");
	}

	elems.pop_back();
}


string MyStack<string>::Top() const
{
	if (false == elems.empty())
	{
		throw std::out_of_range("Stack<>::Pop(): empty stack!");
	}

	return elems.back();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

类模板的局部特例化(偏特化)

而有时候我们并不需要重写所有的方法，那么就可以通过局部特例化来进行实现。

基本类模板

先实现一个基本类模板，有俩个模板参数分别是T1、T2。

template<class T1, class T2>
class Class1{ ... };
1
2

局部特例化

俩个模板参数相同的类型

template<class T>
class Class1<T, T>
{
};
1
2
3
4

第二个模板参数为int类型

template<class T>
class Class1<T, int>
{
};
1
2
3
4

俩个模板参数都是指针的类型

template<class T1, class T2>
class Class1<T1*, T2*>
{
};
1
2
3
4

调用

	Class1<int, float> c1;
	Class1<float, float> c2;
	Class1<float, int> c3;
	Class1<int*, float*> c4;
1
2
3
4

局部特例化导致的二义性

比如上面我们同时实现了俩个模板参数都为int类型的和俩个模板参数都是指针类型，那么我们实例化Class1 c5; 时编译就会报错，存在二义性。所以我们在实现局部特例化时也需要考虑二义性的问题。

Class1<int, int> c5; //  error C2752: 'Class1': more than one partial specialization matches the template argument list
1

那么对于上述存在的二义性问题我们可以实现一种俩个类型相同且类型为指针的特例化。

template<class T>
class Class1<T*, T*>
{
};
1
2
3
4

缺省模板实参

类模板中还可以和函数一样设置缺省值， 还可以引用之前的模板参数。这个缺省值就被称为缺省模板实参。

例如下面第二个模板参数为缺省参数。将这个与文章开头自定义的Stack模板类结合起来，就可以实现动态的指定存储数据的容器类型了。 有兴趣的读者朋友可以尝试自己实现哦。

template <class T1, typename T2 = std::vector<T1> >
class Class2
{
public:
	void test(T1 t);
};

template<class T1, typename T2>
void Class2<T1, T2>::test(T1 t)
{
	//test 
}

1
2
3
4
5
6
7
8
9
10
11
12
13

总结

• 类模板是具有如下性质的类:在类的实现中，可以有一个或多个类型还没有被指定。
• 为了使用类模板，你可以传入某个具体类型作为模板实参;然后编译器将会基于该类型来实例化类模板。
• 对于类模板而言，只有那些被调用的成员函数才会被实例化。·你可以用某种特定类型特例化类模板。
• 你可以用某种特定类型局部特例化类模板。
• 你可以为类模板的参数定义缺省值，这些值还可以引用之前的模板参数。