How can I pass std::unique_ptr into a function

Question

How can I pass a std::unique_ptr into a function? Lets say I have the following class:

class A
{
public:
    A(int val)
    {
        _val = val;
    }

    int GetVal() { return _val; }
private:
    int _val;
};

The following does not compile:

void MyFunc(unique_ptr<A> arg)
{
    cout << arg->GetVal() << endl;
}

int main(int argc, char* argv[])
{
    unique_ptr<A> ptr = unique_ptr<A>(new A(1234));
    MyFunc(ptr);

    return 0;
}

Why can I not pass a std::unique_ptr into a function? Surely this is the primary purpose of the construct? Or did the C++ committee intend for me to fall back to raw C-style pointers and pass it like this:

MyFunc(&(*ptr));

And most strangely of all, why is this an OK way of passing it? It seems horribly inconsistent:

MyFunc(unique_ptr<A>(new A(1234)));

There is nothing wrong with "falling back" to raw C-style pointers as long as they are non-owning raw pointers. You might prefer to write 'ptr.get()'. Although, if you don't need nullability a reference would be preferred. — Chris Drew, Jun 18 '15 at 04:51

score 167 · Accepted Answer · answered Jun 18 '15 at 02:33

167

There's basically two options here:

Pass the smart pointer by reference

void MyFunc(unique_ptr<A> & arg)
{
    cout << arg->GetVal() << endl;
}

int main(int argc, char* argv[])
{
    unique_ptr<A> ptr = unique_ptr<A>(new A(1234));
    MyFunc(ptr);
}

Move the smart pointer into the function argument

Note that in this case, the assertion will hold!

void MyFunc(unique_ptr<A> arg)
{
    cout << arg->GetVal() << endl;
}

int main(int argc, char* argv[])
{
    unique_ptr<A> ptr = unique_ptr<A>(new A(1234));
    MyFunc(move(ptr));
    assert(ptr == nullptr)
}

answered Jun 18 '15 at 02:33

Bill Lynch

72,481
14
116
162

@VermillionAzure: The feature you are referring to is normally called noncopyable, not unique. – Bill Lynch Jun 18 '15 at 02:35
1

Thanks. In this case I wanted to create an instance, perform some actions on it and then pass off ownership to someone else, which move() seems perfect for. – user3690202 Jun 18 '15 at 02:42
7

You should only pass a `unique_ptr` by reference if the function might or might-not move from it. And then it should be an rvalue reference. To observe an object without requiring anything about its ownership semantics, use a reference like `A const&` or `A&`. – Potatoswatter Jun 18 '15 at 03:56
17

Listen to Herb Sutters talk on CppCon 2014. He strongly discourages, to pass references to unique_ptr<> . The essence is, that you should just use smart pointers like unique_ptr<> or shared_ptr<> when you deal with ownership. See www.youtube.com/watch?v=xnqTKD8uD64 Here you can find the slides https://github.com/CppCon/CppCon2014/tree/master/Presentations/Back%20to%20the%20Basics!%20Essentials%20of%20Modern%20C%2B%2B%20Style – schorsch_76 Jun 18 '15 at 05:43
Is `assert(ptr == nullptr)` necessary? – Eliad Jun 18 '15 at 07:32
2

@Furihr: It's just a way of showing what the value of `ptr` is after the move. – Bill Lynch Jun 18 '15 at 14:35
@AdamGetchell the fact that you got segfaults doesn't mean std::move() must always be avoided, it means you aren't completely grokking what unique_ptr is and what std::move is for, and are using them incorrectly. "Eradicating std::move() wherever you find it" is just as much of a footgun as keeping it and using it incorrectly. You should use it where you need it, and don't use it where you don't need it. – MadScientist Mar 05 '19 at 13:52

Mark Tolonen · Answer 2 · 2015-06-18T14:05:31.460

36

You're passing it by value, which implies making a copy. That wouldn't be very unique, would it?

You could move the value, but that implies passing ownership of the object and control of its lifetime to the function.

If the lifetime of the object is guaranteed to exist over the lifetime of the call to MyFunc, just pass a raw pointer via ptr.get().

edited Jun 18 '15 at 14:05

answered Jun 18 '15 at 02:36

Mark Tolonen

132,868
21
152
208

Is the overhead of passing a ```unique_ptr``` by reference significant to warrant this call to ```ptr.get()``` and exposing the raw pointer? – User 10482 Feb 15 '21 at 00:51
@User10482 See the comment on the question itself: "There is nothing wrong with "falling back" to raw C-style pointers as long as they are non-owning raw pointers. You might prefer to write 'ptr.get()'. Although, if you don't need nullability a reference would be preferred." and the comment about Herb Sutter discouraging passing references to unique_ptr in the accepted answer. – Mark Tolonen Feb 15 '21 at 01:00

R Sahu · Answer 3 · 2018-03-19T02:33:48.507

Why can I not pass a unique_ptr into a function?

You cannot do that because unique_ptr has a move constructor but not a copy constructor. According to the standard, when a move constructor is defined but a copy constructor is not defined, the copy constructor is deleted.

12.8 Copying and moving class objects

...

7 If the class definition does not explicitly declare a copy constructor, one is declared implicitly. If the class definition declares a move constructor or move assignment operator, the implicitly declared copy constructor is defined as deleted;

