Что лучший способ состоит в том, чтобы реализовать интеллектуальные указатели в C++?

Только для предоставления другого представления к повсеместному ответу Повышения (даже при том, что это - правильный ответ для многого использования) смотрите на реализацию Loki интеллектуальных указателей. Для дискурса на принципах проектирования исходный создатель Loki записал книге современный Дизайн C++.

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

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

Это кажется мне, этот вопрос отчасти похож на выяснение, "Которое является лучшим алгоритмом сортировки?" Нет никакого ответа, он зависит от Ваших обстоятельств.

В моих собственных целях я использую Ваш тип 1. У меня нет доступа к библиотеке TR1. Я действительно имею полный контроль над всеми классами, на которые я должен совместно использовать указатели. Дополнительная память и эффективность времени типа 1 могли бы быть довольно небольшим, но использованием памяти, и скорость большие проблемы для моего кода, таким образом, тип 1 был хлопком Данк.

С другой стороны, для любого, кто может использовать TR1, я думал бы станд. типа 2:: tr1:: класс shared_ptr был бы разумным выбором по умолчанию, чтобы использоваться каждый раз, когда нет некоторой нажимающей причины не использовать его.

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

• Совместно использованный: Где владение совместно используется несколькими объектами
• Принадлежавший: Где один объект владеет объектом, но передача позволяется.
• Неперемещаемый: Где один объект владеет объектом, и он не может быть передан.

Стандартная библиотека имеет:

• станд.:: auto_ptr

Повышение имеет пару больше, чем было адаптировано tr1 (следующая версия стандарта)

• станд.:: tr1:: shared_ptr
• станд.:: tr1:: weak_ptr

И те, которые все еще в повышении (который в относительно необходимая вещь так или иначе), которые, надо надеяться, превращают его в tr2.

• повышение:: scoped_ptr
• повышение:: scoped_array
• повышение:: shared_array
• повышение:: intrusive_ptr

См.: Интеллектуальные указатели: Или кто владеет Вами ребенок?

Повышение также имеет навязчивый указатель (как решение 1), который не требует наследования ни от чего. Это действительно требует, чтобы изменение указателя на класс сохранило подсчет ссылок и обеспечило соответствующие функции членства. Я использовал это в случаях, где эффективность памяти была важна, и не хотела издержки другого объекта для каждого общего используемого указателя.

Пример:

class Event {
public:
typedef boost::intrusive_ptr<Event> Ptr;
void addRef();
unsigned release();
\\ ...
private:
unsigned fRefCount;
};

inline void Event::addRef()
{
  fRefCount++;
}
inline unsigned Event::release(){
    fRefCount--;
    return fRefCount;
}

inline void intrusive_ptr_add_ref(Event* e)
{
  e->addRef();
}

inline void intrusive_ptr_release(Event* e)
{
  if (e->release() == 0)
  delete e;
}

Определение типа Ptr используется так, чтобы я мог легко switcth между повышением:: shared_ptr <> и повышение:: intrusive_ptr <>, не изменяя клиентского кода

Проблема с 2 может работаться вокруг. Повышение предлагает повышение:: shared_from_this по этой той же причине. На практике это не большая проблема.

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

Я должен был бы сказать, что № 2 является лучшим, просто потому что он может использоваться при любых обстоятельствах.

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

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

void doSomething (NIPtr<int> const &);

void foo () {
  NIPtr<int> i = new int;
  int & j = *i;
  doSomething (&j);          // Ooops - owned by two pointers! :(
}

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

К нашему большому удивлению одна вещь, которую мы действительно замечали, состояла в том, что у нас было непосредственное повышение производительности при помощи навязчивого указателя. Мы не поместили много исследования этого и просто предположили, что различием была стоимость поддержания объекта количества. Возможно, что другие реализации ненавязчивого общего указателя решили эту проблему к настоящему времени.

О чем Вы говорите, навязчивые и ненавязчивые интеллектуальные указатели. Повышение имеет обоих. boost::intrusive_ptr вызывает функцию, чтобы уменьшить и увеличить подсчет ссылок Вашего объекта, каждый раз это должно изменить подсчет ссылок. Это не называет функции членства, но бесплатные функции. Таким образом, это позволяет управлять объектами без потребности изменить определение их типов. И как Вы говорите, boost::shared_ptr ненавязчиво, Ваша категория 2.

У меня есть ответ, объясняя intrusive_ptr: Создание shared_ptr не использует, удаляют. Короче говоря, Вы используете его, если у Вас есть объект, который уже имеет подсчет ссылок или потребность (как Вы объясняете), объект, на который уже ссылаются для владения intrusive_ptr.