Take ownership of parameter by rvalue-reference

Question

I want to make clear that the constructor of my class A will take ownership of the passed Data parameter. The obvious thing to do is take a unique_ptr by value:

class A
{
public:
    A(std::unique_ptr<Data> data) : _data(std::move(data)) { }

    std::unique_ptr<Data> _data;
};

However, for my use-case, there is no reason why Data should be a pointer, since a value type would suffice. The only remaining option that I could think of to make really clear that Data will be owned by A is pass by rvalue-reference:

class A
{
public:
    A(Data&& data) : _data(std::move(data)) { }

    Data _data;
};

Is this a valid way to signal ownership or are there better options to do this without using unique_ptr?

@IvanRubinson For mutliple reasons, such as Dependency Injection. — lt.ungustl, Sep 27 '16 at 10:09
well, you answered you own question, yes, move ctor and rvalues in general is the way to go :) — Alexey Andronov, Sep 27 '16 at 10:15
@sfk92fksdf Ok, thanks! Just wanted to make sure, since I have actually never seen rvalues being used this way... — lt.ungustl, Sep 27 '16 at 10:17
If it is not copyable as `std::unique_ptr`, you may take it by value instead of rvalue reference. — Jarod42, Sep 27 '16 at 11:25
So this would have the advantage that move does not have to be called explicitly but Data would still be moved. Or am I missing something else? — lt.ungustl, Sep 27 '16 at 11:33
@angelag No, if `Data` is non-copyable it just means you may take it by-value and there is no danger the caller might make a copy by accident. — Chris Drew, Sep 27 '16 at 13:43

Chris Drew · Accepted Answer · 2016-09-27T10:28:33.850

Yes, I think it is a valid way.

In the case of unique_ptr, it is non-copyable, so there is no danger of someone accidentally making a copy when they didn't intend to so both pass-by-value and pass-by-rvalue-reference signify taking ownership.

In the case of Data, pass-by-rvalue-reference documents that you are taking ownership and there is no danger of the caller accidentally making a copy when they didn't intend to.

score 2 · Answer 2 · answered Sep 27 '16 at 10:03

2

Yes, it's a valid way. You can also pass it by value:

class A {
    A(Data data) : _data(std::move(data)) { }
};
Data data;
A a(std::move(data));

answered Sep 27 '16 at 10:03

for_stack

21,012
4
35
48

3

Of course this is also an option. However, it doesn't enforce to move the object and therefore unnecessary copies could be made. – lt.ungustl Sep 27 '16 at 10:10
2

@angelag In this case, I think pass-by-value might be a better option. If you want `Data` always has only ONE owner, then you should make it non-copyable, and pass `Data` by value works as what you did with `unique_ptr`. Otherwise, i.e. `Data` is copyable, pass-by-value gives the client two choices: copy it or 'move' it. It's more flexible, and sometimes the client might want to keep a copy of `Data` after passing it to `A`'s constructor. – for_stack Sep 27 '16 at 12:25

Take ownership of parameter by rvalue-reference

2 Answers2

Linked