使用智能指针变得聪明：避免 shared_ptr 过度使用

Question

我遇到过类似的代码

bool open_resource(..., shared_ptr<resource> & res)
{
   ...
   shared_ptr<resource> newResource(new resource(...));
   res = move(newResource);
   return true;
}

然后用

调用

shared_ptr<resource> res;
open_resource(..., res);

然后，据我所见， res 不以需要共享指针的方式使用。

当然我马上就想到了改变

   shared_ptr<resource> newResource(new resource(...));
   res = move(newResource);

与

res = make_shared<resource>(...)

...但后来我遇到了障碍。现在我不能再建议将 shared_ptr 引用更改为更基本的东西了；至少如果我想确保，如果调用者稍后确实需要一个 shared_ptr，则控制块有效地驻留在与对象相同的分配上。为此，它必须从一开始就是一个 shared_ptr。

另一方面，shared_ptr 是一个“重”类型；它有两个计数器和别名以及在大多数呼叫站点中似乎确实不需要的各种功能。然而，如果它是签名中的 shared_ptr，他们必须使用。

我看到的最佳解决方案是将函数体移动到辅助函数，然后重载。

bool get_resource_parameters(Param1& param1,..., ParamN& paramN)
{
   ...
}

bool open_resource(..., shared_ptr<resource> & res)
{
   Param1 param1;
   ...
   ParamN paramN;
   if(!get_resource_parameters(param1,...,paramN))
       return false;

   res = make_shared<resource>(param1,...,paramN);
   return true;
}

bool open_resource(..., unique_ptr<resource> & res)
{
   Param1 param1;
   ...
   ParamN paramN;
   if(!get_resource_parameters(param1,...,paramN))
       return false;

   res = unique_ptr<resource>(new resource(param1,...,paramN));
   return true;
}

但是真的不满意。

有没有人看到更好、更 C++ 的解决方案？

编辑

是的，C++ 方法是返回指针而不是布尔值（并检查空值）。在这种情况下，我无法为 shared_ptr 重载，但我可以将返回的 unique_ptr 临时分配给 shared_ptr 变量，并且适当的构造函数将对其进行转换。

但是，这样我就失去了make_shared的单一分配。我可以保存吗？

Answer 1

std::shared_ptr 有一个converting constructor from std::unique_ptr。为什么不让函数按值返回std::unique_ptr：

unique_ptr<resource> open_resource(...);

这也可以作为文档说明这是一个工厂函数，它将resource 的所有权转移给调用者。

让调用者决定他们想要的方式：

auto x = open_resource(...);
// or
std::shared_ptr<resource> x{open_resource(...)};

Answer 2

致allow unique_ptr/shared_ptr，您可以使用模板：

// Dispatcher for make_unique/make_shared
template <template <typename...> class Ptr, typename T>
struct make_helper;

template <typename T>
struct make_helper<std::unique_ptr, T>
{
    template <typename ...Ts>
    std::unique_ptr<T> operator() (Ts&&... args) const {
        return std::make_unique<T>(std::forward<Ts>(args)...);
    }
};

template <typename T>
struct make_helper<std::shared_ptr, T>
{
    template <typename ...Ts>
    std::shared_ptr<T> operator() (Ts&&... args) const {
        return std::make_shared<T>(std::forward<Ts>(args)...);
    }
};

template <template <typename...> class Ptr, typename T, typename ... Ts>
auto make(Ts&&... args)
{
    return make_helper<Ptr, T>{}(std::forward<Ts>(args)...);
}

然后

bool get_resource_parameters(Param1& param1,..., ParamN& paramN)
{
    //...
}

template <template <typename...> class Ptr>
Ptr<resource> open_resource(...)
{
   Param1 param1;
   ...
   ParamN paramN;
   if(!get_resource_parameters(param1, ..., paramN))
       return nullptr;

   return = make<Ptr, resource>(param1, ..., paramN);
}

并检查 nullptr 而不是 split bool 和 smart_pointer。