Перезагрузить операции “<<” и “>>” для ввода и вывода многочленов

#include <iostream>
#include <utility>
#include <iomanip>
 
/**
 * Single Indeterminate Polynomial
 * @tparam T coefficient Type
 */
template<typename T>
class Polynomial {
public:
    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 Polynomial<T> &o) : size{o.size}, coefficients(new T[size]{}) {
        std::copy(o.coefficients, o.coefficients + o.size, coefficients);
    }
 
    Polynomial<T> &operator=(const Polynomial<T> &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(Polynomial<T> &&o) noexcept
            : size{std::move(o.size)}, coefficients{std::exchange(o.coefficients, nullptr)} {}
 
    Polynomial<T> &operator=(Polynomial<T> &&o) noexcept {
        if (this != &o) {
            size = std::move(o.size);
            if (coefficients != o.coefficients) {
                coefficients = std::exchange(o.coefficients, nullptr);
            }
        }
        return *this;
    }
 
    Polynomial<T> &operator+=(const Polynomial<T> &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 && i < p.getSize()) {
            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>
std::istream &operator>>(std::istream &in, Polynomial<T> &p) {
    for (int i = 0; i < p.getSize(); ++i) {
        in >> p[i];
    }
    return in;
}
 
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() {
 
    std::size_t size;
 
    std::cin >> size;
    Polynomial<float> a(size);
    std::cin >> a;
 
    std::cin >> size;
    Polynomial<float> b(size);
    std::cin >> b;
 
    std::cout << "a = " << a << "\n"
              << "b = " << b << "\n"
              << "a - b = " << a - b << "\n"
              << "a * b = " << a * b << "\n"
              << "a + b = " << a + b << "\n";
 
    return 0;
}

struct Point
{
    int m_n{0};
    std::vector<double> m_coeff;
};
 
std::istream& operator>> (std::istream &in, Point &point)
{
    point.clear();
    std::in >> point.m_n;
    for(int i = 0; i < point.m_n; i++)
    {
        double tmp;
        in >> tmp;
        point.coeff.emplace_back(tmp);
    }
    
    return in;
}
 
std::ostream& operator<< (std::ostream &out, const Point &point)
{
    bool first = true;
    for(const auto& x : point.coeff)
    {
        if(!first)
            std::out << '+';
        else
            first = false;
 
        out << x;
     }
     std::out << "x" << "^2";
    
    return out;
}