数组实现双向栈

#ifndef __BISTACK__
#define __BISTACK__
template <typename T>
class BISTACK{
public:
    virtual bool push(T val)=0;
    virtual T pop()=0;
    virtual bool empty()=0;
    BISTACK(){cout << "virtual class constructor calling!\n";};
    virtual ~BISTACK(){cout << "virtual class deconstructor calling!\n";};
protected:
    int top;
    const static int size = 20;  // 静态常量成员可以在类里初始化
    static T* stackarray;
    static int res;
private:
    
};
//template <typename T>
//int BISTACK<T>::size = 20;
template <typename T>
int BISTACK<T>::res = size;
template <typename T>
T* BISTACK<T>::stackarray  = new T[BISTACK<T>::size];

template <typename T>
class lstack: public BISTACK<T>
{
public:
     bool push(T val);
     T pop();
     bool empty();
     lstack();
     ~lstack();
};

template <typename T>
class rstack:public BISTACK<T>
{
public:
     bool push(T val);
     T pop();
     bool empty();
     rstack();
     ~rstack();

};

template <typename T>
lstack<T>::lstack()
{
    top = -1;
    cout <<"lstack constructor calling!\n";
}

template <typename T>
rstack<T>::rstack()
{
    top = size;
    cout <<"rstack constuctor calling!\n";
}

template <typename T>
T lstack<T>::pop()
{
    if(top <= -1){
        cerr << "error, empty stack, no element to pop!\n";
        
    }
    top = top -1;
    res = res + 1;
    cout <<"lstack pop success!\n";
    return stackarray[top+1];
    //return BISTACK::stackarray[top+1];   // 静态成员可以通过类名或者对象来调用
}

template <typename T>
bool lstack<T>::push(T val)
{
    if(res <= 0){
        cout <<"error,stack is full!\n";
        return false;
    }
    top = top +1;
    stackarray[top] = val;
    res = res -1;
    cout << "lstack push success!\n";
    return true;
}

template <typename T>
lstack<T>::~lstack()
{
    res = res + top +1;
    top = -1;
    cout << "lstack deconstructor calling!\n";
}

template <typename T>
bool lstack<T>::empty()
{
    if(top == -1)
        return true;
    else
        return false;
}

template <typename T>
bool rstack<T>::empty()
{
    if(top == size)
        return true;
    else
        return false;
}

template <typename T>
T rstack<T>::pop()
{
    if(top >= size){
        cerr<< "error! empty stack! no element to pop!\n";
    }
    top = top + 1;
    res += 1;
    cout <<"rstack pop success!\n";
    return stackarray[top-1];

}

template <typename T>
bool rstack<T>::push(T val)
{
    if(res<=0)
    {
        cout<<"error! stack is full!\n";
        return false;
    }

    res -=1;
    top = top -1;
    stackarray[top] = val;
    cout << "rstack puch success!\n";
    return true;
}

template <typename T>
rstack<T>::~rstack()
{
    res = res + size - top;
    top = size;
    cout <<"rstack deconstructor calling!\n";
}

#endif