How to return a smart pointer to a member variable?

Question

I'm attempting to create an accessor for a class member variable using smart pointers. Here's the code:

class MyResource
{
};

class MyClass
{
public:
    std::unique_ptr<MyResource> getResource();
private:
    std::unique_ptr<MyResource> resource;
};

std::unique_ptr<MyResource> MyClass::getResource()
{
    return this->resource;
}

The error I get trying to compile this:

cannot access private member declared in class 'std::unique_ptr<_Ty>'

Adding .get to this->resource of course doesn't work because the return type changes.

Should I not be using a unique_ptr here? Is this just a syntax issue? Am I totally on the wrong track?

my background with smart pointers: I've been using plain-old-pointers for a couple of years now in part because I can't find a solid explanation of when to use which types of smart pointers and how to go about using them. I'm tired of making excuses, so I'm just diving in. I think I understand what smart pointers are and why to use them, but I understand very little of the details. At the moment I'm totally lost in the endless Q&A about smart pointers.

you shouldn't be using a unique pointer here. Return it by value or make it a shared pointer. — dwcanillas, Apr 07 '15 at 18:50
@Angew yep, exactly. The whole point of unique pointers are that they are unique, there is one pointer to one object. — dwcanillas, Apr 07 '15 at 18:52
@OP You are aware that `std::unique_ptr MyClass::getResource()` would transfer ownership to the caller? That's most probably not what you wan't, unless designing a factory. — πάντα ῥεῖ, Apr 07 '15 at 18:53
Note: You can not transfer ownership without a std::move (std::forward), see Barry's answer — , Apr 07 '15 at 19:00

score 30 · Accepted Answer · answered Apr 07 '15 at 18:57

The most important thing to understand about smart pointers is that the "pointer" aspect is not the fundamental part of their semantics. Smart pointers exist to represent ownership. Ownership is defined as the responsibility for cleanup.

A unique pointer says: "I am the sole owner of the pointee. I will destroy it when I go out of scope."

A shared pointer says: "I am one of a group of friends who share the responsibility for the pointee. The last of us to go out of scope will destroy it."

(In a modern C++ program,) A raw pointer or reference says: "I do not own the pointee, I merely observe it. Someone else is responsible for destroying it."

In your case, using a unique_ptr for the member type means that MyClass owns the MyResource object. If the getter is supposed to transfer ownership (that is, if the MyClass is giving up the resource to whoever called the getter), returning a unique_ptr is appropriate (and you'll have to return std::move(resource); to make the ownership transfer explicit).

If the getter is not supposed to give up the ownership (which I consider the likely scenario), just return a plain old pointer (if returning a null pointer is an option) or a plain old reference (if returning null is not an option).

While the other answer has received more votes, this answer was the most helpful to me personally because of the explanation. Now I think (I gorram hope) that I finally understand this. — Logical Fallacy, Apr 07 '15 at 19:54
@David Which is precisely why SO has both the concepts of voting and accepting :-) Happy to have helped. — Angew is no longer proud of SO, Apr 07 '15 at 19:56
For the third case, we will soon also have `std::experimental::observer_ptr`. — T.C., Apr 07 '15 at 23:23

score 21 · Answer 2 · edited Apr 07 '15 at 18:56

21

You have several options here, depending on the semantics you wish your class to observe.

You want to give up ownership of your resource:

std::unique_ptr<MyResource> MyClass::releaseResource() {
    return std::move(this->resource);
}

You want to maintain unique ownership, but have somebody else use it:

MyResource& MyClass::getResource() {
    assert(this->resource);
    return *(this->resource);
}

You want to share ownership, so the resource doesn't get destroyed if MyClass goes out of scope: switch everything to std::shared_ptr<MyResource> and still return by value.

edited Apr 07 '15 at 18:56

πάντα ῥεῖ

83,259
13
96
175

answered Apr 07 '15 at 18:53

Barry

247,587
26
487
819

You were faster, have a +1 :-) – Angew is no longer proud of SO Apr 07 '15 at 19:00

How to return a smart pointer to a member variable?

2 Answers2