C++实现循环队列

（基础知识后期补充）
操作代码如下：

头文件CircleQueue.h

#include<iostream>
#include<cstring>

#pragma once  
//循环队列
class CircleQueue
{
public:
    CircleQueue(int size = 20);    //构造函数
    ~CircleQueue();   //析构函数
    CircleQueue(const CircleQueue &src);  //自定义构造函数（避免浅拷贝）
    void operator=(const CircleQueue &src); //自定义赋值函数（避免浅拷贝）
    void addQue(int val);  //入队
    void delQue();  //出队
    int front();  //返回队头元素
    int back();  //返回队尾元素
    bool empty();  //判断队空
    bool full(); //判断队满
    void print();//打印函数
private:
    int *_pQue;
    int _size;
    int _front;
    int _rear;
    void resize()
    {
        int *_pMQue = new int[_size * 2];
        if (_size<_rear)
        {
            memcpy(_pMQue, _pQue + _front, sizeof(int)*(_size - _front));
            memcpy(_pMQue + (_size - _front), _pQue, sizeof(int)*(_rear - _size));
            _rear = _rear - _front;
            _front = 0;
        }
        else
        {
            memcpy(_pMQue, _pQue, sizeof(int)*(_rear));
        }

        _size *= 2;
        delete[]_pQue;
        _pQue = _pMQue;
    }
};

实现方法CircleQueueFun.cpp

#include "CircleQueue.h"
#include<iostream>

using namespace std;
CircleQueue::CircleQueue(int size)
{
    _pQue = new int[size];
    _size = size;
    _front = 0;
    _rear = 0;
}

CircleQueue::~CircleQueue()
{
    delete[]_pQue;
    _pQue = NULL;
}
CircleQueue::CircleQueue(const CircleQueue &src)
{
    _pQue = new int[src._size];
    if (src._size<src._rear)  //表示循环队列中有循环发生
    {
        memcpy(_pQue, src._pQue + src._front, sizeof(int)*(src._size - src._front));   //先拷贝目前队列中处于非循环位置上元素  
        memcpy(_pQue + (src._size - src._front), src._pQue, sizeof(int)*(src._rear - src._size));//拷贝目前队列中处于循环位置上的元素  
        _size = src._size;
        _front = 0;
        _rear = src._rear - src._front;
    }
    else
    {
        memcpy(_pQue, src._pQue, sizeof(int)*(src._rear));
        _size = src._size;
        _front = src._front;
        _rear = src._rear;
    }
}

void CircleQueue::operator=(const CircleQueue &src)
{
    if (this == &src)
    {
        return;
    }
    delete[]_pQue;
    _pQue = new int[src._size];
    if (src._size<src._rear)
    {
        memcpy(_pQue, src._pQue + src._front, sizeof(int)*(src._size - src._front));
        memcpy(_pQue + (src._size - src._front), src._pQue, sizeof(int)*(src._rear - src._size));
        _size = src._size;
        _front = 0;
        _rear = src._rear - src._front;
    }
    else
    {
        memcpy(_pQue, src._pQue, sizeof(int)*(src._rear));
        _size = src._size;
        _front = src._front;
        _rear = src._rear;
    }
}

void CircleQueue::addQue(int val)
{
    if (full())
    {
        resize();
    }
    _pQue[(_rear) % _size] = val;
    _rear++;

}

void CircleQueue::delQue()
{
    if (empty())
    {
        return;
    }
    _front++;
}

int CircleQueue::front()
{
    return _pQue[_front];
}

int CircleQueue::back()
{
    return _pQue[_rear];
}
bool CircleQueue::empty()
{
    return (_rear - _front) == 0;
}

bool CircleQueue::full()
{
    return (_rear - _front) == _size;
}
void CircleQueue::print()
{
    for (int i = _front; i <_rear; i++)
    {
        if (i >= _size)
        {
            cout << _pQue[i%_size] << "\t";
        }
        else
        {
            cout << _pQue[i] << "\t";
        }

        if ((i - _front + 1) % 5 == 0)
            cout << endl;
    }
    cout << endl;
}

测试函数

/*
** 题目：实现循环队列
**注意点:扩容，拷贝队列时需要注意两种特殊情况的发生
*/


#include<iostream>
#include<cstring>
#include "CircleQueue.h"
#include <stdlib.h>
#include <time.h>  

using namespace std;

int main()
{
    cout << "循环队列基本操作" << endl;
    CircleQueue circlequeue(5);     //构造函数
    srand((unsigned)time(NULL));
    for (int i = 0; i < 5; i++)
    {
        circlequeue.addQue(rand());    //入队函数
    }
    circlequeue.print();  //打印函数


    for (int i = 0; i < 2; i++)
    {
        circlequeue.delQue();    //入队函数
    }
    circlequeue.print();  //打印函数


    for (int i = 0; i < 5; i++)
    {
        circlequeue.addQue(rand()); //入队函数
    }
    circlequeue.print();

    cout << "调用自定义拷贝构造函数" << endl;

    CircleQueue circlequeueTwo(circlequeue);
    circlequeueTwo.print();


    cout << "调用自定义赋值函数" << endl;
    CircleQueue circlequeueThree(5);
    circlequeueThree = circlequeue;
    circlequeueThree.print();
    for (int i = 0; i < 5; i++)
    {
        circlequeueThree.addQue(rand()); //入队函数
    }
    circlequeueThree.print();
    return 0;
}