Задание: создать класс полином

[Ghost111]

Доброго времени суток! Буквально сегодня мне ответили по поводу решения следующего задания:


"Разработать класс «Полином» от одной переменной.
Полином задается степенью и массивом коэффициентов.
Реализовать методы для вычисления значения полинома, сложения, вычитания и умножения полиномов.
Перегрузить операции сложения, вычитания, умножения, присваивания для данного класса.
Полином от одной переменной есть конечная формальная сумма вида:
C0 + C1 * x^1 + ... + Cn * x^n"


Но я всё же захотел на основе того кода, который разместили в моей предыдущей теме решил создать свой. Вот результат:

#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
 
class Polynom
{
    public:
    int k[];
    int s;
    
    Polynom operator + (Polynom object) //перегрузка оператора "+"
    {
        Polynom P;
        for (int i = 0; i <= s; i++)
        {
            P.k[i] = k[i] + object.P[i];
        }
        return P;
    }
    
    Polynom operator - (Polynom object) //перегрузка оператора "-"
    {
        Polynom P;
        for (int i = 0; i <= s; i++)
        {
            P.k[i] = k[i] - object.P[i];
        }
        return P;
    }
    
    Polynom operator * (double z) //перегрузка оператора "*"
    {
        Polynom P;
        for (int i = 0; i <= s; i++)
        {
            P.k[i] = k[i] * z;
        }
        return P;
    }
    
    Polynom operator = (Polynom object) //перегрузка оператора "="
    {
        Polynom P;
        for (int i = 0; i <= s; i++)
        {
            P.k[i] = k[i];
        }
        return P;
    }
    
    Polynom() //конструктор класса
    {
        for (int i = 0; i <= s; i++)
        {
            k[i] = i + 1;
        }
    }
    
    Polynom operator + (Polynom a, Polynom b) //сложение полиномов
    {
        int B = a.s;
        int A[] = new int[B + 1];
        Polynom p = new Polynom(A, B);
        for (int i = 0; i < a.s + 1; i++)
        {
            p.k[i] = a.k[i] + b.k[i];
        }
        return p;
    }
    
    Polynom operator - (Polynom a, Polynom b) //вычитание полиномов
    {
        int B = a.s;
        int A[] = new int[B + 1];
        Polynom p = new Polynom(A, B);
        for (int i = 0; i < a.s + 1; i++)
        {
            p.k[i] = a.k[i] - b.k[i];
        }
        return p;
    }
    
    Polynom operator * (Polynom a, Polynom b) //умножение полиномов
    {
    int B = a.s;
        int A[] = new int[B + 1];
        Polynom p = new Polynom(A, B);
        for (int i = 0; i < a.s + 1; i++)
        {
            p.k[i] = a.k[i] * b.k[i];
        }
        return p;   
    }
    
    void show(Polynom object) //функция отображения коэффициентов
    {
        for (int i = 0; i < s; i++)
        {
            cout << "Полином: " << "+ " << k[i] << "x^ " << (s - i);
        }
    }
};
 
int main()
{
    Polynom a, b;
    cout << "Полином a = ";
    cout << "Полином b = ";
    cout << "Полином с = a = ";
    cout << "Сумма полиномов: ";
    cout << "Разность полиномов: ";
    cout << "Умножение полиномов";
}

Конечно же, в нём есть ошибки, но это всё, что я смог написать. Пожалуйста, помогите его доделать так, чтобы всё работало правильно и были все функции, классы, методы и т.д., которые в задании написаны.

[Ghost111]

#include <iostream>
#include <iomanip>
#include <algorithm>
 
/**
 * 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(Polynomial<T> &&o) noexcept: size{}, coefficients{} {
        swap(*this, o);
    }
 
    Polynomial<T> &operator=(Polynomial<T> other) noexcept {
        swap(*this, other);
        return *this;
    }
 
    Polynomial<T> &operator+=(Polynomial<T> o) {
        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;
    }
 
    friend void swap(Polynomial<T> &a, Polynomial<T> &b) {
        using std::swap;
        swap(a.coefficients, b.coefficients);
        swap(a.size, b.size);
    }
 
    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 = 0, size = p.getSize(); i < size; ++i) {
        const T &value = p[i];
        if (value >= 0) {
            out << "+";
        }
        out << std::fixed << std::setprecision(2) << value;
        if (i == 1) {
            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) {
    Polynomial<T> result(std::max(a.getSize(), b.getSize()));
    for (std::size_t i = 0, size = a.getSize(); i < size; ++i) {
        result[i] = a[i];
    }
    for (std::size_t i = 0, size = b.getSize(); i < size; ++i) {
        result[i] += b[i];
    }
    return result;
}
 
template<typename T>
Polynomial<T> operator-(const Polynomial<T> &a, const Polynomial<T> &b) {
    Polynomial<T> result(std::max(a.getSize(), b.getSize()));
    for (std::size_t i = 0, size = a.getSize(); i < size; ++i) {
        result[i] = a[i];
    }
    for (std::size_t i = 0, size = b.getSize(); i < size; ++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;
}
 
int main() {
    Polynomial<double> a{0, 1, 0, 1};
    Polynomial<double> b{1, 0, 1};
    Polynomial<double> c{1};
 
    std::cout
            << "a = " << a << std::endl
            << "b = " << b << std::endl
            << "c = " << b << std::endl
            << "a(1) = " << a(1) << std::endl
            << "b(2) = " << b(2) << std::endl
            << "a + b = " << a + b << std::endl
            << "a - b = " << a - b << std::endl
            << "a * b = " << a * b << std::endl
            << "c = a = " << (c = a) << std::endl
            ;
 
    return 0;
}

Или вот код, который мне написали на другом форуме для этого задания. Можно ли его как-то переделать, чтобы без std почти в каждой строчке? Точнее, я знаю, что можно просто написать using namespace std, но как именно будет выглядеть код, непонятно мне немного.

[Алексей1153]

Сообщение от Ghost111

class Polynom
{
public:
int k[];
int s;

какой смысл в массиве с неуказанным размером? Это даже не скомпилится (кроме специального кривожопого случая, унаследованного из Си, там этот массив можно разместить самым последним полем)
Используй std::vector<int> k;

Сообщение от Ghost111

Polynom operator = (Polynom object) //перегрузка оператора "="

оператор написан криво. И вообще, это не нужно, дефолтный оператор всё сделает правильно

Сообщение от Ghost111

Можно ли его как-то переделать, чтобы без std

нет, это не нужно переделывать. Забудь про "using namespace std", ты ж не в детском саду уже

[Ghost111]

Ну ладно, будем пробовать реализовывать тогда