ich hab ein Problem folgenden Quelltext zu verstehen:

class Polynom
{
public:
     Polynom();
     virtual ~Polynom();

     Polynom& operator=(Polynom const &P);
     Polynom& operator*=(Polynom const &P);
     Polynom operator+(Polynom const &P) const;

private:
     double* a;
     int gr;
};

Polynom::operator+(const Polynom &P) const
{
   Polynom r;
   r= *this;
   r+=P;

   return r;
}

Der Compiler findet frei Fehler.

Was macht der *this Zeiger? Ist die " r+=P " überhaupt so machbar?

Gruß
Reptile100

Foo operator+ (Foo const& a, Foo const& b)
{
   Foo tmp(a);
   a += b;
   return tmp;
}

die implementation von operator+= ist natürlich dann jeweils klassenspezifisch.

wenn du genauer sagst, was du nicht verstehst, kann man dir sicher auch besser weiterhelfen.

ich hab ein Problem folgenden Quelltext zu verstehen:

Zu sehen ist eine Klasse mit virtuellem Destruktur (für spätere Ableitungen gebraucht) und die Überladung für 3 Operatoren.
Die kannst zu dann so anwenden:

Polynom p1, p2, p3;
p1 = p2; // entspricht p1.operator=(p2);
p1 *= p3; // entspricht p1.operator(p3);
p2 = p1 + p3; // entspricht p2 = p1.operator(p3);

relativ simple, nicht?

Reptile100 schrieb:

Der Compiler findet frei Fehler.

und du bist dir natürlich zu fein uns diese mitzuteilen?

Reptile100 schrieb:

Was macht der *this Zeiger? Ist die " r+=P " überhaupt so machbar?

Polynom::operator+(const Polynom &P) const
{
   Polynom r;
   r= *this;
   r+=P;

   return r;
}

this ist der Zeiger auf das Object, *this der dereferenzierte Zeiger und somit das Objekt selbst.

ich würde dir empfehlen der Methode auch einen Rückgabewert zu geben

Fehler 1: error C2556: int_thiscall Polynom::operator +(const class Polynom &) const : Überladene Funktion unterscheidet sich nur hinsichtlich des Rückgabetyps von class Polynom_thiscall Polynom::operator +(const class Polynom &)const

Fehler 2: error C2371: + : Neudefinition; unterschiedliche Basistypen

Fehler 3: error C2676: Binaerer Operator += : class Polynom definiert diesen Operator oder eine Konvertierung in einen für den vordefinierten Operator geeigneten Typ nicht.

Ich verstehe noch nicht wozu der this Zeiger hier gebraucht wird. Warum kann nicht gleich mit r+=P weitergemacht werden?

Ich verstehe noch nicht wozu der this Zeiger hier gebraucht wird. Warum kann nicht gleich mit r+=P weitergemacht werden?

Weil operator+ doch das linke und das rechte Element addiert. Und das linke Element ist nunmal this. Ohne die Initialisierung (oder hier: Zuweisung, ist eigentlich weniger elegant) wäre r leer.

Polynom::Polynom operator+(const Polynom &P)const
{
    Polynom r;
    r=*this;
    r+=P;
    return r;
}

jetzt hab ich folgende Fehler:

Error C2143: Fehlendes ; vor +
Error C2350: Polynom::Polynom::Polynom ist kein statisches Element
fatal error C1004: Unerwartetes Dateiende

Damit ich das mit dem This Zeiger auch richtig verstehe:
würde r ohne die this Zuweisung wie eine normale Variable behandelt werden?

Polynom::Polynom operator+(const Polynom &P)const
{
    Polynom r;
    r=*this;
    r+=P;
    return r;
}

Der Rückgabetyp gehört vor den Klassennamen.

Polynom Polynom::operator+(const Polynom &P)const
{
    Polynom r;
    r=*this;
    r+=P;
    return r;
}

gruss

Gruß
Reptile100

const Polynom::Polynom operator+(Polynom const & rhs) const
{
    Polynom tmp(*this);
    return tmp += rhs;
}

a += b;

Meintest natürlich tmp+= b

(D)Evil schrieb:

const Polynom::Polynom operator+(Polynom const & rhs) const

du meintest natürlich const Polynom Polynom::operator+ . (oder auch gleich ohne const )

Polynom Polynom::Polynom operator+(Polynom const & rhs) const
{
    Polynom tmp(*this);
    tmp += rhs;
    return tmp;
}

denkbar ist noch

Polynom operator+(Polynom lhs, Polynom const & rhs)
{
    lhs += rhs;
    return lhs;
}

jede andere auf += basierende Form führt zwangsweise zu zusätzlichen nicht (per 12.8/15) eliminierbaren Kopien.