Реализовать шаблон очереди в виде «динамического» массива

#include <iostream>
#include <stdexcept>
 
template<typename T>
class ArrayQueue {
public:
    ArrayQueue(std::size_t size) : head(0), tail(0), maxSize(size), twiceMaxSize(maxSize * 2), data(new T[size]) {}
 
    ArrayQueue(const ArrayQueue<T> &) = delete;
 
    ArrayQueue<T> &operator=(const ArrayQueue<T> &) = delete;
 
    ~ArrayQueue() {
        delete[] data;
    }
 
    void push(const T &value) {
        if (getSize() == maxSize) {
            throw std::overflow_error("queue overflow");
        }
        data[tail % maxSize] = value;
        tail = fix(tail + 1);
    }
 
    void pop() {
        if (isEmpty()) {
            throw std::underflow_error("stack is empty");
        }
        head = fix(head + 1);
    }
 
    T &top() {
        if (isEmpty()) {
            throw std::underflow_error("stack is empty");
        }
        return data[head % maxSize];
    }
 
    const T &top() const {
        if (isEmpty()) {
            throw std::underflow_error("stack is empty");
        }
        return data[head % maxSize];
    }
 
    std::size_t getSize() const {
        return tail - head;
    }
 
    bool isEmpty() const {
        return getSize() == 0;
    }
 
    std::size_t getMaxSize() const {
        return maxSize;
    }
 
private:
    std::size_t fix(std::size_t index) {
        return index % (twiceMaxSize);
    }
 
    std::size_t head;
    std::size_t tail;
    std::size_t maxSize;
    std::size_t twiceMaxSize;
    T *data;
};
 
int main() {
 
    ArrayQueue<int> x(5);
 
    for (std::size_t i = 0; i < 11; ++i) {
        for (std::size_t j = 0; j < x.getMaxSize() - 1; ++j) {
            x.push(j);
        }
        while (!x.isEmpty()) {
            std::cout << x.top() << ' ';
            x.pop();
        }
    }
 
    return 0;
}