ОНОВЛЕННЯ
Ця відповідь досить стара, і так описується те, що було «добре» в той час, які розумні вказівки надавали бібліотека 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_ptrs корисні, коли ви хочете прив’язати термін експлуатації об'єкта до певного блоку коду, або якщо ви вбудували його як дані члена всередині іншого об'єкта, термін служби цього іншого об'єкта. Об'єкт існує до тих пір, поки не містить блоку коду або до його знищення.
Більш складна політика інтелектуального вказівника передбачає підрахунок посилань. Це дозволяє скопіювати покажчик. Коли остання "посилання" на об'єкт знищена, об'єкт видаляється. Цю політику реалізує 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.