shared_ptr 和 unique_ptr 转换

Question

我不确定要使用哪种类型的智能指针，因为我不确定我的班级的所有用例。我可以只使用共享指针，但是当我不一定需要共享所有权时，我不喜欢在我的代码中到处传递共享指针的想法。 Herb Sutter 的This article 说，如果有疑问，请使用 unique_ptr 并在必要时转换为 shared_ptr。这是我想做的，但我不清楚应该如何做，请考虑以下示例：

class Example
{
    public:
        Example(): _ptr(std::make_unique<Node>()) {}

        std::unique_ptr<Node>& getPtr() 
        {
            return _ptr;
        }

    private:
        // I am unsure if I will eventually need shared ownership or not
        std::unique_ptr<Node> _ptr;
};

Example* example = new Example();


// Some function somewhere
void f()
{
    // I've decided I need shared ownership, converting
    std::shared_ptr<Node> ptr(std::move(example->getPtr()));

    // Oops, example is no longer valid...
}

如果有人对如何处理此类情况有更好的了解，我会很高兴听到。

Answer 1

我认为您在问一种优化问题。您希望Example 使用unique_ptr，因为它具有更简单和更有效的语义（解释您引用的文章）。但是，当需要时，您希望允许将指针转换为shared_ptr。

Example 应该简单地为此提供一个接口，并且当其用户调用该接口时，它本身需要从unique_ptr 转换为shared_ptr。您可以使用状态模式来捕获实例是处于unique_ptr 模式还是shared_ptr 模式。

class Example
{
    struct StateUnique;
    struct StateShared;
    struct State {
        State (std::unique_ptr<State> &s) : _state(s) {}
        virtual ~State () = default;
        virtual Node & getPtr () = 0;
        virtual std::shared_ptr<Node> & getShared() = 0;
        std::unique_ptr<State> &_state;
    };
    struct StateUnique : State {
        StateUnique (std::unique_ptr<State> &s)
            : State(s), _ptr(std::make_unique<Node>()) {}
        Node & getPtr () { return *_ptr.get(); }
        std::shared_ptr<Node> & getShared() {
            _state = std::make_unique<StateShared>(*this);
            return _state->getShared();
        }
        std::unique_ptr<Node> _ptr;
    };
    struct StateShared : State {
        StateShared (StateUnique &u)
            : State(u._state), _ptr(std::move(u._ptr)) {}
        Node & getPtr () { return *_ptr.get(); }
        std::shared_ptr<Node> & getShared() { return _ptr; }
        std::shared_ptr<Node> _ptr;
    };
public:
    Example(): _state(std::make_unique<StateUnique>(_state)) {}
    Node & getNode() { return _state->getPtr(); }
    std::shared_ptr<Node> & getShared() { return _state->getShared(); }
private:
    std::unique_ptr<State> _state;
};

如果状态机看起来很吓人（它应该是这样，因为它被过度设计了），那么你可以只在Example 中维护两个指针，以及需要测试它需要使用哪一个的方法。

class Example
{
public:
    Example(): _u_node(std::make_unique<Node>()) {}
    Node & getNode() { return _u_node ? *_u_node.get() : *_s_node.get(); }
    std::shared_ptr<Node> & getShared() {
        if (_u_node) _s_node = std::move(_u_node);
        return _s_node;
    }
private:
    std::unique_ptr<Node> _u_node;
    std::shared_ptr<Node> _s_node;
};

Answer 2

如果你有一个类，比如UniqueResourceHolder，它可能实现如下：

class UniqueResourceHolder{
public:
  std::unique_ptr<Widget> ptr;
};

稍后，如果您想从UniqueResourceHolder 获取所述资源并将其放入SharedResourceHolder 中，如下所示：

class SharedResourceHolder{
public:
  std::shared_ptr<Widget> ptr;
};

执行此操作的代码可能如下所示：

{
  UniqueResourceHolder urh;
  SharedResourceHolder srh;
  //initialization of urh.ptr

  srh.ptr = std::shared_ptr<Widget>(urh.release());
}

UniqueResourceHolder 将不再拥有曾经的Widget，因此任何使用urh 获取小部件的尝试都将无效（除非您用新的小部件重新填充它），但现在srh将拥有该小部件并愿意分享。无论如何，这就是我理解您提供的链接中问题的答案的方式。我自己的两分钱是用std::shared_ptr替换出现的std::unique_ptr也是一件小事；您的程序遵循的任何业务逻辑以确保资源的唯一性仍然有效，但是从您利用std::shared_ptr 的共享性质的业务逻辑出发需要一些时间并专注于重新设计独特的思维方式。

Answer 3

共享指针用于共享资源。如果你想共享资源，我会从一开始就声明所有共享的东西，而不是经过特殊的转换。

如果您想使用唯一指针，您是在说“必须”只存在一个指针用于您分配的资源。这不会限制您使用这些对象的方式。为什么不使用唯一指针并通过类实例和函数“移动”您的对象...如果您必须转换为指针，为什么不将其作为唯一指针移动...

关于性能：据说，与原始指针相比，共享指针大约慢了 6 倍。唯一指针的速度大约是原来的两倍。当然，我说的是访问。如果您确实有代码的性能关键部分，您仍然可以获得这些类的原始指针并进行操作。它甚至不必是指针，仍然有 C++ 引用。

我认为你应该决定你的对象是“共享”还是“移动”并继续使用范式，而不是一直转换和更改。

std::unique_ptr<Node>& getPtr() 
{
   return _ptr;
}

不，不。如果您从不同的地方调用它，您将传递多个引用。请改用“移动”运算符（例如使用 type& operator=(type&& other) 之类的声明）并传递您的唯一指针。