3. Denkfehler bei Pointerübergabe

Denkfehler bei Pointerübergabe

  • A

    Hallo ich habe folgende Funktion:

    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.

    0
  • *
     

    Complex* Complex::addComplex(Complex*& dest, Complex const& c1, Complex const&)
{
  dest = new Complex(c1);
  return dest;
}

    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...

    0
  • A

    Funktioniert! Super! Danke!

    0
  • A

    Aber wieso funktioniert airscape's Variante nicht???
    hat es damit zu tun, dass nur eine Kopie des Pointers erstellt wird, welche nach Beenden der Funktion verloren geht?? Daher die Referenz auf einen Complex-Pointer??

    Danke im Voraus für die Antwort!

    anchelito

    0
  • *

    Guck dir mal param-by-val an 😛

    0
  • A

    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.

    0
  • A

    hier ist was ich gefunden habe ... schlussendlich gehts hier wohl wirklich um die Kopierkonstruktoren:

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

    0
  • C

    Wieso übergibst du überhaupt Pointer? Damit holst du dir nur ein Speicherleck, weil nach Ende der operator+ niemand mehr die Adresse des neu angelegten Complex-Objektes kennt.

    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;
}
    0
  • K

    CStoll: Sollte operator+ nicht lieber ein const -Objekt zurückgeben? Und der Code von add erfüllt ja nun überhaupt keinen Sinn. 😉

    0
  • C

    Konrad Rudolph schrieb:

    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")

    0
  • A
     

    Complex* Complex::addComplex(Complex*& dest, Complex const& c1, Complex const& c2)
	{
		Matrix m = c2.getMatrixForAdd();
		Vector3D v = c1.getVector3D();
		Vector3D result = v * m;
		dest = new Complex(result.x, result.y);

		return dest;
	}

    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.

    0
  • C

    Ja, aber um analog zu dem Ansatz zu arbeiten, mußt du die Pointer dort als C-Version der Referenzen betrachten - da ist es nicht nötig, extra Speicher per new anzufordern (im Gegenteil: wenn du new verwendest, mußt du immer überlegen, wer für das dazugehörige delete verantwortlich sein soll).

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

    0
  • A

    *hehe* das mit dem new hab ich auch dann beim schreiben entdeckt. Natürlich ist das totaler Unfug, vorallem da ich nicht mal auf NULL oder so wenigstens prüfe ^^

    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!

    0
Anmelden zum Antworten