AKTUALIZACJA
Ta odpowiedź jest raczej stara i opisuje to, co było wtedy „dobre”, czyli inteligentne wskaźniki dostarczone przez bibliotekę Boost. Od wersji C ++ 11 standardowa biblioteka zapewnia wystarczającą liczbę typów inteligentnych wskaźników, dlatego powinieneś preferować użycie std::unique_ptr, std::shared_ptri std::weak_ptr.
Było też std::auto_ptr. Był bardzo podobny do wskaźnika celowniczego, tyle że miał także „specjalną” niebezpieczną zdolność do kopiowania - która również nieoczekiwanie przenosi własność.
Został przestarzały w C ++ 11 i usunięty w C ++ 17 , więc nie powinieneś go używać.
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.
STARA ODPOWIEDŹ
Inteligentny wskaźnik to klasa, która otacza „surowy” (lub „goły”) wskaźnik C ++, aby zarządzać żywotnością wskazywanego obiektu. Nie ma jednego inteligentnego typu wskaźnika, ale wszystkie próbują wyodrębnić surowy wskaźnik w praktyczny sposób.
Inteligentne wskaźniki powinny być preferowane nad surowymi wskaźnikami. Jeśli uważasz, że musisz użyć wskaźników (najpierw zastanów się, czy naprawdę tak robisz), zwykle powinieneś użyć inteligentnego wskaźnika, ponieważ może to złagodzić wiele problemów z surowymi wskaźnikami, głównie zapominając o usunięciu obiektu i wycieku pamięci.
Dzięki surowym wskaźnikom programista musi jawnie zniszczyć obiekt, gdy nie jest on już użyteczny.
// 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...?
Inteligentny wskaźnik przez porównanie definiuje zasadę, kiedy obiekt zostanie zniszczony. Nadal musisz stworzyć obiekt, ale nie musisz się już martwić o jego zniszczenie.
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
Najprostsza w użyciu zasada obejmuje zakres obiektu opakowania inteligentnego wskaźnika, na przykład zaimplementowanego przez boost::scoped_ptrlub std::unique_ptr.
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.
}
Pamiętaj, że std::unique_ptrnie można skopiować instancji. Zapobiega to wielokrotnemu usuwaniu wskaźnika (niepoprawnie). Możesz jednak przekazywać odniesienia do innych wywoływanych funkcji.
std::unique_ptrs są przydatne, gdy chcesz powiązać czas życia obiektu z określonym blokiem kodu lub jeśli osadziłeś go jako dane członka w innym obiekcie, czas życia tego innego obiektu. Obiekt istnieje do momentu opuszczenia zawierającego go bloku kodu lub do momentu zniszczenia zawierającego go obiektu.
Bardziej złożone zasady dotyczące inteligentnych wskaźników obejmują liczenie referencji przez wskaźnik. Pozwala to na skopiowanie wskaźnika. Gdy ostatnie „odniesienie” do obiektu zostanie zniszczone, obiekt zostanie usunięty. Ta polityka jest wdrażana przez boost::shared_ptri std::shared_ptr.
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.
Wskaźniki liczone w odniesieniach są bardzo przydatne, gdy czas życia obiektu jest znacznie bardziej skomplikowany i nie jest bezpośrednio powiązany z określoną sekcją kodu lub innym obiektem.
Istnieje jedna wada w stosunku do liczonych wskaźników - możliwość utworzenia wiszącego odniesienia:
// 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!
Inną możliwością jest tworzenie referencji cyklicznych:
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!
Aby obejść ten problem, zarówno Boost, jak i C ++ 11 zdefiniowały a, weak_ptraby zdefiniować słabe (niepoliczone) odwołanie do a shared_ptr.