Mal wieder Überladung von Operatoren

elysis

In der Theorie sind überladene Operatoren ja 'ne tolle Sache. Jetzt, wo ich am Apfelmännchen-Fraktal rumrechne, sind die überladenen Operatoren für komplexe Zahlen schwer wegzudenken aber ich habe ein grundlegendes Problem.

class CComplex  
{
public:
    double real;
    double imag;

// Operatoren ...
// Methoden ...
}

Wenn ich das mache :

CComplex &CComplex::operator-(const CComplex &zahl)
{
        CComplex pZahl;
    pZahl->imag=imag-zahl.imag;
    pZahl->real=real-zahl.real;
    return *pZahl;
}

dann kriege ich irgendwann einen Speicherüberlauf, weil anscheinend immer neue Objekte erzeugt, aber nie zerstört werden.

Wenn ich das mache :

CComplex &CComplex::operator*(const CComplex &zahl)
{
    CComplex pt2;
    //(a+bi)*(c+di)=(ac+adi+bci-bd)=ac-bd+(ad+bc)i
    pt2.real=(real*zahl.real)-(imag*zahl.imag);
    pt2.imag=(real*zahl.imag)+(imag*zahl.real);
    return pt2;
}

// und weiter :

CComplex &CComplex::operator+(const CComplex &zahl)
{
    CComplex pt3;
    pt3.imag=imag+zahl.imag;
    pt3.real=real+zahl.real;
    return pt3;
}

CComplex &CComplex::operator=(const CComplex &zahl)
{
    imag=zahl.imag;
    real=zahl.real;
    return *this;
}

dann wird bei einer Rechnung wie : z2=(z1*z1)+c mit z1,z2,c vom Typ CComplex
zuerst die Multiplikation gerechnet und in der Addition ist bereits das Ergebnis der Multiplikation verloren. Irgendetwas grundlegendes mache ich anscheinend falsch. Aber was - hat jemand 'ne Idee ?

elysis

PS : Im ersten Fall ist ein Fehler - das Objekt wird natürlich so erzeugt :

CComplex pZahl= new CComplex;

Du gibst Referenzen auf lokale Objekte zurück.

elysis

Autsch! - Wie blöd. Und dafür schreib' ich hier 'nen halben Roman !
(Anfänger-Pech...) Dein Hinweis war dafür um so kürzer, aber wichtig, den jetzt funktioniert's.
Danke