2

我不得不把这个程序交给家庭作业，它已经被评分了，得到了 80 分。我要回去清理一些代码。我的代码底部是重载函数= operator。出于某种原因，cout我注释掉的语句导致我的程序崩溃，但是，当我删除 //s 时，程序运行正常......

有人知道为什么会这样吗？

#include <iostream>
using namespace std;

class Poly
{
    private:
        int order; //order of the polynomial
        int * coeff;//pointer to array of coeff on the heap

    public:
        Poly();
        Poly(int Order);
        Poly(int Order, int * Coeff);
        ~Poly(){/*cout << "Deconstructor\n";*/};
        Poly(const Poly &rhs);

        //accessors &  mutators
        void set();
        void set(int * Coeff, int Order);
        void Print2();
        void PtrReset();
        int getorder(){return order;};
        int * get()const{return coeff;};

        //Overloaded Operators
        Poly operator+(const Poly &rhs);
        Poly operator-(const Poly &rhs);
        Poly operator*(const int scale);
        Poly operator=(const Poly &rhs);
        Poly operator*(const Poly &rhs);
        const int& operator[](int I)const;
        int& operator[](int I);
        bool operator==(const Poly &rhs);
        int operator( )(int X);
        friend ostream & operator<<(ostream & Out, const Poly &rhs);
        friend istream & operator >>(istream & In, Poly &rhs);
};

int main()
{
    int coeff1[ ] =  {-19,1,-12,3,1};
    int coeff2[ ] = {-19,1,-6,0,0,7,0,-1};

    bool flag;

    Poly P1(4, coeff1);
    Poly P2(7, coeff2);
    Poly P3;
    P3 = P1 + P2;
    cout << "P1 + P2: " << P3;
    P3 = P2 - P1;
    cout << "P2 - P1: " << P3;
    P3 = P1 * 10;
    cout << "P1 * 10: " << P3;
    P3 = P1 * P2;
    cout << "P1 * P2: " << P3;
    flag = (P2 == P2);
    cout << "P2 and P2 are ";
    if (flag)
        cout << "Equal\n";
    else
        cout << "Not Equal\n";
    flag = (P1 == P2);
    cout << "P1 and P2 are ";
    if (flag)
        cout << "Equal\n";
    else
        cout << "Not Equal\n";
    cout << "P1(4) = " << P1(4) << endl;
    cout << "P1: ";
    cout << P1;
    cout << "P2: ";
    cout << P2;
    P1[3] = P2[5];
    cout << "P1(after P1[3] = P2[5]): " << P1;
    P1[3] = P2[4];
    cout << "P1(after P1[3] = P2[4]): " << P1;

    return 0;
}

Poly::Poly()
{
    coeff = (int *) malloc(sizeof(int));
    order = 0;
    *coeff = 0;
    //cout << "Default Constructor\n";
}

Poly::Poly(int Order)
{
    order = Order;
    coeff = new int[order+1];
    for(int i(0); i <= order; i++)
        coeff[i] = 0;
}

Poly::Poly(int Order, int * Coeff)
{
    order = Order;
    coeff = Coeff;
}

Poly::Poly(const Poly &rhs)
{
    order = rhs.order;
    int *temp;
    temp = (int *) malloc((rhs.order + 1) * sizeof(int));
    coeff = (int *) malloc((order + 1) * sizeof(int));
    temp = rhs.coeff;
    for(int i(0); i <= order; i++)
    {
        *coeff = *temp;
        coeff++;
        temp++;
    }
    PtrReset();
}


void Poly::set()
{
    coeff = (int *) malloc((order + 1) * sizeof(int));
    if(coeff == NULL)
    {
        cout << "Error allocating memory!\n";
        exit(1);
    }
    cout << "Begin entering with the non x value, then x^1 coefficient, x^2, etc:\n";
    for(int i(0); i <= order; i++)
    {
        cout << (i+1) << ". ";
        cin >> * coeff;
        coeff++;
    }   
    PtrReset();
}

void Poly::set(int * Coeff, int Order)
{
    order = Order;
    for(int i(0); i <= order; i++)
    {
        *coeff = *Coeff;
        coeff++;
        Coeff++;
    }
    PtrReset();
}


void Poly::Print2()
{
    for(int i(0); i <= order; i++)
    {
        cout << * coeff << " ";
        coeff++;
    }
    cout << endl;
    PtrReset();
}

