scoped_ptr, shared_ptr, auto_ptr, smart_ptr

Delryn

Mahlzeit.

Ich bin jemand der bisher nur die normalen Pointer genutzt hat, jetzt lese ich immer öfter (ob ich nun die Forumsuche benutze oder mich nur so umschaue) Diskussionen über diese Pointertypen (die ja eigentlich nur Klassen sind).

Nur irgendwie kann ich so als Außenstehender absolut nichts damit anfangen, warum sind die "gut", was kann man damit tolles machen. Und vor allem; wieso?

Welche sollte ich mir unbedingt mal anschauen?

simon.phoenix

edit: Sorry für Doppelpost (verklickt)

simon.phoenix

Nur auto_ptr ist Teil der Standard-Bibliothek. Der Rest ist afaik Teil von boost.

Der Sinn von auto_ptr (eine primitive Art von Smart-Pointer) ist, dass das Stack-Objekt (der auto_ptr) bei seinem Destruktor-Aufruf zugleich ein Objekt auf dem Free Store mit zerstört. Das heißt, man muss sich selbst nicht mehr um das delete kümmern:

// mit auto_ptr
std::auto_ptr<Foo> fooPtr (new Foo);
// foo benutzen
// ...
// Der durch "new Foo" allozierte Speicher wird bei Destruktion von fooPtr 
// automatisch freigegeben (und fooPtr wird beim Verlassen des Scopes sowieso
// zerstört) => keine Speicherlücken

// ohne auto_ptr
Foo* fooPtr = new Foo;
// benutzen...
delete fooPtr;

Dort erscheint der Sinn noch nicht schlüssig, aber hier:

try{
    Foo* fooPtr = new Foo;
    FooBarFunction();
}
catch(...){
   reactOnException();
}

delete fooPtr;

Wenn der Konstruktor von Foo oder FooBarFunction() eine Exception werfen, wird "delete fooPtr" nie aufgerufen => Speicherleck.

Deshalb:

try{
    std::auto_ptr<Foo> fooPtr (new Foo);
    FooBarFunction();
}
catch(...){
   reactOnException();
}

Schwer vereinfach sieht das auto_ptr-Klassentemplate also so aus:

template<class T>
class auto_ptr{
    auto_ptr(T* ptr = NULL) : ptr_(ptr) {}
    ~auto_ptr() { if(ptr_) {delete ptr_;} }
};

Wichtig zu erwähnen ist vielleicht noch, dass man auto_ptr nicht mit Zeiger auf Arrays füllen kann/sollte, weil dazu ein "delete[] ptr_" im Destruktor nötig wäre. Für dynamische Arrays nimmt man aber sowieso eher std::vector und Konsorten.

Ich hoffe ich konnte dir irgendwie weiterhelfen und mich einigermaßen verständlich ausdrücken :). Zum Rest können dir die Anderen denke ich mal deutlich mehr erzählen

groovemaster

http://www.boost.org/libs/smart_ptr/smart_ptr.htm
Ansonsten, google ist dein Freund.

simon.phoenix, du hast std::auto_ptr so beschrieben als wenn es ein boost::scoped_ptr wäre und das wichtigste ausgelassen.

Infos zum std::auto_ptr: http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=auto_ptr#Answ

simon.phoenix

Zu auto_ptr findet auch bei Rückgabewerten Verwendung:

http://www.c-plusplus.net/forum/viewtopic.php?t=39473

@gggggggg:

Ja, ich habe vergessen die Eigentümerschaft zu beschreiben. Aber ist imho i.d.R. nicht so wichtig wie die automatische Speicherfreigabe (zumindet für Anfänger wie mich ;)).