简单顺序栈（C++模版技术实现）

//
// C++ 模版技术实现简单顺序栈. 
// 

#include <cstdlib>
#include <iostream>
#include <iomanip>
#include <stdexcept>

//
// 顺序栈类模版.  
//
template <typename T>
class Stack
{
private:
        int _top;
        size_t _size;
        T *_pStack;
        static const size_t _DEF_SIZE = 20;
        // 
        // _MIN_TOP 不应为 size_t 类型.
        // 因为 size_t 类型与 int 类型变量比较时会将 int 类型转换为 size_t 类型. 
        //
        static const int _MIX_TOP = 0; 
        
public:
        Stack(const size_t size = _DEF_SIZE)
                : _top(_MIX_TOP - 1)
                , _size(size)
        { _pStack = new T[_size]; }
        
        
        ~Stack(void)
        { delete[] _pStack; }
        
        
        bool isEmpty(void) const
        { return _MIX_TOP > _top; }
        
        
        bool isFull(void) const
        { return _size - 1 == _top; }
        
        
        T getTop(void) const
        {
                if (isEmpty()) {
                        throw std::underflow_error("栈空下溢 !"); 
                }
                return _pStack[_top]; 
        }
        
        
        void push(const T &val)
        {
                if (isFull()) {
                        throw std::overflow_error("栈满上溢 !");
                }
                _pStack[++_top] = val;
        }
        
        
        T pop(void)
        { 
                if (isEmpty()) {
                        throw std::underflow_error("栈空下溢 !");
                }
                return _pStack[_top--];
        }
};

//
// 测试栈. 
// 
int main(void)
{
        const size_t MAX_SIZE = 20;
        Stack<int> stack(MAX_SIZE);
        
        std::cout << "栈" << (stack.isEmpty() ? "" : "不") << "为空." << std::endl; 
        std::cout << "栈" << (stack.isFull() ? "" : "不") << "为满." << std::endl; 
        
        for (size_t i = 0; i < MAX_SIZE; ++i)
        {
                stack.push(i);
                std::cout << std::setw(3) << stack.getTop();
        }
        // stack.push(MAX_SIZE);
        
        std::cout << std::endl;
        std::cout << "栈" << (stack.isEmpty() ? "" : "不") << "为空." << std::endl; 
        std::cout << "栈" << (stack.isFull() ? "" : "不") << "为满." << std::endl; 
        
        for (size_t i = 0; i < MAX_SIZE; ++i)
        {
                std::cout << std::setw(3) << stack.pop();
        }
        // std::cout << std::setw(3) << stack.pop();
        
        return EXIT_SUCCESS;
}