ОБНОВИТЬ
Этот ответ довольно старый и поэтому описывает то, что было «хорошо» в то время, то есть умные указатели, предоставляемые библиотекой Boost. Начиная с C ++ 11, стандартная библиотека предоставляла достаточное количество типов интеллектуальных указателей, поэтому вы должны отдавать предпочтение использованию std::unique_ptr, std::shared_ptrи std::weak_ptr.
Был также std::auto_ptr. Это было очень похоже на указатель в области видимости, за исключением того, что он также имел «особую» опасную способность для копирования, которая также неожиданно передает право собственности.
Он был объявлен устаревшим в C ++ 11 и удален в C ++ 17 , поэтому его не следует использовать.
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
Простейшая используемая политика включает в себя область действия объекта-оболочки интеллектуального указателя, например, реализованную с помощью 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Они полезны, когда вы хотите связать время жизни объекта с конкретным блоком кода или, если вы внедрили его как данные члена в другой объект, время жизни этого другого объекта. Объект существует до тех пор, пока не будет завершен содержащий блок кода или пока сам содержащий объект не будет уничтожен.
Более сложная политика интеллектуальных указателей включает подсчет ссылок указателя. Это позволяет копировать указатель. Когда последняя «ссылка» на объект уничтожается, объект удаляется. Эта политика реализуется 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.
Указатели с подсчетом ссылок очень полезны, когда время жизни вашего объекта намного сложнее и не привязано напрямую к определенному разделу кода или другому объекту.
У указателей с подсчетом ссылок есть один недостаток - возможность создания зависшей ссылки:
// 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!
Чтобы обойти эту проблему, и Boost, и C ++ 11 определили a weak_ptrдля определения слабой (неучтенной) ссылки на a shared_ptr.