void Poly::PtrReset()
{
    for(int i(0); i <= order; i++)
        coeff--;
}

Poly Poly::operator+(const Poly &rhs)
{
    int neworder;
    int * newpointer;
    int * temp;
    temp = rhs.coeff;
    if(order >= rhs.order)
    {
        neworder = order;
        newpointer = (int *) malloc((neworder+1) * sizeof(int));
        for(int i(0); i <= rhs.order; i++)
        {
            *newpointer = *coeff + *temp;
            newpointer++;
            coeff++;
            temp++;
        }
        for(int i(0); i < (order - rhs.order); i++)
        {
            *newpointer = *coeff;
            newpointer++;
            coeff++;
        }       
    }
    else
    {
        neworder = rhs.order;
        newpointer = (int *) malloc((neworder+1) * sizeof(int));
        for(int i(0); i <= order; i++)
        {
            *newpointer = *coeff + *temp;
            newpointer++;
            coeff++;
            temp++;
        }
        for(int i(0); i < (rhs.order - order); i++)
        {
            *newpointer = *temp;
            newpointer++;
            temp++;
        }       
    }
    PtrReset();
    for(int i(0); i <= neworder; i++)
        newpointer--;

    return Poly(neworder, newpointer);
}

Poly Poly::operator-(const Poly &rhs)
{
    int neworder;
    int * newpointer;
    int * temp;
    temp = rhs.coeff;
    if(order >= rhs.order)
    {
        neworder = order;
        newpointer = (int *) malloc((neworder+1) * sizeof(int));
        for(int i(0); i <= rhs.order; i++)
        {
            *newpointer = *coeff - *temp;
            newpointer++;
            coeff++;
            temp++;
        }
        for(int i(0); i < (order - rhs.order); i++)
        {
            *newpointer = *coeff;
            newpointer++;
            coeff++;
        }       
    }
    else
    {
        neworder = rhs.order;
        newpointer = (int *) malloc((neworder+1) * sizeof(int));
        for(int i(0); i <= order; i++)
        {
            *newpointer = *coeff - *temp;
            newpointer++;
            coeff++;
            temp++;
        }
        for(int i(0); i < (rhs.order - order); i++)
        {
            *newpointer = 0 - *temp;
            newpointer++;
            temp++;
        }       
    }
    PtrReset();
    for(int i(0); i <= neworder; i++)
        newpointer--;

    return Poly(neworder, newpointer);
}

Poly Poly::operator*(const int scale)
{
    int neworder = order;
    int * temp = new int[order+1];

    for(int i(0); i <= order; i++)
        temp[i] = scale * coeff[i];

    return Poly(neworder, temp);
}
Poly Poly::operator*(const Poly &rhs)
{
    int neworder = order + rhs.order;
    int * newcoeff;
    int * temp;
    temp = rhs.coeff;
    newcoeff = (int *) malloc((neworder + 1) * sizeof(int));
    for(int i(0); i <= neworder; i++)
    {
        *newcoeff = 0;
        newcoeff++;
    }
    for(int i(0); i <= neworder; i++)
        newcoeff--;

    for(int i(0); i <= order; i++)
    {
        for(int j(0); j <= rhs.order; j++)
        {
            *newcoeff += (*coeff * *temp);
            newcoeff++;
            temp++;
        }
        coeff++;
        for(int j(0); j < rhs.order; j++)
            newcoeff--;
        for(int j(0); j <= rhs.order; j++)
            temp--;
    }
    for(int i(0); i <= (neworder - rhs.order); i++)
        newcoeff--;
    PtrReset();

    return Poly(neworder, newcoeff);
}
bool Poly::operator==(const Poly &rhs)
{
    bool test = true;
    int count = 0;
    while(test && (count <= order))
    {
        if(order != rhs.order)
            test = false;
        else if(coeff[count] != rhs.coeff[count])
            test = false;
        count++;
    }


    return test;
}

int Poly::operator()(int X)
{
    int * temp;
    int * temp2;
    temp = (int *) malloc((order + 1) * sizeof(int));
    temp2 = temp;
    for(int i(0); i < order; i++)
        coeff++;
    for(int i(0); i <= order; i++)
    {
        *temp = *coeff;
        temp++;
        coeff--;
    }
    coeff++;
    for(int i(0); i < order; i++)
        temp--;
    for(int i(0); i < order; i++)
    {
        *temp += (X * *temp2);
        temp++;
        *temp2++;
    }
    return *temp2;
}

