Destruktoren- Klarrheit schaffen

Was ist dann ein lokaler Besitzer oder ein geteilter???

314159265358979

Lokal bedeutet, dass das Objekt am Ende des Scopes weggeräumt wird. Geteilt heißt, dass es mehrere shared_ptr zu dem Objekt geben kann. Das Objekt wird dann weggeräumt, wenn alle shared_ptr zu dem Objekt gelöscht werden
(Nebenbei gibt es auch noch weak_ptr, der allerdings nicht so oft gebraucht wird, am besten siehst du im Internet nach, was er tut

Nexus

314159265358979 schrieb:

(Nebenbei gibt es auch noch weak_ptr, der allerdings nicht so oft gebraucht wird, am besten siehst du im Internet nach, was er tut

weak_ptr wird immer nur in Verbindung mit shared_ptr benutzt, er ist kein eigenständiger Smart-Pointer. Das sieht man daran, dass er keine Dereferenzierung anbietet.

Und Absolute_nooby: shared_ptr brauchst du sehr selten. Wiederhole nicht den Fehler vieler C++-Programmierer und setze ihn aus Bequemlichkeit ein, zum Beispiel innerhalb STL-Container für automatische Wegräumung, wenn du viel lieber Pointer-Container nehmen würdest. Du solltest immer auch bedenken, dass er mit seinen vielen Features auch einiges an Laufzeitoverhead mitbringt.

314159265358979 schrieb:

Lokal bedeutet, dass das Objekt am Ende des Scopes weggeräumt wird. Geteilt heißt, dass es mehrere shared_ptr zu dem Objekt geben kann. Das Objekt wird dann weggeräumt, wenn alle shared_ptr zu dem Objekt gelöscht werden
(Nebenbei gibt es auch noch weak_ptr, der allerdings nicht so oft gebraucht wird, am besten siehst du im Internet nach, was er tut

Laut wikipedia ist Scope der Sichtbarkeitsbereich?! Würde das Beispiel stimmen:

class A;
meth()
{
    A* a = new A();
    a->do1();
    a->do2();
    //...
}// mit Abschluss der meth() wird der Scope verlassen?! Nun würde mit lokalem Pointer a aus dem Heap entfernt?!

Was ist genau ein Container (im Bezug auf den ptr_vector)? Da war google nicht so wirklich aufschlussreich...

314159265358979

Du musst das Objekt in einen scoped_ptr werfen, dann wird es entfernt. Rohe Zeiger sind ziemlich dumm.
std::vector, std::list, std::map sind Container. Du kannst darin mehrere Elemente des selben Typs speichern.

HighLigerBiMBam

Du kannst das ja mal ausprobieren. Du benötigst dafür aber boost.

#include <boost/scoped_ptr.hpp>
#include <iostream>

class A{public: void do1(){} void do2(){} ~A(){std::cout << "Destructor\n";}};

void methdumb() 
{ 
    A* a = new A(); 
    a->do1(); 
    a->do2(); 

    delete a; //muss aufgerufen werden, sonst Memory leak!
}

void methsmart() 
{ 
	boost::scoped_ptr<A> a(new A); 
    a->do1(); 
    a->do2(); 

    //Scoped ptr gibt hier automatisch die Ressource wieder frei! Kein Memory leak.
	//Grund Destructor des scoped_ptr löscht mit delete.
}

ipsec

Absolute_nooby schrieb:

Laut wikipedia ist Scope der Sichtbarkeitsbereich?! Würde das Beispiel stimmen:

class A;
meth()
{
    A* a = new A();
    a->do1();
    a->do2();
    //...
}// mit Abschluss der meth() wird der Scope verlassen?! Nun würde mit lokalem Pointer a aus dem Heap entfernt?!

Falls dich die anderen Antworten verwirren: Pointer haben keine Sonderbehandlung. Der Pointer a liegt wird korrekt und richtig gelöscht. a liegt nämlich auf dem Stack. Aber das Objekt, auf das a zeigt, wird nicht gelöscht, weil es nicht der automatischen Speicherklasse unterliegt (es liegt auf dem Heap).
Und genau hier kommt sowas wie scoped_ptr ins Spiel. Der verhält sich wie ein Pointer, löscht aber in seinem Destruktor sein referenziertes Objekt. Mit diesem "Trick" kann man also nicht-automatische Objekte an die automatische Speicherklasse binden. Diese Technik nennt sich RAII und ist ein Schlüsselparadigma von C++.