循环队列的顺序结构实现

class Queue
{
public:
    Queue(int len = 10);
    Queue(const Queue& src);
    Queue& operator=(const Queue& src);
    ~Queue();

    void Push(int val);
    void Pop();
    int getHead();

    bool isEmpty();
    bool isFull();
    void show();
private:
    int* _arr;
    int _head;
    int _tail;
    int _len;
};

Queue::Queue(int len) : _head(0), _tail(0)
{
    if (len < 10)
    {
        _len = 10;
    }
    _len = len;
    _arr = new int[len];
}

Queue::Queue(const Queue&ob) :  _head(ob._head), _tail(ob._tail)
{
    _arr = new int[ob._len];
    _len = ob._len;
    for (int j = _head; j != _tail; j = (j + 1) % _len)
    {
        _arr[j] = ob._arr[j];
    }
}

Queue& Queue::operator=(const Queue& src)
{
    if (this == &src)
    {
        return *this;
    }
    if (_arr == nullptr)
    {
        delete[]_arr;
    }
    _arr = new int[src._len];
    _len = src._len;
    _head = src._head;
    _tail = src._tail;
    for (int j = _head; j != _tail; j = (j+1)%_len)
    {
        _arr[j] = src._arr[j];
    }
    return *this;

}

Queue::~Queue()
{
    if(_arr )
    delete[]_arr;
    _arr = nullptr;
    _head = 0;
    _tail = 0;
    _len = 0;
}
bool Queue::isEmpty()
{
    return _head == _tail;
}

bool Queue::isFull()
{
    return (_tail + 1) % _len == _head;
}

void Queue::Push(int val)
{
    if (!isFull())
    {
        _arr[_tail] = val;
        _tail = (_tail + 1) % _len;
    }     
}

void Queue::Pop()
{
    if (!isEmpty())
    {
        _head = (_head + 1) % _len;
    }
}

int Queue::getHead()
{
    if (!isEmpty())
    {
        return _arr[_head];
    }
}

void Queue::show()
{
    for (int j = _head; j != _tail; j = (j + 1) % _len)
        cout << j << " ";
}

int main() {
   
    int arr[] = { 123,32,7,25,453,791,66,432,1245,9,770};
    Queue q;
    for (int j = 0; j < 9; ++j)
    {
        q.Push(j);
    }
    q.show();
    cout << endl;
    for (int j = 0; j < 4; ++j)
    {
        cout<<q.getHead()<<endl;
        q.Pop();
    }
    q.show();
    return 0;

}