【栈队列】一个数组实现两个栈(共享栈)

一个数组实现两个栈，就是共享栈的实现问题。

从图中可以看出，数组的起始位置和终点位置分别为两个栈的栈底。
给一个数组，给出两个栈顶，再给一个数组的容量。

废话不说，代码实现

template<class T>
class SharedStack
{
public:
    SharedStack()
        : _a(NULL)
        , _top1(0)
        , _top2(0)
        , _capacity(0)
    {
        _CheckCapacity();
    }
    ~SharedStack()
    {
        if (_a)
            delete[] _a;
    }
    void Push1(const T& data)
    {
        _CheckCapacity();
        _a[_top1++] = data;
    }
    void Push2(const T& data)
    {
        _CheckCapacity();
        _a[_top2--] = data;
    }
    void Pop1()
    {
        if (_top1 > 0)
            --_top1;
    }
    void Pop2()
    {
        if (_top2 < _capacity - 1)
            _top2++;
    }
    size_t Size1()
    {
        return _top1;
    }
    size_t Size2()
    {
        return _capacity - 1 - _top2;
    }
    bool Empty1()
    {
        return _top1 == 0;
    }
    bool Empty2()
    {
        return _top2 == _capacity - 1;
    }
    T& Top1()
    {
        if (_top1>0)
        {
            return _a[_top1 - 1];
        }
    }
    T& Top2()
    {
        if (_top2 < _capacity - 1)
            return _a[_top2 + 1];
    }
private:
    //判断
    void _CheckCapacity()
    {
        if (_a == NULL)
        {
            _capacity += 3;
            _a = new T[_capacity];
            _top2 = _capacity - 1;
            return;
        }
        if (_top1 == _top2)
        {
            size_t OldCapacity = _capacity;
            _capacity = _capacity * 2;
            T* tmp = new T[_capacity];
            for (size_t i = 0; i < _top1; i++)
            {
                tmp[i] = _a[i];
            }
            for (size_t j = OldCapacity - 1, i = _capacity - 1; j>_top2; j--, i--)
            {
                tmp[i] = _a[j];
            }
            delete[] _a;
            _a = tmp;
            _top2 += _capacity / 2;
        }
    }
private:
    T* _a;
    size_t _top1;
    size_t _top2;
    size_t _capacity;
};