ich habe eine Frage zur Überladung des -> Operators:

Für einen SmartPointer habe ich so etwas gesehen:

T* operator->() { return _ptr; }

also dann zum Bespiel :

SP<A> spA = new A;
spA->foo();

spA-> ergibt nun aber doch lediglich eine Zeiger auf A also müsste darauf doch nochmals ein -> folgen um eine Methode von A aufzurufen?

Vielen Dank für die Hilfe!
Gruss

Also:

(*spA).foo();

oder gleich so:

//Keine Überladung
spA->foo();

@drakon:

Da sich der Smart Pointer wie ein echter Zeiger bedienen lassen soll brauche ich den -> operator und muss diesen somit auch überladen. Ich wende Ihn ja direkt auf Objekte an (spA ist kein Zeiger).

@ Shade Of Mine:

Aha, danke! Wusste ich nicht.

Hallo
danke für die Antworten!

@drakon:

Da sich der Smart Pointer wie ein echter Zeiger bedienen lassen soll brauche ich den -> operator und muss diesen somit auch überladen. Ich wende Ihn ja direkt auf Objekte an (spA ist kein Zeiger).

@ Shade Of Mine:

Aha, danke! Wusste ich nicht.

Sry. Habe selber nacher gemerkt,dass es Bullshit ist.

Wenn ich mich nicht täusche, müsste es auch so gehen: (Ohne Überladung)

(&spA)->foo ();

Soll ja aber nicht der Sinn sein.

Aber bin ich der einzige, dem das irgendwie so nicht gefällt?

Irgendwie kann ich mich mit dem nicht so richtig anfreunden.
Also mal abgesehen von einem SmartPointer ist dieses Überladen ja nicht gerade die feine Art.
Wenn man zum Beispiel einen Zeiger von so einer Klasse will, kann man nicht mehr einfach mit dem -> Operator auf die Elementfunktionen zugreifen. Da muss man zuerst den Zeiger dereferenzieren und erst dann kann man den -> Operator wieder brauchen..

Du bekommst einzig dann Probleme, wenn du einen Pointer auf ein Objekt einer Klasse hast, die den operator-> ueberladen hat, (z.B. einen Pointer auf einen smartpointer, shared_ptr<T>* ) denn wenn du auf den Pointer dann den eingebauten op-> anwendest, macht C++ sofort weiter und wendet auf das Ergebnis wieder op-> an, was meistens das ist, was man erreichen moechte.

Unfug.

Wenn man zum Beispiel einen Zeiger von so einer Klasse will, kann man nicht mehr einfach mit dem -> Operator auf die Elementfunktionen zugreifen. Da muss man zuerst den Zeiger dereferenzieren und erst dann kann man den -> Operator wieder brauchen..

Das hat schon gestummen, was ich da geschrieben habe. Wenn du einen Zeiger auf einen Smartpointer hast, und dann den -> Operator benutzt, greifst du auf die Elementfunktionen des Pointers auf. Wenn du jetzt aber die gleiche Funktion willst, wie bei einem normalen Objekt, musst du dereferenzieren oder die umständliche Weise schreiben:

ptr a;
ptr* b = &a;

a->foo (); //Die überladene Weise
(*b)->foo (); //Mit dem Zeiger auf die überladene Weise
b->operator ()->foo (); // Ebenfalls mit Zeiger überladene (umständlich)

Nur was mir da nicht passt, ist, dass sonst ja immer gilt, dass der -> Operator das gleiche macht, wie der . Operator, aber einfach über einen Zeiger.

Nun, das eigentliche Problem, dass ich mir vorstelle (abgesehen von einem Smartpointer) ist, dass, ich sage es jetzt mal extrem, der Benutzer einer (beliebigen Klasse), nicht das Ergebnis bekommt, dass er erwartet, wenn er jetzt anstatt eines normalen Objekt eines mit einem Zeiger erstellt.

pumuckl schrieb:

Du bekommst einzig dann Probleme, wenn du einen Pointer auf ein Objekt einer Klasse hast, die den operator-> ueberladen hat, (z.B. einen Pointer auf einen smartpointer, shared_ptr<T>* ) denn wenn du auf den Pointer dann den eingebauten op-> anwendest, macht C++ sofort weiter und wendet auf das Ergebnis wieder op-> an, was meistens das ist, was man erreichen moechte.

Unfug.

Dann muss ich mir den entsprechenden Teil bei Alexandrescu nochmal durchlesen. Der achte sich das irgendwie zunutze, indem er in seinen smartpointern statt C-Poiintern wieder andere smartpointer als member verwendete. Tut mir leid wenn mir das falsch in erinnerung geblieben ist.