Stack的一种简单实现

注意以下几点：

1.Stack是一种适配器，底层以vector、list、deque等实现

2.Stack不含有迭代器

在本例中，我添加了几项功能，包括不同类型stack之间的复制和赋值功能，可以实现诸如Stack<int, vector<int> >和Stack<double, list<double> >之间的复制和赋值，这主要依靠成员函数模板来实现。

为了更方便的实现以上功能，我添加了一个函数：

const_container_reference get_container() const

来获取内部容器的引用。

此外，标准库的stack不检查越界行为，我为stack添加了异常处理，当栈空时，执行pop或者top会抛出异常。这个异常类继承自Exception，用来标示栈空。

代码如下:

#ifndef STACK_H
#define STACK_H
#include "Exception.h"
#include <deque>

class EmptyStackException : public Exception
{
public:
    EmptyStackException()
        :Exception("read empty stack")
    { }
};


template <typename T, typename Container = std::deque<T> >
class Stack
{
public:
    typedef T                                 value_type;
    typedef T&                                 reference;
    typedef const T&                         const_reference;
    typedef Container                         container_type;
    typedef EmptyStackException             exception_type;
    typedef typename Container::size_type     size_type;
    typedef Container&                         container_reference;
    typedef const Container&                const_container_reference;

    explicit Stack(const container_type &cont = container_type())
        :_cont(cont)
    { }

    template <typename T2, typename Container2>
    Stack<T, Container>(const Stack<T2, Container2> &s);

    template <typename T2, typename Container2>
    Stack<T, Container> &operator=(const Stack<T2, Container2> &s);

    void push(const value_type &value) { _cont.push_back(value); }

    void pop()
    {
        if(_cont.empty())
            throw exception_type();
        _cont.pop_back();
    }

    reference top()
    {
        if(_cont.empty())
            throw exception_type();
        return _cont.back();
    }

    const_reference top() const
    {
        if(_cont.empty())
            throw exception_type();
        return _cont.back();
    }

    bool empty() const { return _cont.empty(); }
    size_type size() const { return _cont.size(); }

    const_container_reference get_container() const
    { return _cont; }


    friend bool operator== (const Stack &a, const Stack &b)
    { return a._cont = b._cont; }

    friend bool operator!= (const Stack &a, const Stack &b)
    { return !(a == b); }

    friend bool operator< (const Stack &a, const Stack &b)
    { return a._cont < b._cont; }

    friend bool operator<= (const Stack &a, const Stack &b)
    { return a._cont <= b._cont; }

    friend bool operator> (const Stack &a, const Stack &b)
    { return a._cont > b._cont; }

    friend bool operator>= (const Stack &a, const Stack &b)
    { return a._cont >= b._cont; }

private:
    Container _cont;
};

template <typename T, typename Container>
template <typename T2, typename Container2>
Stack<T, Container>::Stack(const Stack<T2, Container2> &s)
    :_cont(s.get_container().begin(), s.get_container().end())
{ }

template <typename T, typename Container>
template <typename T2, typename Container2>
Stack<T, Container> &Stack<T, Container>::operator=(const Stack<T2, Container2> &s)
{
    if((void *)this != (void *)&s)
    {
        _cont.assign(s.get_container.begin(), s.get_container.end());
    }

    return *this;
}
#endif

测试代码如下:

#include "stack.h"
#include <iostream>
#include <string>
#include <vector>
#include <list>
#include <stdio.h>
using namespace std;

int main(int argc, char const *argv[])
{
    try
    {
        Stack<string, vector<string> > s;
        s.push("foo");
        s.push("bar");

        Stack<string, list<string> > s2(s);
        while(!s2.empty())
        {
            cout << s2.top() << endl;
            s2.pop();
        }

        s2.pop();                    //引发异常
    }

    catch(const Exception &ex)
    {
        fprintf(stderr, "reason : %s
", ex.what());
        fprintf(stderr, "stack trace : %s
", ex.stackTrace());
    }
    return 0;
}

测试结果为:

bar
foo
reason : read empty stack
stack trace : ./a.out()
./a.out()
./a.out()
./a.out()
./a.out()
/lib/libc.so.6(__libc_start_main+0xe6)
./a.out()