C++ template 学习笔记（第三，四章）

　　在这一章中主要讲述了class template相关的一些基础知识。主要分为：

　　　　1. class template的声明和定义

　　　　2. class template的使用

　　　　3. class template的特化

　　　　4. class template的偏特化

　　　　5. class template的预设模版参数

　　关于这几个方面，根据书上的例子，写了如下代码，注释部分为说明和一些注意事项：

#include <iostream>
#include <vector>

template <typename T, typename CONT = std::vector<T> >　　　　　　　　　　//模板参数缺省处理，默认为vector容器
class Stack                                    　　　　　　　　　　　　　　//在非特化的主模版声明中，类名后面不能跟尖括号说明类型
{
private:
    CONT elems;                                　　　　　　　　　　　　　　//储存元素所用容器，在此处我们使用了默认参数 vector 做为容器
    
public:
    void push(T const&);　　　　　　　　　　　　　　　　　　　　　　　　　　　 //类模版中的一些成员函数
    void pop();
    T top() const;
    inline bool empty() const {
        return elems.empty();
    }    
};

template <typename T, typename CONT>                        　　　　　　//除了特化类模版的类模版的成员函数的定义，
                                        　　　　　　　　　　　　　　　　　 //前面需要添加“template <typename T, typename CONT>”说明
void Stack<T, CONT>::push (T const& elem)                    　　　　　//对于函数定义处，需要使用类模版的类型名 “Stack<T, CONT>::” 来限定
{
    elems.push_back(elem);                             　　　　　　　　 //末尾添加元素
}

template <typename T, typename CONT>
void Stack<T, CONT>::pop()
{
    if (elems.empty ()){
        std::cout << "Stack<T, CONT>::pop(): empty stack!" << std::endl;
        return;    
    }
    elems.pop_back();                             　　　　　　　　　　//删除最后一个元素
}

template <typename T, typename CONT>
T Stack<T, CONT>::top() const
{
        
    if (elems.empty ()){
        std::cout << "Stack<T, CONT>::top(): empty stack!" << std::endl;
        return;
    }
    return elems.back ();                            　　　　 　　　//返回最后一个元素的值
}

/*
 *类模版的偏特化
 *（在这里尤其需要注意，定义模版的歧义性问题）
 */
template<typename CONT>                             　　　　　　 //类模版的偏特化，针对double类型的参数声明，将使用此模版 ，
class Stack<double, CONT>                            　　　　　　//因此只需接收一个容器类型即可
{
private:
    CONT elems;
public:
    void push(double const&);                        　　　　　　//在此处直接使用 double 类型即可
    void pop();
    double top() const;
    inline bool empty() const {
        return elems.empty();
    }
    
    inline void print()
    {
        std::cout << "Stack<double, CONT>_ >> " << elems.back() << std::endl;
    }

    Stack<double, CONT> operator=(Stack<double, CONT> const& stack_to);    //运算符重载，在此重载过程中使用了push_front函数
                                        　　　　　　　　　　　　　　　　　　　　 //因此，在选用容器时，许选用支持此函数的容器
};

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

template<typename CONT>
void Stack<double, CONT>::pop()
{
    if (elems.empty()){
        std::cout << "Stack<double, CONT>::pop(): empty stack!" << std::endl;
        return;
    }
    elems.pop_back();
}

template<typename CONT>
double Stack<double, CONT>::top() const
{
    if (elems.empty()){
        std::cout << "Stack<double, CONT>::top(): empty stack!" << std::endl;
        return;
    }
    return elems.back();
}

template<typename CONT>
Stack<double, CONT> Stack<double, CONT>::operator= (Stack<double, CONT> const& stack_to)
{
    if ((void*)this == (void*) &stack_to)
        return *this;

    Stack<double, CONT> temp(stack_to);
    elems.clear();
    while (!temp.empty())
    {
        elems.push_front(temp.top());
        temp.pop();
    }
    return *this;
}

/*
*模版的特化
*由于此处对模版的所有参数进行了特化，
*因此只需在声明前加 “template<>” 即可
*类的声明后面紧跟成员函数声明，
*成员函数前面需要使用类模版的类型名“Stack<std::string, std::vector<std::string> >"限定
*函数前无需添加 ”template<>" 
*/
template<>
class Stack<std::string, std::vector<std::string> >                　　　　//类模板的特化
{
private:
    typename std::vector<std::string> elems;
public:
    void push(std::string const&);
    void pop();
    std::string top() const;
    inline bool empty() const{
        return elems.empty();
    }
    inline void print(){
        std::cout << "Stack<std::string, std::vector<std::string> > _>> " << top() << std::endl;
    }
};

void Stack<std::string, std::vector<std::string> >::push(std::string const& elem)    //成员函数前面需要使用类模版的类型名“Stack<std::string, std::vector<std::string> >"限定
                                            　　　　　　　　　　　　　　　　　　　　　　　　//函数前无需添加 ”template<>" 
{
    elems.push_back(elem);
}

void Stack<std::string, std::vector<std::string> >::pop()
{
    if (elems.empty()){
        std::cout << "Stack<std::string, std::vector<std::string> >::pop(): empty stack!" << std::endl;
        return;
    }
    elems.pop_back();
}

std::string Stack<std::string, std::vector<std::string> >::top() const
{
    if (elems.empty()){
        std::cout << "Stack<std::string, std::vector<std::string> >::top(): empty stack!" << std::endl;
        return;
    }
    return elems.back();
}

　　对上述代码的使用和测试代码如下：

#include "template_3.hpp"
#include <deque>
#include <stdexcept>
#include <cstdlib>
using namespace std;

int main ()
{

    Stack<int> Stack_int;                                    //使用默认容器vector

    Stack_int.push(1);
    Stack_int.push(2);
    Stack_int.push(3);
    cout << "vector >> " << Stack_int.top() << endl;
    Stack_int.pop();
    cout << "vector >> " << Stack_int.top() << endl;


    Stack<int, std::deque<int> > Stack_deque_int;            //使用容器deque

    Stack_deque_int.push(1);
    Stack_deque_int.push(2);
    Stack_deque_int.push(3);
    cout << "deque >> " << Stack_deque_int.top() << endl;
    Stack_deque_int.pop();
    cout << "deque >> " << Stack_deque_int.top() << endl;

    Stack<string, vector<string> > Stack_string;
    Stack_string.push("aaa");
    Stack_string.push("bbb");
    Stack_string.push("cccc");
    Stack_string.print();
    Stack_string.pop();
    Stack_string.print();

    Stack<double, deque<double> > Stack_double, Stack_temp;
    Stack_double.push(1.1111);
    Stack_double.push(2.2222);
    Stack_double.push(3.3333);
    Stack_temp = Stack_double;
    Stack_temp.print();
    Stack_temp.pop();
    Stack_temp.print();
    return 0;
}

　　　

以上代码，均在gcc 4.6版本 编译通过~