Составить описание класса многочленов от одной переменной

#include <iostream>
#include <utility>
#include <iomanip>
 
/**
 * Single Indeterminate Polynomial
 * @tparam T coefficient type
 */
template<typename T>
class Polynomial {
public:
    using Self = Polynomial<T>;
 
    Polynomial() : size{1}, coefficients(new T[1]{}) {}
 
    explicit Polynomial(std::size_t size) : size{size}, coefficients(new T[size]{}) {}
 
    Polynomial(const std::initializer_list<T> &coefficients) : size{coefficients.size()}, coefficients{new T[size]} {
        std::copy(coefficients.begin(), coefficients.end(), Polynomial::coefficients);
    }
 
    Polynomial(const Self &o) : size{o.size}, coefficients(new T[size]{}) {
        std::copy(o.coefficients, o.coefficients + o.size, coefficients);
    }
 
    Self &operator=(const Self &o) {
        if (this != &o) {
            size = o.size;
            if (coefficients != o.coefficients) {
                delete[] coefficients;
                coefficients = new T[size]{};
                std::copy(o.coefficients, o.coefficients + o.size, coefficients);
            }
        }
        return *this;
    }
 
    Polynomial(Self &&o) noexcept: size{std::move(o.size)}, coefficients{std::exchange(o.coefficients, nullptr)} {}
 
    Self &operator=(Self &&o) noexcept {
        if (this != &o) {
            size = std::move(o.size);
            if (coefficients != o.coefficients) {
                coefficients = std::exchange(o.coefficients, nullptr);
            }
        }
        return *this;
    }
 
    Self &operator+=(const Self &o) {
        if (this == &o) {
            return *this;
        }
        if (o.size > size) {
            T *extended = new T[o.size]{};
            std::copy(coefficients, coefficients + size, extended);
            delete[] coefficients;
            coefficients = extended;
            size = o.size;
        }
        for (std::size_t i = 0; i < o.size; ++i) {
            coefficients[i] += o.coefficients[i];
        }
        return *this;
    }
 
    virtual ~Polynomial() {
        delete[] coefficients;
    }
 
    std::size_t getSize() const {
        return size;
    }
 
    T &operator[](std::size_t i) {
        return coefficients[i];
    }
 
    const T &operator[](std::size_t i) const {
        return coefficients[i];
    }
 
    T operator()(const T &value) {
        T thisValue{1};
        T result{0};
        for (std::size_t i = 0; i < size; ++i) {
            result += thisValue * coefficients[i];
            thisValue *= value;
        }
        return result;
    }
 
private:
    std::size_t size;
    T *coefficients;
};
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const Polynomial<T> &p) {
    for (std::size_t i = p.getSize(); i > 0; --i) {
        const T &value = p[i - 1];
        if (value >= 0) {
            out << "+";
        }
        out << std::fixed << std::setprecision(2) << value;
        if (i == 2) {
            out << "*x";
        } else if (i > 1) {
            out << "*x^" << (i - 1);
        }
    }
    return out;
}
 
template<typename T>
Polynomial<T> operator+(const Polynomial<T> &a, const Polynomial<T> &b) {
    if (a.getSize() < b.getSize()) {
        return operator+(b, a);
    }
    Polynomial<T> result{a};
    for (std::size_t i = 0; i < b.getSize(); ++i) {
        result[i] += b[i];
    }
    return result;
}
 
template<typename T>
Polynomial<T> operator-(const Polynomial<T> &a, const Polynomial<T> &b) {
    if (a.getSize() < b.getSize()) {
        return operator+(b, a);
    }
    Polynomial<T> result{a};
    for (std::size_t i = 0; i < b.getSize(); ++i) {
        result[i] -= b[i];
    }
    return result;
}
 
template<typename T>
Polynomial<T> multiply(const Polynomial<T> &p, const T &coefficient, std::size_t power) {
    Polynomial<T> result(p.getSize() + power);
    for (std::size_t i = 0; i < p.getSize(); ++i) {
        result[i + power] = p[i] * coefficient;
    }
    return result;
}
 
template<typename T>
Polynomial<T> operator*(const Polynomial<T> &a, const Polynomial<T> &b) {
    if (b.getSize() < a.getSize()) {
        return operator*(b, a);
    }
    Polynomial<T> result(a.getSize() + b.getSize() - 1);
    for (std::size_t i = 0; i < a.getSize(); ++i) {
        result += multiply(b, a[i], i);
    }
    return result;
}
 
template<typename T>
Polynomial<T> getDerivative(const Polynomial<T> &p) {
    if (p.getSize() == 1) {
        return Polynomial<T>{0};
    }
    Polynomial<T> result(p.getSize() - 1);
    for (std::size_t i = 0; i < result.getSize(); ++i) {
        result[i] = p[i + 1] * (i + 1);
    }
    return result;
}
 
int main() {
    Polynomial<int> a{1, 1, 1};
    Polynomial<int> b{1, 1, 1};
    std::cout << "a = " << a << std::endl
              << "b = " << b << std::endl
              << "a + b = " << a + b << std::endl
              << "a - b = " << a - b << std::endl
              << "a * b = " << a * b << std::endl
              << "a(2) = " << a(2) << std::endl
              << "Derivative of a = " << getDerivative(a) << std::endl;
 
    return 0;
}