реализовать методы консольного и файлового ввода/вывода, создать манипуляторы insetup и outsetup для форматирования соот

#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) // дружественный оператор вывода в поток (вывод элементов очереди 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(); // если очередь пуста
    }
    catch (const std::underflow_error& e) {
        std::cout << "Error popping element: " << e.what() << std::endl;
    }
 
    return 0;
}