Zuweisen von vorhandenen Werte zu smart-ptrs?

Ich bin nur zu lernen, über intelligente Zeiger, und ich habe Probleme bei der Zuweisung eine bereits bestehende Lage einer Variablen auf die standard-Bibliothek shared pointer.

Zum Beispiel, können sagen, Sie haben eine int x, die Sie nicht kennen den Wert des. Mit normalen Zeigern, ich habe gerade

int* ptr;
ptr = &x;

Ich versucht, sowohl die, die mit shared Pointer, und

std::tr1::shared_ptr<int> ptr;
ptr = std::make_shared<int> (&x)

So, ich bin ziemlich verloren, wie es zu tun.

  • Es ist extrem unwahrscheinlich, dass Sie möchten, übergeben Sie die Adresse einer variable, um einen shared pointer. Der Punkt shared Pointer ist, dass Sie zu verwalten dynamisch zugewiesenen Objekte.
InformationsquelleAutor bluepanda | 2013-11-25
  1. 21

    Würden Sie nicht (in der Regel) eine smart-pointer, zeigen Sie auf eine vorhandene variable. Ein smart-pointer verwaltet die Lebensdauer eines dynamisch reservierten Objekts, es zu löschen nach Gebrauch; verweist es auf etwas, dass nicht dynamisch zugewiesen wird einen Fehler verursachen, wenn er versucht, es zu löschen.

    Würden Sie in der Regel verwenden new oder make_shared um ein Objekt zu erstellen, und erstellen oder zuweisen einer smart-pointer zeigt, mit dem Ergebnis, dass:

    std::shared_ptr<int> ptr(new int(42)); //Create a new pointer to manage an object
ptr.reset(new int(66));                //Reset to manage a different object
ptr = std::make_shared<int>(53);       //Use `make_shared` rather than `new`

    make_shared ist in der Regel vorzuziehen new, denn es macht eine bessere Nutzung von Arbeitsspeicher und gibt stärkere exception-Sicherheit.

    InformationsquelleAutor Mike Seymour
  2. 3

    Shared Pointer verwendet werden, zu verwalten dynamisch Speicher zugewiesen, und genauer gesagt, Sie verwalten die Eigentum für diese Erinnerung.

    Grundsätzlich ein smart-pointer ist eine Materialisierung der Ressource Acquisition Is Initialization, oder RAII. Ich empfehle, Sie werfen Sie einen Blick auf dieses Prinzip, denn es ist äußerst nützlich für die Verwaltung von Ressourcen und Betriebskosten (im wesentlichen, jedes mal, wenn Sie benötigen, zu erwerben, eine Ressource, und lassen Sie es, werden Sie im Speicher, eine Datenbank-Verbindung, eine Datei-handler, einen mutex, etc.).

    Was es tut, ist im Grunde genommen garantieren, dass, während jemand Punkte auf den dynamisch reservierten Speicher, den Sie verwaltet, dann ist dieser Arbeitsspeicher verfügbar sind, und sobald der Letzte (smart) Zeiger auf diesen Speicher-Bereich verlässt, dann delete genannt wird.

    Dann macht es keinen Sinn, den Einsatz von smart-Pointer mit variable, automatische Speicherung Dauer (D. H., die entfernt werden, wenn Sie außerhalb des Bereichs, oder wenn das Objekt, das Sie sind Mitglied der geht sich aus dem Umfang oder gelöscht wird (wenn es neu war würde).

    InformationsquelleAutor JBL
  3. 1

    sobald der Referenzzähler des shared_ptr null erreicht, wird das Objekt gelöscht werden, indem der Letzte shared_ptr. mit der smart-Pointer können Sie die Funktion, die dieses Objekt gelöscht werden.

    den Deleter ist eine einfache Funktion (standardmäßig zu den üblichen operator delete) werden an das smart-pointer, die entweder statisch über template-parameter (siehe unique_ptr) oder dynamisch über parameter des Konstruktors (siehe shared_ptr).

    //dynamically via shared_ptr:
//  shared_ptrs share the pointer to the Deleter
//  because they already share a common data structure for reference counting.
auto ignore = [](int* o){
    std::cout<<"i will refuse to delete this object: " << o << "\n";
    std::cout<<"not my responsibility." <<std::endl;
};
std::shared_ptr<int> sptr(&x,ignore);


//statically via unique_ptr:
// actually, the unique_ptr is as data structure not more than a regular pointer.
// but a pointer with special copy-constructor and destructor,
// which will most likely be inlined.
// there is no space to store a reference to a Deleter dynamically.
struct IgnorantDeleter{
    void operator()(int* o){
        std::cout<<"who ate my cake? " << o << "\n";
        std::cout<<"but i baked it." <<std::endl;
    }
};
std::unique_ptr<int,IgnorantDeleter> uptr(&x);
    InformationsquelleAutor comonad
  4. 0

    Sollten Sie nicht erstellen Sie ein smart-pointer zeigen auf ein Objekt, das nicht dynamisch zugeteilt. Ansonsten ist der smart pointer können versuchen, löschen Sie den Speicher zugewiesen, was wiederum einen Fehler verursachen.

    InformationsquelleAutor Ivaylo Strandjev
Schreibe einen Kommentar