повысить shared_ptr: разница между оператором = и сбросом?

operator= присваивает shared_ptr shared_ptr, а reset заставляет shared_ptr владеть указателем. Итак, в основном нет никакой разницы между примерами, которые вы опубликовали. Тем не менее, вы не должны отдавать предпочтение ни одному из них и просто использовать make_shared:

foo = boost::make_shared<Blah>();

Кроме того, если возможно, вы можете избежать объявления shared_ptr без инициализации, заключив блок try-catch в отдельную функцию, которая просто возвращает shared_ptr во вновь созданный объект:

boost::shared_ptr<Blah> createBlah() {
    try {
        // do stuff
        return newBlah;
    }
    catch ...
}

operator= принимает еще один shared_ptr в качестве параметра, тем самым создавая еще одну копию (и увеличивая счетчик ссылок), в то время как reset() принимает указатель и, возможно, средство удаления, таким образом, на самом деле создавая новый shared_ptr поверх текущего.

reset эквивалентен (и, вероятно, реализован как)

void reset(T p, D d)
{
   shared_ptr shared(p,d);
   swap( shared );
}

operator=, вероятно, будет реализован как:

shared_ptr& operator=( shared_ptr const& other )
{
   shared_ptr shared(other);
   swap(other);
   return *this;
}

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

foo.reset(p) определяется как эквивалент shared_ptr(p).swap(foo).

Назначение логически эквивалентно копированию и обмену и, возможно, реализовано таким образом. Итак, foo = shared_ptr(p); эквивалентно foo.swap(shared_ptr(p)). Возможно, с дополнительной копией, если у компилятора очень плохой день.

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

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

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

CSharedObj& CSharedObj::operator=(CSharedObj& r) noexcept
{ 
     if(*this != r){
        //detach from the previous ownership
        if(0 == dec()) delete m_pControlObj;
        //attach to the new control object and increment the reference count
        r.inc();
        m_pControlObj = r.m_pControlObj;
    }
    return *this;
}

в то время как вызов сброса не создает новый общий объект, а скорее новое право собственности - присоединение к новому базовому указателю (через объект управления)

void CSharedObj::reset(Ptr pointee) noexcept
{
   //check if this is a last reference-detach from the previous ownership
   if(0==dec()) delete m_pControlObj;
   // create the ownership over the new pointee (refCnt = 1)
   m_pControlObj = new (std::nothrow) CControlObj(pointee);
}