Operator überladen (->)

[xType2]

Hallo,

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

[drakon]

Was spricht dagegen, dass du einfach dereferenzieren tust?

Also:

(*spA).foo();

oder gleich so:

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

[Shade Of Mine]

Das ist die Magie von -> er dereferenziert soweit es geht. (vereinfacht ausgedrueckt)

[xType2]

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.

[drakon]

xType2 schrieb:

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.

[drakon]

Sorry, für den Doppelpost.

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

[pumuckl]

nein, das ist so nicht richtig. Fuer normale Klassen ist der Operator-> nicht definiert, den gibts per default nur fuer Pointer. 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. Einzig wenn du eine Memberfunktion des Smartpointers aufrufen moechtest, musst du deinen pointer einmalig explizit dereferenzieren.

[camper]

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.

[drakon]

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]

camper schrieb:

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.