2

したがって、すでに定義した+演算子を利用しようとする方法で、+=演算子をオーバーロードしています。つまり、その多項式+多項式は新しい多項式を返します。したがって、私の+ =関数は、基本的に、LHSを* this、RHSを* this + B（Bは関数へのconst参照によって渡される多項式オブジェクト）としてこの+関数を呼び出そうとします。エラーが発生します。私はこれでどこが間違っているのですか？ 

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <cmath>

using namespace std;
void line(int lines);


class Polynomial
{
    private:
        int degree;
        double* coeffs;
    public:
        //constructors
        Polynomial() {degree=0;coeffs=new double[1];}
        Polynomial(int deg) {degree=deg;coeffs=new double[deg+1];}
        Polynomial(const Polynomial& A);

        //mutators
        void GetCoeffs(istream& in);
        void EditCoeff(int deg);
        void ResetCoeffs();
        int Coeff(int deg);
        void Randomize(int max);

        //accessors
        void Show(ostream& out);
        int Degree() {return degree;}

        //operators
        Polynomial operator+(const Polynomial& B); //Polynomial + Polynomial
        friend Polynomial operator +(double c, Polynomial& A); //c + Polynomial
        Polynomial operator +(double c); //Polynomial + c
        void operator +=(const Polynomial& B); //Polynomial+=Polynomial
        void operator =(Polynomial& A);
        Polynomial operator*(int k);
        Polynomial operator*(Polynomial& A);

};



int main()
{
    Polynomial A(5);
    A.Randomize(4);
    A.Show(cout);
    line(2);
    Polynomial B=A+8;
    B.Show(cout);




    return 0;
}

Polynomial Polynomial::operator*(int k)
{
    Polynomial C(degree);
    C=*this;
    for (int i=degree; i>=0; i--)
        C.coeffs[i]*=k;
    return C;
}

Polynomial operator +(double c, Polynomial& A)
{
    Polynomial C=A;
    C.coeffs[0]+=c;
    return C;
}
Polynomial Polynomial::operator +(double c)
{
    Polynomial C=*this;
    C.coeffs[0]+=c;
    return C;
}

void Polynomial::Randomize(int max)
{
    for (int i=degree; i>=0; i--)
    {
        coeffs[i]=rand()%(max+1) + 1;
        if ((rand()%(101) + 1)%2 == 0)
            coeffs[i]*=-1;
    }
}

void Polynomial::operator =(Polynomial& A)
{
    if (degree==A.degree)
    {
        for (int i=degree; i>=0; i--)
        {
            coeffs[i]=A.coeffs[i];
        }
    }
}

Polynomial Polynomial::operator+(const Polynomial& B)
{

    if (degree>=B.degree)
    {
        Polynomial C(degree);
        C=*this;

        for (int i=B.degree; i>=0; i--)
        {
            C.coeffs[i]=coeffs[i]+B.coeffs[i];
        }
        return C;
    }
    else
    {
        Polynomial C=B;

        for (int i=degree; i>=0; i--)
        {
            C.coeffs[i]=coeffs[i]+B.coeffs[i];
        }
        return C;

    }

}

void Polynomial::operator+=(const Polynomial& B)
{
    *this = (*this + B);
}

int Polynomial::Coeff(int deg)
{
    return coeffs[deg];
}

void line(int lines)
{
    for (int i=0; i<lines; i++)
        cout << endl;
}

void Polynomial::GetCoeffs(istream& in)
{
    for (int i=degree; i>=0; i--)
    {
        in >> coeffs[i];
    }
    in.ignore();
}

void Polynomial::Show(ostream& out)
{

    if (coeffs[degree]>0)
                cout << "   ";
    for (int i=degree; i>=0; i--)
    {


        if (coeffs[i]>=0)
        {
            if (i!=degree)
                out << " + ";
            out << coeffs[i];


        }
        else
        {
            if (coeffs[i]<0)
                out << " - ";
                out << 0-coeffs[i];
        }
        if (i>1)
            out << "x^" << i;
        else if (i==1)
            out << "x";

    }
}

Polynomial::Polynomial(const Polynomial& A)
{
    coeffs=new double[A.degree+1];
    degree=A.degree;
    for (int i=A.degree; i>=0; i--)
    {
        coeffs[i]=A.coeffs[i];

    }

}

Polynomial Polynomial::operator*(Polynomial& A)
{
    int deg=A.degree+degree;
    Polynomial P(deg);

    for (int i=deg; i>=0; i--)
        P.coeffs[i]=0;



    for (int i=deg; i>=0; i--)
    {
        for (int j=A.degree; j>=0; j--)
        {
            P.coeffs[i+j]+=coeffs[i]*A.coeffs[j];
        }
    }

    return P;


}
4

3 に答える 3

3

問題はそれ*this + Bが一時的なものであり、一時的なオブジェクトを非const参照にバインドできないことです。

もちろん、割り当てのRHSができない理由はありませんconst。試す：

void operator=(/* HERE */ const Polynomial& A);

他のオペレーターのほとんどは、本来あるconstべき場所を使用していません。例えば：

Polynomial operator+(const Polynomial& B) /* HERE */ const; //Polynomial + Polynomial
friend Polynomial operator +(double c, /* HERE */ const Polynomial& A); //c + Polynomial

代入演算子のみが非constメンバーである必要があり、それらはconst正しいオペランドを受け入れる必要があります。新しいオブジェクトを作成する通常の二項演算子constは、左右両方のオペランドである必要があります。

于 2012-10-16T02:55:25.357 に答える
1

多くの場合、それは逆に行われます。人々は、すでに定義されている+ =演算子（メンバー）を利用する二項+演算子（通常は非メンバー）を作成します。

于 2012-10-16T02:34:24.930 に答える
1

私はこれでどこが間違っているのですか？

  • std::vector生のポインタの代わりに使用する必要があります。
  • あなたは三つのルールに違反しました。
  • operator+=メンバーと無料を作成する規則に従わなかったoperator+。

これを試して：

// UNTESTED
class Polynomial
{
    private:
        std::vector<double> coeffs;

    public:
        //constructors
        Polynomial() : coeffs(1) {}
        Polynomial(int deg) : coeffs(deg+1) {}
        // Don't need copy constructor
        // Don't need destructor
        // Don't need assignment operator

        ...
        int Degree() {return coeffs.size()-1;}

        //operators
        Polynomial& operator+=(const Polynomial& B) {
            if(Degree() < B.Degree())
              coeffs.resize(B.Degree()+1);
            for(int i = 0; i <= B.Degree(); ++i)
              coeffs[i] += B.coeffs[i];
            return *this;
        }    
};

Polynomial operator+(Polynomial A, const Polynomial& B) {
  return A += B;
}
于 2012-10-16T02:55:14.897 に答える