Im Grunde geht es um folgende Template-Klasse:

template <typename T> class Test
{
public:
	Test<T> *me;

	Test()
	{
		me = this;
	}

	Test<int>* GiveMeMe()
	{
		return me;
	}

	bool NonsenseCondition(Test<int> *w1)
	{
		return (w1->me==this->me?1:0);
	}

	Test<T>* operator ->()
	{
		std::cout << "Hi" << std::endl;
		return *(this);
	}
};

Ein Aufruf in dem theoretisch bis auf den Konstruktor alles aufgerufen würde, könnte zum Beispiel sein:

Obj->NonsenseCondition(Obj->GiveMeMe());

Ich denke, das Beispiel ist relativ selbst erklärend. Kurz aber trotzdem mal Stichpunkte:
-> Obj ist ein Objekt der Templateklasse Test<T>. Welchen Typ T einnimmt ist glaube ich für das Problem irrelevant.
-> me ist ein Pointer auf ein Objekt der Template-Klasse. Er erhält im Konstruktor die Adresse des eigenen Objektes.
-> NonsenseCondition prüft, ob Obj.me und das übergebene Objekt das gleich Objekt beinhalten
-> Der Aufruf überprüft also nur, ob Obj.me und Obj.me das gleiche sind...

Nun also zum Problem:
Wie man sieht habe ich den operator-> überladen. (Dachte ich zumindest)
Nun ist allerdings das Problem, dass der Operator-> wohl nicht aufgerufen wird. Die Testausgabe erscheint also nicht.
Bisher habe ich allerdings nur einen Unterschied zu den bei Google gefundenen Beispielen gefunden:
Normalerweise wird wohl der Operator für die Typen der Member einer Klasse überladen. Geht das also für die eigene Klasse nicht?
Ich hätte jetzt damit gerechnet, dass zumindest Obj->GiveMeMe() die Überladung wahr nimmt.

Ich habe es übrigens bereits mit Test<T>&, Test<T>* und Test<T> als Rückgabetyp versucht. Ich hätte zumindest bei einer Art mit einem weinenden Compiler gerechnet, dem war aber nicht so. Daher habe ich auch so langsam keine Hinweise denen ich mehr folgen kann...

Danke schonmal, für jeden Versuch mir dabei zu helfen.

PS.: Noch ein paar Eckdaten:

gpp 4.6.2
Eclipse Indigo
Windows 7

Lg Marius

bool NonsenseCondition(Test<int> *w1)
{
    return ((*w1)->me==this->me?1:0);
}

(sofern w1 nicht null ist)

Obj ist ein Pointer auf meine Templateklasse. Um genau zu sein "Test<int>*".
Was bedeutet das denn dann, wie müsste der Aufruf verändert werden, damit die Überladung passt, oder umgekehrt?

Wenn Obj ein "eingebauter" Zeiger ist, dann wird natürlich auch die eingebaute -> Logik verwendet (man könnte sagen: der eingebaute operator -> -- wobei der Standard das IIRC nicht so nennt). D.h. der Zeiger wird ganz normal dereferenziert. Das Ergebnis davon ist dann eine Referenz, und damit ist der Vorgang abgeschlossen.
Auf diese Referenz wird dann NonsenseCondition aufgerufen.

Wenn du willst dass dein operator -> aufgerufen wird, dann musst du mit einer Referenz starten.
D.h. wenn Obj hier wieder ein "eingebauter" Zeiger ist, und du möchtest dass 2x dein operator -> aufgerufen wird, dann müsstest du

(*Obj)->NonsenseCondition((*Obj)->GiveMeMe());

schreiben.

Ich habe jetzt mal den Vorschlag von hustbaer genommen:

Test<T> *me;
(*w1)->me;
(*w1)->GiveMeMe();
(*w1)->NonsenseCondition();

Das Ende vom Lied ist die folgende Fehlermeldung:

loop in sequence of "operator->" functions starting at class "Test<int>"

Für alle 3 Aufrufe ...
Ich glaube somit kann ich behaupten, dass der Aufruf nun zumindest versucht wird. Nur funktionieren will es eben immer noch nicht.

