c+ - Ce qui est un pointeur intelligent et quand devrais-je utiliser un

Mots clés : c++pointersc++11smart-pointersc++-faqc++

meilleur 1 Réponses c+ - Ce qui est un pointeur intelligent et quand devrais-je utiliser un

vote vote

91

std::auto_ptr<MyObject> p1 (new MyObject()); std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership.                                   // p1 gets set to empty! p2->DoSomething(); // Works. p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception. 
// Need to create the object to achieve some goal MyObject* ptr = new MyObject();  ptr->DoSomething(); // Use the object in some way delete ptr; // Destroy the object. Done with it. // Wait, what if DoSomething() raises an exception...? 
SomeSmartPtr<MyObject> ptr(new MyObject()); ptr->DoSomething(); // Use the object in some way.  // Destruction of the object happens, depending  // on the policy the smart pointer class uses.  // Destruction would happen even if DoSomething()  // raises an exception 
void f() {     {        std::unique_ptr<MyObject> ptr(new MyObject());        ptr->DoSomethingUseful();     } // ptr goes out of scope --        // the MyObject is automatically destroyed.      // ptr->Oops(); // Compile error: "ptr" not defined                     // since it is no longer in scope. } 
void f() {     typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias     MyObjectPtr p1; // Empty      {         MyObjectPtr p2(new MyObject());         // There is now one "reference" to the created object         p1 = p2; // Copy the pointer.         // There are now two references to the object.     } // p2 is destroyed, leaving one reference to the object. } // p1 is destroyed, leaving a reference count of zero.    // The object is deleted. 
// Create the smart pointer on the heap MyObjectPtr* pp = new MyObjectPtr(new MyObject()) // Hmm, we forgot to destroy the smart pointer, // because of that, the object is never destroyed! 
struct Owner {    std::shared_ptr<Owner> other; };  std::shared_ptr<Owner> p1 (new Owner()); std::shared_ptr<Owner> p2 (new Owner()); p1->other = p2; // p1 references p2 p2->other = p1; // p2 references p1  // Oops, the reference count of of p1 and p2 never goes to zero! // The objects are never destroyed! 

Questions similaires