ostream &operator <<(ostream& out, const Poly &source)
{
    for(int i(source.order); i >= 0; i--)
    {
        if(i == 1)
        {
            if(i == source.order)
                if(source.coeff[i] == 1)
                    out << "X";
                else if(source.coeff[i] == -1)
                    out << "-X";
                else
                    out << source.coeff[i] << "X";
            else if(source.coeff[i] == 1)
                out << " + " << "X";
            else if(source.coeff[i] == -1)
                out << " - " << "X";
            else if(source.coeff[i] > 0)
                out << " + " << source.coeff[i] << "X";
            else if(source.coeff[i] < 0)
                out << " - " << abs(source.coeff[i]) << "X";
        }

        else if(i > 1)
        {   
            if(i == source.order)
                if(source.coeff[i] == 1)
                    out << "X^" << i;
                else if(source.coeff[i] == -1)
                    out << "-X^" << i;
                else
                    out << source.coeff[i] << "X^" << i;
            else if(source.coeff[i] == 1)
                out << " + " << "X^" << i;
            else if(source.coeff[i] == -1)
                out << " - " << "X^" << i;
            else if(source.coeff[i] > 1)
                out << " + " << source.coeff[i] << "X^" << i;
            else if(source.coeff[i] < -1)
                out << " - " << abs(source.coeff[i]) << "X^" << i;
        }
        else
        {
            if(source.coeff[i] > 0)
                out << " + " << source.coeff[i];
            else if(source.coeff[i] < 0)
                out << " - " << abs(source.coeff[i]);
        }
    }
    out << endl;

    return out;
} 
int& Poly::operator[](int I)
{
    if(I > (order + 1) || I < 0)
    {
        cout << "Request to access outside Poly boundaries!" << endl;
        exit(1);
    }
    return coeff[I];
}
const int& Poly::operator[](int I) const
{
    if(I > (order + 1) || I < 0)
    {
        cout << "Request to access outside Poly boundaries!" << endl;
        exit(1);
    }

    return coeff[I];
}
Poly Poly::operator=(const Poly &rhs)
{
    order = rhs.order;

    //cout << "new order = " << rhs.order << endl;  ******HERE*******

    for(int i(0); i <= rhs.order; i++)
        coeff[i] = rhs.coeff[i];
    return Poly(order, coeff);
}
4

2 回答 2

2

Assignment operator作为成员应该返回对this If it is not going to then 的引用，那么您可能不应该使用assignment operator.

除了注释行之外，赋值运算符的另一个直接问题是，当您手动构建一个新的 coeff 数组时，您会泄漏更多内存。您还返回了第三个对象，这不是任何使用该对象的人所assignment operator期望的，这完全是危险的

Poly& Poly::operator=(const Poly &rhs)
{
    order = rhs.order;
    // you should probably initialize coeff here

    //cout << "new order = " << rhs.order << endl;  ******HERE*******

    for(int i(0); i <= rhs.order; i++)
        coeff[i] = rhs.coeff[i];

    //This is wrong return this. see signature fix above
    //return Poly(order, coeff);
    return *this;

}

其次，不要手动处理您在代数运算符中所做的任何事情，而是首先复制构造，然后修改该对象。

例如乘法： 

//member multiplication which still sucks because we are going to copy construct again to return..
Poly Poly::operator*(const int scale)
{
    Poly result(*this);
    // now manipulate your new object and leave THIS this alone

    for(int i(0); i <= result.order; i++)
        result.coeff[i] *= scale;

    return result;
}

*=operator如果你把它设为非成员函数，然后创建一个成员函数，然后你可以像 Ben 和我所设想的那样做，那就更好了

Poly operator*(Poly result, int scale)
{
    return (result *= scale);
}

我看到的主要问题是您正在疯狂地泄漏内存，并且从未对其进行任何边界保护。

于 2013-07-31T23:04:40.790 回答
0

当我看到这一点时，它背后的常见问题是双重释放/删除。您可能会在同一个指针上调用 free 两次（或无效指针），这会导致一切变得奇怪，并且几乎随时可能发生崩溃。

当您混合使用 malloc 和 new 时，也会发生这种情况。将所有内容切换为新的，看看您是否仍然遇到崩溃。

于 2013-07-31T23:11:02.647 回答