考虑vector常数小用数组操作生成队列

template <class T> struct _queue
{
    vector<T> q;
    int first = 0, rear = 0;
    inline void push(T& _) { q.push_back(_), rear++; }
    inline void pop() { first++; }
    inline T front() { return q[first]; }
    inline size_t size() { return rear - first; }
    inline bool empty() { return first == rear; }
};

实现队列类

// 原生版队列
//手写队列 copy的
template<class _Tp> class _queue
{
    enum { DEFAULT_SIZE = 50 }; 
    typedef _Tp DataType;
public:
    _queue() { _data = new DataType[_capacity]; } // 构造函数
    ~_queue() { if (_data) delete[] _data; } // 析构函数
    inline void push(const DataType& e)
    {
        extend(); // 判断是否需要扩容
        _data[_end] = e;  // 将end位置置为e
        _end = (_end + 1) % _capacity;  // 循环后移
    }
    inline void pop()
    {
        if (!empty()) // 判空
        {
            _data[_begin].~DataType();  // 释放begin处的元素
            _begin = (_begin + 1) % _capacity;  // 循环后移
        }
    }
    inline bool empty() const { return _begin == _end; }
    inline const DataType& front() const { return _data[_begin]; }
    inline size_t size() const { return (_end - _begin + _capacity) % _capacity; }
private:
    _Tp* _data = nullptr;
    int _begin = 0, _end = 0;
    size_t _capacity = (size_t)DEFAULT_SIZE;
    inline void extend() // 判断队列空间是否不够用
    {
        size_t siz = size();
        if (siz == _capacity - 1)
        {
            DataType* tmp = new DataType[_capacity << 1];
            for (int i = _begin, j = 0; i != _end; i = (i + 1) % _capacity, ++j) 
                tmp[j] = _data[i]; // 数据拷贝
            _begin = 0, _end = siz;
            delete[] _data;  // 释放原有空间
            _data = tmp, _capacity <<= 1;
        }
    }
};