C++模板的特化和偏特化

特化

#include <iostream>
#include <deque>
#include <string>
#include <stdexcept>

//一般化模板
template<typename T>
class MyStack {};

//特化模板 当T为std::string时进行特殊处理
template<>
class MyStack<std::string>{
private:
	std::deque<std::string> elems;

public:
	MyStack();
	void push(std::string const& elem);
	void pop();
	std::string top() const;
	bool empty() const { return this->elems.empty(); }

};

inline MyStack<std::string>::MyStack(){}

inline void MyStack<std::string>::push(std::string const& elem) {
	this->elems.push_back(elem);
}

inline void MyStack<std::string>::pop() {
	if (this->elems.empty())
		throw std::out_of_range("Stack<std::string>::pop(): empty stack");
	this->elems.pop_back();
}

inline std::string MyStack<std::string>::top() const {
	if (this->elems.empty())
		throw std::out_of_range("Stack<std::string>::pop(): empty stack");

	return this->elems.back();
}


int main(void) {
	try {
		using stringStack = MyStack<std::string>;	//为MyStack<std::string>创建一个别名
		stringStack strStack;

		strStack.push("hello world");

		std::cout << "stringStack top is: " << strStack.top() << std::endl;
		strStack.pop();
		strStack.pop();

	}
	catch (const std::exception& e) {
		std::cerr << "Exception: " << e.what() << std::endl;
		return EXIT_FAILURE;

	}

	return 0;
}

偏特化

template<class T1, class T2>  // 普通版本，有两个模板参数
class A {};

template<class T1>			  // 偏特化版本，指定其中一个参数，即指定了部分类型
class A<T1, int> {};		  // 当实例化时的第一个参数为int 则会优先调用这个版本

template<class T2>			  // 偏特化版本，指定其中一个参数，即指定了部分类型
class A<int, T2> {};		  // 当实例化时的第二个参数为int 则会优先调用这个版本

template<class T>		// 普通版本
class A {};

template<class T>		// 偏特化版本，只接受指针
class A<T*> {};

template<class T>		// 偏特化版本，只接受引用
class A<T&> {};

template<class T>		// 偏特化版本，只接受容器vector
class A<std::vector<T>>{};

偏特化的特点就在于T没有完全消失，而是变成了组合的形式或者只消失了一部分