überladen von Operatoren

Reptile100

Hallo,

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

queer_boy

normalerweise implementiert man operator+= (als memberfunktion) und operator+ als freie (idR friend) funktion so:

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.

Xantus

Reptile100 schrieb:

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

Reptile100

Danke für eure schnellen Antworten.

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?

LordJaxom

Die Fehler kommen vermutlich vom fehlenden Rückgabetyp bei der Definition der Methode operator+. Da fehlt ein "Polynom " am Anfang der Zeile.

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.

Reptile100

Ich hab jetzt ein "Polynom" davor gesetzt.

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?

[quote="Reptile100"]Ich hab jetzt ein "Polynom" davor gesetzt.

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

Reptile100

Danke für eure Hilfe. Jetzt hab ich keinen Fehler mehr.

Gruß
Reptile100

*D*Evil

Hast du für Polynom keinen copy-ctor? Dann kannst du dir die Zuweisung sparen ... wenn dann noch operator+= korrekt implementiert ist, geht auch das:

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

queer_boy schrieb:

a += b;

Meintest natürlich tmp+= b

queer_boy

jaja, man sollte sich alles zweimal durchlesen ^^'
aber kein problem, ich geb's weiter:

(D)Evil schrieb:

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

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

camper

Nebenbei verträgt sich Operatorüberladung kaum mit polymorphen Basisklassen - Vererbung+Operatorüberladung ist fast immer ein Fehler. Natürlich gibt es auch Ausnahmen, wie die Standardstreams, aber die sind in mehrfacher Hinsicht ein Sonderfall.
Die optimale Implementierung für operator+, wenn dieser auf += basieren soll und die Signatur so vorgeschrieben ist, lautet im Übrigen:

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.