ich versuche gerade die Implementation von std::auto_ptr vom VS 2003 zu verstehen. Nun reichen meine Kenntnisse nicht aus, um folgendes Konstrukt zu verstehen:

template<class _Ty>
class auto_ptr
{
public:
  // ....
  _Ty *operator->() const _THROW0()
  {
    return (&**this);
  }
  // ....
private:
  _Ty *_Myptr;	// the wrapped object pointer
};

Ich verstehe nicht warum

return (&**this)

dasselbe zurückgibt was auch

return _Myptr

zurückgeben würde.

Wie kann es sein, dass die Adresse, die **&this liefert, die gleiche ist, worauf _Myptr zeigt? Was macht dieses Konstrukt genau?

Ich danke schon mal.

Grüße

/edit jo, also bei VS 2005 sieht der operator* in etwa so aus:

_Ty& operator*() const
{
    return (*(_Ty *)_Myptr);
}

Frag mich nicht wozu er da so einen ekelhaften C-Cast macht, aber es ist so. Sieht mir irgendwie nach nem Quickhack aus ...

danke für die Antwort. Du hast recht. Ich habe mal in beiden Operatoren (*, ->) Haltepunkte gesetzt, die dann angesprungen wurden.

Verstehe nicht warum das so umständlich ausgedrückt wird. Ein

return _Myptr

ist einfacher zu schreiben und sofort zu verstehen. Echt seltsam.

Btw:
Operator * sieht im VS 2003 ganz vernünftig aus:

_Ty& operator*() const _THROW0()
{
  return (*_Myptr);
}

Grüße

der grund, warum in vs2005 ein cast notwendig ist, liegt darin, das dort _MyPtr als const T* definiert wird, und das const (sofern es nicht teil von T ist) muss man wieder loswerden - und das ist ein c-style cast.. weil... die immer c-style casts benutzen :p
ein besonderer grund, warum _MyPtr ein zeiger auf const T sein soll, ist allerdings nicht erkennbar.

Also die Version aus VS 2003 sieht mir eigentlich nur nach Angeberei seitens
des Programmierers aus
Erklären kannst du dir den Ausdruck folgendermaßen, wenn du bedenkst,
dass bei Klassen, die keine virtuellen Methoden enthalten,
this mit der Adresse des ersten Attributs identisch ist.
Im Falle des auto_ptr müsste this == _Myptr sein.
Wird this nun dereferenziert (*this) erhält man das auto_ptr-Objekt selbst.
Dieses kann man ohne Bedenken nach den Datentyp _Ty casten.
*this ist also so ziemlich dasselbe wie _Myptr.
Dereferenziert man *this erhält man **this und damit den dereferenzierten Zeiger
*_Myptr.
Der Adressoperator(&) sorgt nun letztendlich dafür, dass die Adresse des derefernzierten Zeigers *_Myptr zurückgegeben wird.
(Adresse von *_Myptr) == &**this == this == _Myptr.
Ich bin grad etwas durcheinander und übernehme keine Gewähr für Richtigkeit
Aber so in der Art kann man sich das vorstellen

operator* kann ein ASSERT für den fall _MyPtr == 0 enthalten, oder im falle von vc++8.0 wird es benutz um dem code analyzer zu helfen. generell ist es eine gute idee operator-> mit hilfe von operator* zu imlementieren, genauso wie man andere operatoren@ nach möglichkeit mit hilfe von operator@= implementiert, wenn die semantik des operators das erlaubt.

denke das "_THROW0()" ist der Grund. Hab zwar keine Ahnung was dieser makro wirklich tut, kann mir aber vorstellen dass der operator vielleicht irgendewann mal eine exception werfen wird wenn _Myptr ugültig ist.

#define _THROW0() throw ()

camper schrieb:

operator* kann ein ASSERT für den fall _MyPtr == 0 enthalten

Tut es in diesem Fall nicht, siehe mein 2. Posting. Daher sieht es nach einem unnötigen Hack aus.

@Nocternity
Danke für die ausführliche Erklärung. Das hatte ich aber nach dem Hinweis von .filmor auch nachvollziehen können.

Sorry, das muss ich zurücknehmen. Ich habe jetzt dein Posting mal genauer durchgelesen. Dass **&this im Falle des std::auto_ptr funktioniert basiert nicht auf der Tatsache, dass bei Klassen ohne V-Table this die gleiche Adresse hat wie das erste Datenelement. Das funktioniert aufgrund des überladenen Dereferenzierungsoperators (). Siehe .filmors Beitrag. Ohne überladenen operator wäre nämlich **&this nicht kompilierbar.

Gruß

Also die Version aus VS 2003 sieht mir eigentlich nur nach Angeberei seitens
des Programmierers aus
Erklären kannst du dir den Ausdruck folgendermaßen, wenn du bedenkst,
dass bei Klassen, die keine virtuellen Methoden enthalten,
this mit der Adresse des ersten Attributs identisch ist.
Im Falle des auto_ptr müsste this == _Myptr sein.
Wird this nun dereferenziert (*this) erhält man das auto_ptr-Objekt selbst.
Dieses kann man ohne Bedenken nach den Datentyp _Ty casten.
*this ist also so ziemlich dasselbe wie _Myptr.
Dereferenziert man *this erhält man **this und damit den dereferenzierten Zeiger
*_Myptr.
Der Adressoperator(&) sorgt nun letztendlich dafür, dass die Adresse des derefernzierten Zeigers *_Myptr zurückgegeben wird.
(Adresse von *_Myptr) == &**this == this == _Myptr.
Ich bin grad etwas durcheinander und übernehme keine Gewähr für Richtigkeit
Aber so in der Art kann man sich das vorstellen

this == Zeiger auf auto_ptr
*this == Reference auf auto_ptr
**this == Reference auf T (durch Benutzung von auto_ptr::operator*)
&*this == Zeiger auf T
Hier wird nur der operator-> mit Hilfe des operator implementiert, kein Hack.

denke das "_THROW0()" ist der Grund. Hab zwar keine Ahnung was dieser makro wirklich tut, kann mir aber vorstellen dass der operator vielleicht irgendewann mal eine exception werfen wird wenn _Myptr ugültig ist.

_THROWO markiert ganz einfach eine Funktion die keine Ausnahmen schmeißen kann. Im Standard gibt es throw() was ansich dafür gedacht ist, allerdings bereitet dieses Standardkonstrukt erhebliche Probleme. Es ist aus diesem Grund auch nur Teils im VC umgesetzt und daher kann es auch gut sein, dass das Makro zu nichts expandiert. Jedenfals um flexibel zu bleiben hat mn sich für das Makro entschieden.