Пример использования shared_ptr

Обучение использованию интеллектуальных указателей находится в на мой взгляд, один из самых важных шагов, чтобы стать грамотным программистом на C ++. Как вы знаете, всякий раз, когда вы создаете новый объект, в какой-то момент вы хотите его удалить.

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

Это причина RAII: http://en.wikipedia.org/wiki/RAII

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

Пример такого класса: std :: auto_ptr

Но иногда вам нравится делиться объектами с другими. Его следует удалять только тогда, когда его больше никто не использует.

Чтобы помочь с этим, были разработаны стратегии подсчета ссылок, но вам все равно нужно запомнить addref и освободить ref вручную. По сути, это та же проблема, что и new / delete.

Вот почему boost разработал boost :: shared_ptr, интеллектуальный указатель с подсчетом ссылок, чтобы вы могли делиться объектами и не допускать утечки памяти непреднамеренно.

С добавлением C ++ tr1 теперь он также добавлен в стандарт C ++, но имеет имя std :: tr1 :: shared_ptr <>.

Я рекомендую по возможности использовать стандартный общий указатель. ptr_list, ptr_dequeue и т. д. являются специализированными контейнерами IIRC для типов указателей. Я пока их игнорирую.

Итак, мы можем начать с вашего примера:

std::vector<gate*> G; 
G.push_back(new ANDgate);  
G.push_back(new ORgate); 
for(unsigned i=0;i<G.size();++i) 
{ 
  G[i]->Run(); 
} 

Проблема в том, что теперь, когда G выходит за пределы области видимости, мы пропускаем 2 объекта, добавленных к G. Давайте перепишем его, чтобы использовать std :: tr1 :: shared_ptr

// Remember to include <memory> for shared_ptr
// First do an alias for std::tr1::shared_ptr<gate> so we don't have to 
// type that in every place. Call it gate_ptr. This is what typedef does.
typedef std::tr1::shared_ptr<gate> gate_ptr;    
// gate_ptr is now our "smart" pointer. So let's make a vector out of it.
std::vector<gate_ptr> G; 
// these smart_ptrs can't be implicitly created from gate* we have to be explicit about it
// gate_ptr (new ANDgate), it's a good thing:
G.push_back(gate_ptr (new ANDgate));  
G.push_back(gate_ptr (new ORgate)); 
for(unsigned i=0;i<G.size();++i) 
{ 
   G[i]->Run(); 
} 

Когда G выходит за рамки, память автоматически восстанавливается.

В качестве упражнения, которым я мучил новичков в моей команде, я попросил их написать свой собственный класс умных указателей. Затем, когда вы закончите, немедленно откажитесь от класса и никогда не используйте его снова. Надеюсь, вы получили важные знания о том, как работает интеллектуальный указатель. На самом деле никакой магии нет.

Я добавлю, что один из важных моментов в shared_ptr'ах состоит в том, чтобы только когда-либо конструировать их со следующим синтаксисом:

shared_ptr<Type>(new Type(...));

Таким образом, "настоящий" указатель на Type является анонимным для вашей области видимости и удерживается только общим указателем. Таким образом, вы не сможете случайно использовать этот "настоящий" указатель. Другими словами, никогда не делайте так:

Type* t_ptr = new Type(...);
shared_ptr<Type> t_sptr ptrT(t_ptr);
//t_ptr is still hanging around!  Don't use it!

Хотя это сработает, теперь в вашей функции есть Type* указатель (t_ptr), который живет вне общего указателя. Опасно использовать t_ptr в любом месте, потому что вы никогда не знаете, когда общий указатель, который его содержит, может его уничтожить, и вы получите segfault.

То же самое касается указателей, возвращаемых вам другими классами. Если класс, который вы не писали, передает вам указатель, обычно небезопасно просто помещать его в shared_ptr. Только если вы не уверены, что класс больше не использует этот объект. Потому что если вы поместите его в shared_ptr, и он выпадет из области видимости, объект будет освобожден, когда он еще может понадобиться классу.

В документации по boost приводится довольно хороший начальный пример: shared_ptr example (на самом деле речь идет о векторе умных указателей) или shared_ptr doc. Следующий ответ Йоханнеса Шауба довольно хорошо объясняет смарт-указатели boost: smart pointers explained

Идея ptr_vector в том, что он обрабатывает деаллокацию памяти под хранимые указатели за вас: допустим, у вас есть вектор указателей, как в вашем примере. При выходе из приложения или из области видимости, в которой определен вектор, вам придется очистить память после себя (вы динамически выделили ANDgate и ORgate), но просто очистить вектор не получится, потому что вектор хранит указатели, а не реальные объекты (он не уничтожит только то, что содержит).

 // if you just do
 G.clear() // will clear the vector but you'll be left with 2 memory leaks
 ...
// to properly clean the vector and the objects behind it
for (std::vector<gate*>::iterator it = G.begin(); it != G.end(); it++)
{
  delete (*it);
}

boost::ptr_vector<> сделает это за вас - то есть деаллоцирует память под указатели, которые хранит.