Ist denn vielleicht grundsätzlich der Gedanke falsch, dass der operator-> ein Objekt der eigenen Klasse zurückgeben kann?
Wie gesagt: In den Erklärungen bei Google war komischer Weise meist ein anderer Rückgabetyp in Verwendung.

Beim rumprobieren ist mir außerdem noch aufgefallen, dass *(w1).me funktionieren würde. Ich hätte aber eher damit gerechnet, dass *(w1)->me und w1.me im Endeffekt (ohne eine Überladung) das Gleiche wären. Ist dem nicht so?

Lg

Ist denn vielleicht grundsätzlich der Gedanke falsch, dass der operator-> ein Objekt der eigenen Klasse zurückgeben kann?

Der operator-> ist ein wenig eigenartig. Wie du daran erkennen kannst, dass er keine Parameter hat, ist er sozusagen unär. Wenn du a->b schreibst, und für a ist operator-> überladen, dann wird b zunächst gar nicht angefasst. Es wird ausgewertet, was a.operator->() zurückgibt, und damit wird dann wieder ->b ausgewertet:

(a.operator->())->b

Wenn der operator-> also ein Objekt einer Klasse zurückgibt, die wiederum operator-> überlädt, dann wird danach eben dieser Operator aufgerufen. Das geht so lange weiter, bis irgendwann ein operator-> einen "echten" Zeiger zurückgibt.

Da der operator-> deiner Klasse das Objekt selbst zurückgibt, terminiert das nicht.

Ist denn vielleicht grundsätzlich der Gedanke falsch, dass der operator-> ein Objekt der eigenen Klasse zurückgeben kann?

Sieht so aus.

marius.schmidt schrieb:

In den Erklärungen bei Google war komischer Weise meist ein anderer Rückgabetyp in Verwendung.

Wieso "komischer Weise"? WTF? Es ist total normal nen anderen Typ zurückzugeben, was hier komisch bzw. eher schon total beknackt ist, ist dein Versuch operator -> nen Zeiger auf den eigenen Typ zurückgeben zu lassen.

Darin lag ganz einfach nur mein Mißverständnis, wenn ich das so richtig verstehe.
Ich hatte ganz einfach nur das Gefühl dass aus einem *(w1)->me ein w1.me wird. In dem Fall hätte mein Gedanke hinter dem Beispiel gepasst.
Zumal ja der Compiler nicht gemeckert hat. Bei einfacheren Operatoren kommt bei einem falschen Datentyp eine Meldung.

Ich denke aber zumindest, dass ich dann jetzt so ungefähr das Problem verstanden habe. Danke für die Hilfe.

was hier komisch bzw. eher schon total beknackt ist, ist dein Versuch operator -> nen Zeiger auf den eigenen Typ zurückgeben zu lassen.

Neuerdings kann man ja Funktionen auch so deklarieren

auto foo(T param) -> result;

Leider hat das Standardkomittee vergessen, auch den Funktionsaufruf zu verbessern.
Zum Glück gibt es dafür eine Lösung

#include <utility>
#include <iostream>

int old_fak(int n)
{
    return n ? n * old_fak( n - 1 ) : 1;
}

struct new_fak
{
    int input;
    struct res
    {
        const int&& value;
        const res* operator->() const { return this; }
    };
    const res operator->() const { return { input ? input * new_fak{ input - 1 }->value : 1 }; }
};

int main()
{
    std::cout << old_fak(4) /* old-style */ << '\n';
    std::cout << new_fak{5}->value /* modern */<< '\n';
}

Es geht, um genau zu sein, um das Testen einer von uns eingesetzten Implementierung eines Iterators.
Ich bin also nicht der, der das schreiben muss, sondern der der gucken muss ob alles aufgerufen wird ... Und das wird operator-> leider nicht ...

Vielleicht solltet ihr eure Iterator Implementierung so umstellen, dass ihr keinen Pointer auf den Iterator habt sondern wirklich das Objekt selbst oder maximal eine Referenz darauf, wenn es teuer ist den Iterator zu kopieren. Dann kannst du dir die ganzen (*obj)-> Geschichten sparen und direkt obj-> schreiben.