Что такое умный указатель и когда я должен его использовать?

ОБНОВЛЕНИЕ

Этот ответ довольно стар, и так описывает то, что было 'хорошо' в то время, который был интеллектуальными указателями, обеспеченными библиотекой Boost. Начиная с C++ 11, стандартная библиотека обеспечила достаточные типы интеллектуальных указателей, и таким образом, необходимо одобрить использование [1 120] std::unique_ptr , std::shared_ptr и std::weak_ptr .

существует также std::auto_ptr . Это очень похоже на ограниченный по объему указатель, за исключением того, что это также имеет "специальную" опасную способность, которая будет скопирована —, который также неожиданно передает владение! Это удерживается от использования в новейших стандартах, таким образом, Вы не должны использовать его. Используйте std::unique_ptr вместо этого.

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.

СТАРЫЙ ОТВЕТ

интеллектуальный указатель А является классом, который обертывает 'сырые данные' (или 'пустой') указатель C++, для управления временем жизни указываемого объекта. Нет никакого единственного типа интеллектуального указателя, но все они пытаются абстрагировать необработанный указатель практическим способом.

Интеллектуальные указатели должны быть предпочтены по необработанным указателям. Если Вы чувствуете, что необходимо использовать указатели (сначала рассматривают, делаете ли Вы действительно ), Вы обычно хотели бы использовать интеллектуальный указатель, поскольку это может облегчить многие проблемы с необработанными указателями, главным образом забыв удалять объект и пропустив память.

С необработанными указателями, программист должен явно уничтожить объект, когда это больше не полезно.

// 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

самая простая используемая политика включает объем интерфейсного объекта интеллектуального указателя, такой, как реализовано [1 125] boost::scoped_ptr или 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.
}

Примечание, что std::unique_ptr экземпляры не могут быть скопированы. Это препятствует тому, чтобы указатель был удален многократно (неправильно). Можно, однако, передать ссылки на него вокруг к другим функциям, которые Вы вызываете.

std::unique_ptr с полезны, когда Вы хотите связать время жизни объекта к конкретному блоку кода, или если Вы встроили его как членские данные в другом объекте, время жизни того другого объекта. Объект существует, пока из содержания блока кода не выходят, или пока содержание объекта самостоятельно не уничтожается.

А более сложная политика интеллектуального указателя включает подсчет ссылок указатель. Это действительно позволяет указателю быть скопированным. Когда последняя "ссылка" на объект уничтожается, объект удален. Эта политика проводится [1 127] boost::shared_ptr и 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.

Reference рассчитал, указатели очень полезны, когда время жизни Вашего объекта намного более сложно, и не связывается непосредственно с конкретным разделом кода или к другому объекту.

существует один недостаток к ссылке считаемые указатели — возможность создания повисшей ссылки:

// 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!

Для работы вокруг этой проблемы оба Повышения и C++ 11 определили weak_ptr для определения слабой (бесчисленной) ссылки на shared_ptr.