You can pass the unique_ptr to the function by using:

void MyFunc(std::unique_ptr<A>& arg)
{
    cout << arg->GetVal() << endl;
}

and use it like you have:

or

void MyFunc(std::unique_ptr<A> arg)
{
    cout << arg->GetVal() << endl;
}

and use it like:

std::unique_ptr<A> ptr = std::unique_ptr<A>(new A(1234));
MyFunc(std::move(ptr));

Important Note

Please note that if you use the second method, ptr does not have ownership of the pointer after the call to std::move(ptr) returns.

void MyFunc(std::unique_ptr<A>&& arg) would have the same effect as void MyFunc(std::unique_ptr<A>& arg) since both are references.

In the first case, ptr still has ownership of the pointer after the call to MyFunc.

score 6 · Answer 4 · edited Jun 18 '15 at 03:43

6

Why can I not pass a unique_ptr into a function?

You can, but not by copy - because std::unique_ptr<> is not copy-constructible.

Surely this is the primary purpose of the construct?

Among other things, std::unique_ptr<> is designed to unequivocally mark unique ownership (as opposed to std::shared_ptr<> ).

And most strangely of all, why is this an OK way of passing it?

Because in that case, there is no copy-construction.

edited Jun 18 '15 at 03:43

0x6773

1,077
1
14
31

answered Jun 18 '15 at 02:38

Nielk

551
1
4
18

Thanks for your answer. Just out of interest, can you explain why the last way of passing it isn't using the copy constructor? I would have thought that the use of the unique_ptr's constructor would generate an instance on the stack, which would be copied into the arguments for MyFunc() using the copy constructor? Though I admit my recollection is a little vague in this area. – user3690202 Jun 18 '15 at 02:47
2

As it is an rvalue, the move-constructor is called instead. Though your compiler will certainly optimize this out anyway. – Nielk Jun 18 '15 at 02:53

score 6 · Answer 5 · answered Jun 18 '15 at 08:06

6

As MyFunc doesn't take ownership, it would be better to have:

void MyFunc(const A* arg)
{
    assert(arg != nullptr); // or throw ?
    cout << arg->GetVal() << endl;
}

or better

void MyFunc(const A& arg)
{
    cout << arg.GetVal() << endl;
}

If you really want to take ownership, you have to move your resource:

std::unique_ptr<A> ptr = std::make_unique<A>(1234);
MyFunc(std::move(ptr));

or pass directly a r-value reference:

MyFunc(std::make_unique<A>(1234));

std::unique_ptr doesn't have copy on purpose to guaranty to have only one owner.

answered Jun 18 '15 at 08:06

Jarod42

173,454
13
146
250

This answer is missing what the call to MyFunc looks like for your first two cases. Not sure if you're using `ptr.get()` or just passing the `ptr` into the function? – taylorstine May 31 '18 at 19:03
What is the intended signature of `MyFunc` for passing an r-value reference? – James Hirschorn May 20 '20 at 05:42
@JamesHirschorn: `void MyFunc(A&& arg)` takes r-value reference... – Jarod42 May 20 '20 at 07:51
@Jarod42 That's what I guessed, but with `typedef int A[]`, `MyFunc(std::make_unique(N))` gives the compiler error: error: invalid initialization of reference of type ‘int (&&)[]’ from expression of type ‘std::_MakeUniq::__array’ {aka ‘std::unique_ptr >’} Is `g++ -std=gnu++11` recent enough? – James Hirschorn May 20 '20 at 16:36
@Jarod42 I confirmed failure for C++14 with ideone: https://ideone.com/YRRT24 – James Hirschorn May 20 '20 at 18:21
@JamesHirschorn: Your issue is to create `int (&&)[]`. you might ask a dedicated question about that. – Jarod42 May 20 '20 at 19:11
@Jarod42 My question is whether `std::unique_ptr` can be passed to a function as an r-value reference. Are you suggesting to make a dedicated question for this? – James Hirschorn May 22 '20 at 21:12

0x6773 · Answer 6 · 2015-06-18T03:21:24.140

0

Since unique_ptr is for unique ownership, if you want to pass it as argument try

MyFunc(move(ptr));

But after that the state of ptr in main will be nullptr.

edited Jun 18 '15 at 03:21

answered Jun 18 '15 at 02:33

0x6773

1,077
1
14
31

5

"will be undefined" - no, it will be null, or `unique_ptr` would be rather useless. – T.C. Jun 18 '15 at 02:37

score -1 · Answer 7 · edited Jul 19 '20 at 16:51

-1

Passing std::unique_ptr<T> as value to a function is not working because, as you guys mention, unique_ptr is not copyable.

What about this?

std::unique_ptr<T> getSomething()
{
   auto ptr = std::make_unique<T>();
   return ptr;
}

this code is working

edited Jul 19 '20 at 16:51

Adrian Mole

30,672
69
32
52

answered Jul 19 '20 at 14:32

Riste

1

If that code works then my guess would be that it is not copying the unique_ptr, but in fact using move semantics to move it. – user3690202 Jul 22 '20 at 04:19
1

might be the Return Value Optimization (RVO) I guess – Noueman Khalikine Oct 25 '20 at 02:01

How can I pass std::unique_ptr into a function

7 Answers7

Pass the smart pointer by reference

Move the smart pointer into the function argument

Linked

Related