Создать класс Lqueue – структура типа "очередь" базируется на структуре связного списка

#include <iostream>
#include <stdexcept>
 
template<typename T>
class Queue {
public:
    Queue() noexcept: base(), size(0) {}
 
    Queue(const Queue<T> &o) noexcept: base(), size(0) {
        for (NodeBase *i = o.base.next; i != &o.base; i = i->next) {
            add(static_cast<Node *>(i)->value);
        }
    }
 
    Queue<T> &operator=(const Queue<T> &o) noexcept {
        if (this != &o) {
            clear();
            for (NodeBase *i = o.base.next; i != &o.base; i = i->next) {
                add(static_cast<Node *>(i)->value);
            }
        }
        return *this;
    }
 
    ~Queue() noexcept {
        clear();
    }
 
    void clear() {
        while (!isEmpty()) {
            delete base.next;
        }
    }
 
 
    void add(const T &value) {
        new Node(base.prev, value);
        ++size;
    }
 
    std::size_t getSize() const {
        return size;
    }
 
    T pop() {
        if (isEmpty()) {
            throw std::underflow_error("queue is empty");
        }
        T result = static_cast<Node *>(base.next)->value;
        delete base.next;
        --size;
        return result;
    }
 
    bool isEmpty() const {
        return base.next == &base;
    }
 
    friend std::ostream &operator<<(std::ostream &out, const Queue<T> &q) {
        for (NodeBase *i = q.base.next; i != &q.base; i = i->next) {
            std::cout << (static_cast<Node *>(i)->value);
            if (i->next != &q.base) {
                std::cout << ", ";
            }
        }
        return out;
    }
 
private:
 
    struct NodeBase {
        NodeBase *next;
        NodeBase *prev;
 
        NodeBase() noexcept: next(this), prev(this) {}
 
        explicit NodeBase(NodeBase *after) noexcept: next(after->next), prev(after) {
            next->prev = prev->next = this;
        }
 
        virtual ~NodeBase() noexcept {
            next->prev = prev;
            prev->next = next;
        }
    };
 
    struct Node : public NodeBase {
        T value;
 
        Node(NodeBase *after, const T &value) noexcept: NodeBase(after), value(value) {}
    };
 
    NodeBase base;
    std::size_t size;
};
 
int main() {
 
    Queue<int> a;
 
    for (int i = 0; i < 10; ++i) {
        a.add(i);
    }
    
    std::cout << "Size: " << a.getSize() << " [" << a << "]" << std::endl;
    while (!a.isEmpty()) {
        std::cout << "Pop: " << a.pop() << std::endl;
        std::cout << "Size: " << a.getSize() << " [" << a << "]" << std::endl;
    }
 
    try {
        a.pop(); // pop when queue is empty
    } catch (const std::underflow_error &e) {
        std::cout << "Error popping element: " << e.what() << std::endl;
    }
 
    return 0;
}