Передача std :: shared_ptr конструкторам

Поскольку вас интересует эффективность, я хотел бы отметить два момента:

shared_ptr ‹> - один из многих стандартных типов библиотек, в которых построение перемещения дешевле, чем построение копии. Создание копии shared_ptr происходит медленнее, поскольку копирование требует, чтобы счетчики ссылок увеличивались атомарно, тогда как перемещение shared_ptr вообще не требует касания ссылочных данных или счетчиков. Из статьи «Хотите скорости? Передайте по значению! "Дэйва Абрахамса можно узнать, что в определенных ситуациях действительно полезно принимать параметр функции по значению. Это один из таких случаев:

class Foo
{
  explicit Foo(std::shared_ptr<Stuff> myStuff)
  : m_myStuff(move(myStuff))
  {}

  ...

private:
  std::shared_ptr<Stuff> m_myStuff;
};

Теперь ты можешь писать

Foo f (std::make_shared<Stuff>());

где аргумент является временным, и shared_ptr никогда не копируется (просто перемещается один или два раза).

Использование std :: make_shared здесь имеет то преимущество, что выполняется только одно выделение. В вашем случае вы выделили объект Stuff самостоятельно, и конструктор shared_ptr также должен был динамически выделять счетчики ссылок и удаление. make_shared сделает все за вас всего за одно выделение.

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

std::shared_ptr<Stuff> foosStuff(std::make_shared<Stuff>());

Единственное улучшение, которое вы можете сделать, - это если Foo будет единственным владельцем (т.е. вы не собираетесь хранить foosStuff после создания Foo), тогда вы можете переключиться на использование std :: unique_ptr или boost :: scoped_ptr (что является эквивалент до C ++ 11), что потребовало бы меньших накладных расходов.

Было бы более эффективно иметь помощника make_foo:

Foo make_foo() { return Foo(std::make_shared<Stuff>()); }

Теперь вы можете сказать auto f = make_foo();. Или, по крайней мере, самостоятельно используйте вызов make_shared, поскольку результирующий shared_ptr может быть более эффективным, чем тот, который построен из выражения new. И если Stuff действительно принимает аргументы конструктора, может подойти частный вспомогательный конструктор:

struct Foo
{
    template <typename ...Args>
    static Foo make(Args &&... args)
    {
        return Foo(direct_construct(), std::forward<Args>(args)...);
    };

private:

    struct direct_construct{};

    template <typeaname ...Args>
    Foo(direct_construct, Args &&... args)
    : m_myStuff(std::make_shared<Stuff>(std::forward<Args>(args)...))  // #1
    {  }
};

Вы можете заключить Foo::make в make_foo выше или использовать его напрямую:

auto f = Foo::make(true, 'x', Blue);

Тем не менее, если вы действительно не разделяете право собственности, std::unique_ptr<Stuff> звучит как более предпочтительный подход: он концептуально намного проще, а также несколько более эффективен. В этом случае вы должны указать m_myStuff(new Stuff(std::forward<Args>(args)...)) в строке, помеченной #1.