手搓C++队列

我制作的队列，采用了模仿动态数组的方法，本质上，是把链表本身不连续的物理地址，如数组那样，链接在了一起，代价是每次存入新值时，需要有至少比原本值大1个数据类型大小的空间

要说的要点，都写注释了

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;
template <typename T>
class My_queue     //队列
{
private:
    T *front;
    T *last;
    int num;    //记录成员数量
public:
    //构造函数
    My_queue(int size = 1)
    {
        front = new T[size];
        last = front;
        num = 0; //成员数初始化为0；
    }
    //析构函数
    ~My_queue()
    {
        delete []front;
        front = last = NULL;
    }

    //拷贝构造函数
    My_queue(const My_queue &other)
    {
        //原空间大小为num+1，申请空间
        this->front = new T[other.num+1];
        //存入
        memcpy(this->front, other.front, (other.num+1)*sizeof (T));
        this->num = other.num;
        //指针调整指向
        this->last = this->front + this->num;
    }

    //拷贝赋值
    My_queue(My_queue R, const My_queue &other)
    {
        //释放原空间
        delete []R.front;
        R.last = NULL;
        //原空间大小为num+1，申请空间
        R.front = new T[other.num +1];
        //存入
        memcpy(R.front, other.front, (other.num+1)*sizeof (T));
        R.num = other.num;
        //指针调整指向
        R.last = R.front + R.num;
    }

    //判空
    bool empty()
    {
        if(num != 0)
            return 0;
        else
            return 1;
    }

    //队尾入队
    void push(const T val)
    {
        T *temp = new T[this->num+2];   //一个塞数据，一个空
        memcpy(temp, this->front, (this->num+2)*sizeof(T));
        //释放原本空间
        delete []front;
        //更新指针指向
        this->front = temp;
        this->last = this->front + num;
        //存值
        *(this->last) = val;
        this->last++;
        num++;
    }
    //出队
    void pop()
    {
        //判空
        if(this->empty())
        {
            return;
        }
        T *temp = front;
        front = front+1;   //头指针往后移一位
        //释放原本位置的空间
        delete temp;
        //置空
        temp = NULL;
        num--;
    }
    int size()    //求容量
    {
        return num;
    }
    //根据下标查询
    T &at(int index)
    {
        return front[index];   //暂时不进行越界判断
    }
};