《c++ Templates》笔记 第三章 类模板

// xx.h文件
#include <stdexcept>
#include <vector>

template<typename T>
class Stack
{
private:
    std::vector<T> elems;
public:
    void push(T const&);
    void pop();
    T top() const;
    bool empty() const
    {
         return elems.empty();   
    }
}

template<typename T>
void Stack<T>::push(T const& elem)
{
    elems.push_back(elem);
}

template<typename T>
void Stack<T>::pop()
{
    if(elems.empty()){
        throw std::out_of_range("Stack<>::pop():empty stack");
    }
    elems.pop_back();
}

template<typename T>
T Stack<T>::top() const
{
    if(elems.empty()){
        throw std::out_of_range("Stack<>::top():empty stack");
    }
    return elems.back();
}

// main.cpp文件
#include <iostream>
#include "xx.h"

int main()
{
	try{
        Stack<int> intStack;
        Stack<std::string> stringStack; 
        
        intStack.push(7);
        std::cout << intStack.top() << std::endl;
        
        stringStack.push("hello");
        std::cout << stringStack.top() << std::endl;
        stringStack.pop();
        stringStack.pop();
    }
    catch(std::exception const& ex){
        std::cerr << "Exception:" << ex.what() << std::endl;
    }
}

注意：基于不同类型的实例化，会生成不同的类型，比如：Stack和Stack是不同的类型。

类模板的特化

可以用实参来特化类模板，和函数模板的重载类似，可以指定特定类型的实现，来克服实例化模板的不足。

比如，实例化的实参必须支持模板参数的所有调用。对于不支持的类型，可以使用重载实现:

struct Number
{
    int value;
}

template<typename T>
inline T const& max(T const& a, T const& b)
{
    return a < b ? b : a;
}

// Number类型不支持max()的模板参数的'<'的调用，可以使用重载来克服这个缺点
inline Number const& max(Number const& a, Number const& b)
{
    return a.value < b.value ? b : a;
}

类模板的特化也是相同的道理，相当于对类重新实现。

// 对上面的Stack类模板进行特化,模板参数T替换成string
#include <stdexcept>
#include <deque>
using namespace std;

template<>    // 在class前面用template<>来表示特化
class Stack<string>
{
private:
    // 使用deque来管理内部元素，而不是vector
    std::deque<string> elems;	
public:
    void push(string const&);
    void pop();
    string top() const;
    bool empty() const
    {
         return elems.empty();   
    }
    
    // 添加full()成员函数，特化相当于是重新实现stack类，不需要和模板保存相同
    bool full() const{  
        return elems.full();
    }
}

// 特化后成员函数不是模板，不用加template
void Stack<string>::push(string const& elem) 
{
    // 这里和模板的实现相同，但特化的实现可以模板的实现完全不同
    elems.push_back(elem);
}

...略

局部特化

当有多个模板参数时，可以对部分模板参数进行局部特化

template<typename T1, typename T2>
class MyClass
{
    ...
}

// 两个模板参数相同
template<typename T>
class MyClass<T, T>
{
    ...
}

// 第二个模板参数为指定类型
template<typename T>
class MyClass<T, int>
{
    ...
}

// 两个模板参数都是指针类型
template<typename T1, typename T2>
class MyClass<T1*, T2*>
{
    ...
}

// 局部特化可能产生二义性，某个实例化可以匹配多个局部特化时就会产生二义性而报错
Myclass<int, int> m;	// 可以匹配MyClass<T, T>和MyClass<T, int>，报错

缺省模板实参

可以为类模板的模板参数定义缺省值，这个缺省值称为缺省模板实参，并可以引用它前面的模板参数。

// xx.h
template<typename T, typename CONT = std::vector<T>> // std::vector<T>的T引用了前面的T
class Stack
{
private:
    // 内部容器的类型可以使用模板参数指定
	CONT elems;
public:
	void push(T const&);
	void pop();
	T top() const;
	bool empty() const{
		return elems.empty();
	}
}

template<typename T, typename CONT>
void Stack<T, CONT>::push(T const& elem)
{
    elems.push_back(elem);
}
...略

// Stack模板的使用
Stack<int> intStack;                         // CONT = 缺省值(std::vector<int>)
Stack<double, std::deque<double>> dblStack;  // CONT = std::deque<double>

注意

类模板的实例化有个特殊的地方是：只有被调用的成员函数才会被实例化。对于开头的Stack类模板，比如：

Stack<int> intStack;
intStack.push(1);

// 如果整个程序中Stack<int>只调用了push()函数，那么它的实例化代码如下：
class Stack<int>
{
private:
    std::vector<int> elems;
public:
    // 只有push()被调用，因此只有push()被实例化
    void push(int const&);
}

void Stack<int>::push(int const& elem)
{
    elems.push_back(elem);
}