拥有一个带有原始指针访问器的unique_ptr成员是不好的做法吗？

Question

I have a class that has a unique_ptr member, and this class retains sole ownership of this object. However, external classes may require access to this object. In this case, should I just return a raw pointer? shared_ptr doesn't seem to be correct because that would imply that the accessing class now shares ownership of that memory, whereas I want to make it clear that the original class is the sole owner.

For example, perhaps I have a tree class that owns a root node. Another class may wish to explore the tree for some reason, and requires a pointer to the root node to do this. A partial implementation might look like:

class Tree
{    
public:
    Node* GetRoot()
    {
        return m_root.Get();
    }

private:
    std::unique_ptr<Node> m_root;
};

Is this bad practice? What would a better solution be?

Answer 1

A more normal implementation might be for the Tree to expose iterators or provide a visit mechanism to explore the tree, rather than exposing the implementation details of the Tree itself. Exposing the implementation details means that you can never change the tree's underlying structure without risk of breaking who-knows-how-many clients of that code.

If you absolutely insist there's a need for this, at least return the pointer as const , such as const Node* GetRoot() const because external clients should absolutely not be mutating the tree structure.

Answer 2

Scott Meyers, Effective C++ Item 15 says yes, although the primary reason is for interactivity with legacy code. If you are in a controlled environment - eg a startup where there is little legacy code and it's easy to extend a class as needed or in a homework assignment - there may be little need and it may only encourage using the class incorrectly. But the more reusable approach is to expose raw resources.

Answer 3

Keep in mind that when people say "avoid pointers" they really mean "use ownership semantics", and that pointers are not inherently bad.

Returning a non-owning pointer is an acceptable way of getting references that may also be null and isn't anymore dangerous than the alternatives. Now, in your case this would only make sense if your tree was meant to be used as a tree , rather than using a tree internally such as std::map does.

It's uncommon to do this though as usually you'll want the pointers and resources abstracted away.