Разработать программу, формирующую и обрабатывающую объекты класса

#include <iostream>
#include <iomanip>
#include <random>
#include <algorithm>
 
 
/**
 * Абстрактный базовый класс стека
 * @tparam T тип элементов стека
 * @tparam Iterator тип итератора стека
 */
template<typename T, typename Iterator>
struct Stack {
    virtual void push(const T &) = 0;
 
    virtual void pop() = 0;
 
    virtual const T &peek() const = 0;
 
    virtual std::size_t getSize() const = 0;
 
    virtual bool isEmpty() const = 0;
 
    virtual Iterator begin() const = 0;
 
    virtual Iterator end() const = 0;
 
    virtual ~Stack() = 0;
};
 
/**
 * Функция добавления элемента в стек на базе опреатора сложения.
 *
 * @tparam T тип элемента стека
 * @tparam Iterator тип итератора стека
 * @param stack структура стека
 * @param value значение, добавляемое в стек
 * @return стек, переданный параметром
 */
template<typename T, typename Iterator>
Stack<T, Iterator> &operator+(Stack<T, Iterator> &stack, const T &value) {
    stack.push(value);
    return stack;
}
 
/**
 * Функция удаления элементов из стека. Удаляет столько элементов из стека, сколько указано во втором параметре.
 *
 * @tparam T тип элемента стека
 * @tparam Iterator тип итератора стека
 * @param stack структура стека
 * @param value количество значений, удаляемых из стека
 * @return стек, переданный параметром
 */
template<typename T, typename Iterator>
Stack<T, Iterator> &operator-(Stack<T, Iterator> &stack, std::size_t value) {
    while (value-- > 0) {
        stack.pop();
    }
    return stack;
}
 
// определение тела виртуального деструктора, без этого не соберётся
template<typename T, typename Iterator>
Stack<T, Iterator>::~Stack() = default;
 
/**
 * Оператор вывода стека на экран
 * @tparam T тип элемента стека
 * @tparam Iterator тип итератора стека
 * @param out поток вывода
 * @param s стек, который необходимо вывести
 * @return поток вывода, переданный параметром
 */
template<typename T, typename Iterator>
std::ostream &operator<<(std::ostream &out, const Stack<T, Iterator> &s) {
    out << "[";
    for (Iterator i = s.begin(); i != s.end(); ++i) {
        out << *i;
        if ((i + 1) != s.end()) {
            out << ", ";
        }
    }
    return out << "]";
}
 
/**
 * Стек на базе динамического массива
 * @tparam T тип элемента стека
 */
template<typename T>
class ArrayStack : public Stack<T, const T *> {
public:
 
    // тип итератора по стеку -- указатель на элемент стека
    using Iterator = const T *;
 
    /**
     * Конструктор без параметров, создает стек на 0 элементов
     */
    ArrayStack() : size{}, maxSize{}, data{new T[maxSize]{}} {}
 
    /**
     * Конструктор с одним параметом
     * @param maxSize максимальное количество элементов в стеке
     */
    explicit ArrayStack(std::size_t maxSize) : size{}, maxSize{maxSize}, data{new T[maxSize]{}} {}
 
    /**
     * Конструктор копирования
     * @param other копируемый стек
     */
    ArrayStack(const ArrayStack<T> &other) : size{other.getSize()}, maxSize{other.maxSize}, data{new T[maxSize]{}} {
        std::copy(other.begin(), other.end(), data);
    }
 
    /**
     * Конструктор перемещения
     * @param other перемещаемый стек
     */
    ArrayStack(ArrayStack<T> &&other) noexcept: size{std::move(other.size)}, maxSize{std::move(other.maxSize)},
                                                data{std::exchange(other.data, nullptr)} {}
    /**
     * Оператор присваивания
     * @param other присваеваемый стек
     * @return стек, у которого вызван оператор
     */
    ArrayStack<T> &operator=(const ArrayStack<T> &other) {
        if (this != &other) {
            delete[] data;
            size = other.size;
            maxSize = other.maxSize;
            data = new T[maxSize]{};
            std::copy(other.begin(), other.end(), data);
        }
        return *this;
    }
 
    /**
     * Оператор перемещения
     * @param other перемещаемый стек
     * @return стек, у которого вызван оператор
     */
    ArrayStack<T> &operator=(ArrayStack<T> &&other) noexcept {
        if (this != &other) {
            size = std::move(other.size);
            maxSize = std::move(other.maxSize);
            data = std::exchange(other.data, nullptr);
        }
        return *this;
    }
 
    /**
     * Деструктор
     */
    ~ArrayStack() override {
        delete[] data;
    }
 
 
    /**
     * ДОбавление элемента в стек
     * @param value добавляемое значение
     */
    void push(const T &value) override {
        if (size >= maxSize) {
            throw std::overflow_error("stack overflow");
        }
        data[size++] = value;
    }
 
    /**
     * Удаление элемента из вершины стека
     */
    void pop() override {
        if (size <= 0) {
            throw std::underflow_error("stack underflow");
        }
        --size;
    }
 
    /**
     * Просмотр элемента на вершине стека
     * @return элемент на вершине стека
     */
    const T &peek() const override {
        if (size <= 0) {
            throw std::underflow_error("stack underflow");
        }
        return data[size - 1];
    }
 
    /**
     * Получение размера стека
     * @return количество элементов в стеке
     */
    std::size_t getSize() const override {
        return size;
    }
 
    /**
     * Проверка на пустоту стека
     * @return true, если стек пустой, в ином случае false
     */
    bool isEmpty() const override {
        return size == 0;
    }
 
    /**
     * Итератор на элемент в стеке, добавленный раньше всех остальных.
     * @return новый итератор на начало стека
     */
    Iterator begin() const override {
        return data;
    }
 
    /**
     * Итератор на элемент в стеке, следующий за элементом, добавленным самым последним.
     * @return новый итератор на эелмент после вершины стека
     */
    Iterator end() const override {
        return data + size;
    }
 
private:
    std::size_t maxSize;
    std::size_t size;
    T *data;
};
 
int main() {
    ArrayStack<double> stack(200);
 
    stack + 2./3. + 3.333333;
 
    std::cout << std::fixed << std::setprecision(2) << stack << std::endl;
 
    while (!stack.isEmpty()) {
        std::cout << stack.peek() << std::endl;
        stack - 1;
    }
 
    std::cout << std::fixed << std::setprecision(2) << stack << std::endl;
 
    return 0;
}