（基礎知識後期補充）
操作程式碼如下：

標頭檔案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;
}