Complex* Complex::addComplex(Complex* dest, const Complex* c1, const Complex* c2)
 {
  dest = new Complex(*c1);

  return dest;
 }

Wenn ich die so benutze, dann zeigt c nach dem Funktionsaufruf trotzdem auf NULL:

Wo ist hier mein Denkfehler?

const Complex operator+(const Complex& lhs, const Complex& rhs)
	{
		Complex* c = NULL;
		Complex::addComplex(c, &lhs, &rhs);
		return (*c);
	}

Hier zeigt c dann auf die in der Funktion allozierte Speicheradresse:

const Complex operator+(const Complex& lhs, const Complex& rhs)
	{
		Complex* c = NULL;
		c = Complex::addComplex(c, &lhs, &rhs);
		return (*c);
	}

Ich hoffe das war jetzt nicht zu prezise und kurz.

Vielen Dank für die kommende Hilfe.

const Complex operator+(const Complex& lhs, const Complex& rhs)
{
    Complex* c = NULL;
    return (*Complex::addComplex(c, lhs, rhs));
}

Oder wie hätten Sie es gerne? Dein Problem ist einfach, das du einen Complex** übergeben müsstest, um den dann dereferenzieren zu können und dann einen Wert zuweisen zu können...

Danke im Voraus für die Antwort!

anchelito

param-by-val

gibt es genau einmal bei google (o: Bald zweimal wenn Google den Thread hier gefunden hat.

Wenn ich

Complex*& dest

in Worte ausdrücke heißt das ja

dest ist die Referenz auf eine Pointer-Adresse von Complex. Also quasi wie du schon sagtest, der Pointer auf einen Pointer.

http://cplus.kompf.de/tutor.html#i13480046

Complex& Complex::add(Complex& dest,const Complex& c1,const Complex& c2)
{
  dest=c1;

  return dest;
}

Complex operator+(const Complex& lhs,const Complex& rhs)
{
  Complex c;
  Complex::add(c,lhs,rhs);
  return c;
}

CStoll: Sollte operator+ nicht lieber ein const -Objekt zurückgeben?

Stimmt, sollte er

Und der Code von add erfüllt ja nun überhaupt keinen Sinn.

Hat der ursprüngliche Code auch nicht (abgesehen von "Speicherlecks produzieren")

Das wäre der Code der dann Sinn macht. Grundsätzlich geht es in der Aufgabe um die Addition, Subtraktion, Multiplikation und Division von komplexen Zahlen.

Wieso habe ich überhaupt diese Variante probiert?

Also ich habe bei DirectX gesehen das es z.b. solche Funktionen gibt:

D3DXINLINE D3DXVECTOR3* D3DXVec3Maximize
    ( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )

Ich finde das Praktisch, da ich mich entscheiden kann ob ich den Rückgabetyp nehme oder mein Objekt im 1. Parameter verändern lasse. Beides hat so seine Vorteile.

PS: Für den Umgang mit komplexen Zahlen gibt es die Klasse std::complex<>

Joah das mit std::complex hab ich auch schon gesehen, aber ich denke da dies ja die eigentliche Aufgabe der Übung ist, kann ich die nicht benutzen. Naja meine implementierung ist zum Glück auch soweit fertig.

Danke für eure hilfe nochmal!