ich versuche mir gerade smart pointer anzueignen und stehe vor folgendem Problem.

Normalerweise initialisiere ich die Klassenpointer beim erzeugen der Klasse mit Null. Vor der Nutzung frage ich ob sie != NULL sind.

Wie funktioniert es z. B. bei shared_ptr? Wenn ich

myClass:MyClass():mpMyPointer(NULL)

compiliere dann gibt es einen Fehler cannot convert from int to const shared...

Siehe: http://www.boost.org/doc/libs/1_47_0/libs/smart_ptr/shared_ptr.htm#constructors

Ich bekomme bei folgender Zuordnung

inline void eo::setro(const shared_ptr<const ro> &rRO)
{
	mpRelOr = rRO;
}

eine Fehlermeldung die ich nicht nachvollziehen kann

1>error C2678: binary '=' : no operator found which takes a left-hand operand of type 'const std::tr1::shared_ptr<_Ty>' (or there is no acceptable conversion)
1>        with
1>        [
1>            _Ty=const ro
1>        ]
1>        ...\memory(1475): could be 'std::tr1::shared_ptr<_Ty> &std::tr1::shared_ptr<_Ty>::operator =<const ro>(const std::tr1::shared_ptr<_Ty> &)'
1>        with
1>        [
1>            _Ty=const ro
1>        ]
1>        ...\memory(1468): or       'std::tr1::shared_ptr<_Ty> &std::tr1::shared_ptr<_Ty>::operator =(const std::tr1::shared_ptr<_Ty> &)'
1>        with
1>        [
1>            _Ty=const ro
1>        ]
1>        while trying to match the argument list '(const std::tr1::shared_ptr<_Ty>, const std::tr1::shared_ptr<_Ty>)'
1>        with
1>        [
1>            _Ty=const ro
1>        ]

In der Klasse wurde ro wie folgt definiert:

const shared_ptr<const ro>

Ich möchte also einen const pointer auf ein const Objekt.

Was muss ich genau implementieren und wie sieht der Funktionsrumpf aus?

shared_ptr<const ro> mpRelOr;

daraus. Du kannst einer Konstante später nichts mehr zuweisen; das ist der Sinn einer Konstante.

const shared_ptr<const ro> mpRelOr;

Dann hast du natürlich einen konstanten shared_ptr, und kannst ihm nicht einfach etwas zuweisen. Das sollte aber eigentlich klar sein oder nicht? Du musst mpRelOr bei der Definition auch gleich initialisieren.

...

Hat sich erledigt. Ich bin doof und wollte ein const Objekt beschreiben.

Außerdem solltest du (außer es gibt einen sinnvollen Grund) die Smart-Pointer per value übergeben. Die Referenzzählung garantiert, dass der Pointer immer gültig ist, und das geht nur, wenn du die Kopiersemantik nutzt.

Ist das wirklich so?

Ich meine nämlich das hier vorher gefunden zu haben:

http://www.c-plusplus.net/forum/174283

Außerdem solltest du (außer es gibt einen sinnvollen Grund) die Smart-Pointer per value übergeben. Die Referenzzählung garantiert, dass der Pointer immer gültig ist, und das geht nur, wenn du die Kopiersemantik nutzt.

Ganz viel AUA!

shared_ptr bitte niemals nicht by-value übergeben, denn das kostet schnell mal ein paar hundert Cycles (shared_ptr muss seinen Counter threadsafe updaten, und das ist teuer).

Und was die Referenzzählung angeht, das funktioniert natürlich wunderbar. Referenzen auf shared_ptr als Member abzuspeichern wäre böse. Als Parameter aber bitte immer per reference-to-const.

lass den einfach so, der standardkonstruktor belegt den schon mit 0. und selbst wenn nicht, das interessiert dich nicht, da shared_ptr eh fehler wirft wenn du auf einen ungültigen zeiger zugreifen willst...

Auch ganz viel AUA!

Der operator -> von shared_ptr ist "unchecked". D.h. der wirft gar nix wenn man einen ungültigen Zeiger dereferenziert, das Programm wird das selbe machen wie bei einem rohen Zeiger.

§ 20.9.11.2.5 schrieb:

T* operator->() const;

Requires: get() != 0.
Returns: get().
Throws: nothing.

Erstens referenziert ein Zeiger nicht, er zeigt.

Wenn man zwanghaft klugscheißen will, sollte man wenigstens recht haben.

Und wie löst man jetzt dass Problem dass man ihn irgendwie NULL referenziert und dann immer wieder abfragt?

So wie man es in sämtlichen Beispielen sieht.