Задача проекта полиномиального класса с делением и деструктором C ++

Question

Это проект для моего класса объектно-ориентированного программирования. Мне нужно ввести следующее: перегрузка + для суммирования двух полиномов, перегрузка * для умножения многочлена на скаляр или умножение его на другой многочлен, перегрузка [] для возврата коэффициента в указанной c позиции, метод добавления, удаления коэффициент и вычисляющий полином в определенной точке (f (x)).

1. Все работает, кроме деструктора. Деструктор, который следует использовать (delete [] coef) полинома, сломается (Heap Coruption), если я использую cout << A + B, и я не знаю почему. Сейчас я использую обходной путь, но он не удалит coef [0]. Это точка, где она ломается. Если вы можете помочь мне как-нибудь, я буду благодарен. Вы можете понять, что вызвало это? </p>

2. Мне нужен еще один перегруженный оператор, "/". Следует сделать деление между двумя полиномами, и я не знаю, как это реализовать. Я пытался найти его, но я не мог понять ни одного алгоритма. Любой совет или объяснение алгоритма было бы замечательно, потому что я действительно не знаю, с чего начать, и мне нужно закончить его до завтрашнего утра.

3.Если у вас есть какие-либо советы по кодированию или эффективности, также будьте хороши (требование проекта: не используйте STL).

Спасибо!

Polynomial.h:

#pragma once

#include <iostream>

using std::cout;
using std::cin;
using std::endl;
using std::ostream;
using std::istream;

class Polynomial
{
    unsigned int deg;       
    double *coef;           

public:
    Polynomial() : deg(1), coef(new double[1]) {}                   

Polynomial(double [], int);                                     

Polynomial(Polynomial&);                                        

Polynomial& operator = (const Polynomial&);                     

~Polynomial();                                                  

friend ostream &operator <<(ostream&, const Polynomial&);       

friend istream &operator >>(istream&, Polynomial&);             

Polynomial operator + (const Polynomial) ;

double operator[] (unsigned int) const;

Polynomial operator * (int) const;

Polynomial operator * (const Polynomial obj) const;

unsigned int getDeg() { return this->deg; };                    

double eval(int);                                               

void addCoef(double, int);                                      

void delCoef(int);                                              

};

inline Polynomial::Polynomial(double coefficients[], int number) : deg(number), coef(new double[number])
{
    for (int i = 0; i < deg; i++) {
        coef[i] = coefficients[i];
    }
}

inline Polynomial::Polynomial(Polynomial &ob) {
    this->deg = ob.deg;
    this->coef = new double[deg];
    for (int i = 0; i <= deg; i++)
    {
        this->coef[i] = ob.coef[i];
    }
}

inline Polynomial::~Polynomial() {
    for (int i = this->deg; i > 0; i--)
        this->delCoef(i);
    this->coef[0] = 0;       //If i write it like this delete [] coef; it breaks.
    this->deg = 0;           //with HeapCoruption detected
}

Полином. cpp:

Polynomial& Polynomial::operator = (const Polynomial& obj)
{
if (this != &obj)       //Testing to avoid situations like A = A;
{
    this->deg = obj.deg;
    for (int i = 0; i <= obj.deg; i++)
        this->coef[i] = obj.coef[i];
}
return *this;
}

istream& operator >> (istream& in, Polynomial& obj) 
{ 
in >> obj.deg;
cout << endl;
obj.coef = new double[obj.deg];
for (int i = 0; i <= obj.deg; i++)
{
    in >> obj.coef[i];
}
return in;
}

ostream& operator << (ostream& out, const Polynomial& obj) 
{
out << obj.deg << endl;
for (int i = 0; i <= obj.deg; i++)
{   
    if (obj.coef[i] != 0)
    {
        if (obj.coef[i] < 0)
            out << '(' << obj.coef[i] << ')';
        else
            out << obj.coef[i];
        if (i > 1)
            out << "*x^" << i;
        if (i == 1)
            out << "*x";
        if (i != obj.deg)
            out << " + ";
    }
}
out << endl <<endl;
return out;
}

Polynomial Polynomial::operator+ (const Polynomial obj)
{
Polynomial aux;

if (obj.deg >= deg)
{
    aux.deg = obj.deg;
    aux.coef = new double[obj.deg];

    for (int i = 0; i <= deg; i++)
        aux.coef[i] = obj.coef[i] + coef[i];

    for (int i = deg + 1; i <= obj.deg; i++)
        aux.coef[i] = obj.coef[i];
}
else // obj.deg < this->deg
{
    aux.deg = deg;
    aux.coef = new double[deg];

    for (int i = 0; i <= obj.deg; i++)
    {
        aux.coef[i] = obj.coef[i] + coef[i];
    }

    for (int i = obj.deg + 1; i <= deg; i++)
    {
        aux.coef[i] = coef[i];
    }
}

return aux;
}

double Polynomial::operator[] (unsigned int pos) const
{
if (pos > this->deg) {
    throw std::out_of_range("Index bigger than polynomial length");
}
return this->coef[pos];
}

Polynomial Polynomial::operator * (const int scalar) const
{
Polynomial aux;
aux.deg = this->deg;
aux.coef = new double[aux.deg];
for (int i = 0; i <= aux.deg; i++)
    aux.coef[i] = this->coef[i] * scalar;
return aux;
}

Polynomial Polynomial::operator * (const Polynomial obj) const
{
Polynomial aux;
aux.deg = obj.deg + this->deg;
aux.coef = new double[aux.getDeg()];
for (int i = 0; i <= aux.getDeg(); i++)
    aux.addCoef(0, i);

for (int i = 0; i <= this->deg; i++)
    for (int j = 0; j <= obj.deg; j++)
        aux.coef[i+j] += (this->coef[i]) * obj.coef[j];

return aux;
}

double Polynomial::eval(int x) {
double sum = 0;
for (int i = 0; i <= this->deg; i++)
{
    if (i == 0)
        sum += this->coef[0];
    else
    {
        int aux = i;
        int xaux = x;
        aux--;
        while (aux != 0)
        {
            xaux *= x;
            aux--;
        }
        sum += this->coef[i] * xaux;
    }
}
return sum;
}

void Polynomial::addCoef(double NewCoef, int pos)
{
if (pos < 0)
    return;

if (pos > this->deg)
{
    double *newCoef = new double[pos];
    for (int i = 0; i <= this->deg; i++)
        newCoef[i] = this->coef[i];
    for (int i = this->deg + 1; i < pos; i++)
        newCoef[i] = 0;
    newCoef[pos] = NewCoef;
    this->coef = newCoef;
    this->deg = pos;
    return;
}
else
{
    this->coef[pos] = NewCoef;
}
}

void Polynomial::delCoef(int pos) 
{
if (pos > this->deg || pos < 0 )
    return;
if (pos == this->deg)
{
    this->coef[pos] = 0;
    int degNoua = pos - 1;
    while (this->coef[pos] == 0 && pos != 0)
        pos--;
    if (pos == 0 && this->coef[pos] == 0)
    {
        delete this->coef;
        this->deg = 0;
    }
    else
    {
        this->deg = pos;
        double *aux = new double[pos];
        for (int i = 0; i <= pos; i++)
            aux[i] = this->coef[i];
        this->coef = aux;
    }
}
else
{
    this->coef[pos] = 0;
}
}