Converting std::unique_ptr<Derived> to std::unique_ptr<Base>

Question

Using C++11, let's say I have factory functions dealing with base and derived classes:

#include <memory> using namespace std; struct B { virtual ~B() {} }; struct D : B {}; unique_ptr<B> MakeB() { auto b = unique_ptr<B>( new B() ); return b; // Ok! } unique_ptr<B> MakeD() { auto d = unique_ptr<D>( new D() ); return d; // Doh! }

On the last line above, I need move(d) in order to make it work, otherwise I get "Error: invalid conversion from std::unique_ptr<D> to std::unique_ptr<D>&&." My intuition said that in this context, the compiler should know that it could implicitly make d an rvalue and move it into the base pointer, but it doesn't.

Is this a non-conformancy in my compilers (gcc 4.8.1 and VS2012)? The intended design of unique_ptr? A defect in the standard?

Update: C++14 fixes this. Newer compilers such as GCC 9 accept the original code even with -std=c++11.

@Simple: Do you have a normative reference to back that claim? (If you do, it would be the correct answer here) — Jan Hudec
– Jan Hudec, Commented Feb 25, 2014 at 15:12
@JanHudec 12.8/31 and 12.8/32. Implicit move is specified in terms of the compiler failing to elide in cases where it would be allowed to, and elision is not allowed when the types are different. — Simple
– Simple, Commented Feb 25, 2014 at 15:14

Simple · Accepted Answer · 2014-02-25 15:19:41Z

The compiler's behaviour is correct. There is only an implicit move when the types are the same, because implicit move is specified in terms of the compiler failing to perform copy elision in cases where it is actually allowed (see 12.8/31 and 12.8/32).

12.8/31 (copy elision):

in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object (other than a function or catch-clause parameter) with the same cv-unqualified type as the function return type...

12.8/32 (implicit move):

When the criteria for elision of a copy operation are met, [...], overload resolution to select the constructor for the copy is first performed as if the object were designated by an rvalue.

+1, but note that this has been changed for C++14, DR 1579 was approved at the last meeting.
Thanks, @Simple: That definitively answers the question. And thanks, @JonathanWakely: That confirms my intuition that it should work without the move().

aldo · Accepted Answer · 2014-02-25 17:19:55Z

With the addition of the std::move calls in the return statements, this code works for me on Visual Studio 2013:

#include <memory> using namespace std; struct B { virtual ~B() {} }; struct D : B {}; unique_ptr<B> MakeB() { auto b = unique_ptr<B>( new B() ); return std::move( b ); // *** std::move() added here! *** } unique_ptr<B> MakeD() { auto d = unique_ptr<D>( new D() ); return std::move( d ); // *** std::move() added here! *** }

The following also works

unique_ptr<B> MakeB() { return unique_ptr<B>( new B() ); // *** Returning a temporary! *** } unique_ptr<B> MakeD() { return unique_ptr<D>( new D() ); // *** Returning a temporary! *** }

Of course, if you're returning std::unique_ptr<B> anyway, why not shove the D instance into a std::unique_ptr<B> in the first place? Then there's no conversion necessary at all!

Well, that's even stated in question. The real question is why a std::move() is necessary here.
Sorry. Totally missed that. Oh well. (But hey, it still works in VS2013! Hurray! :-P )
@pepper_chico But the accepted answer says it is conformant!
@aldo the accepted answer says the OP compiler error report is correct behavior, which means, the OP's code is not conformant to standard. what you're saying, it seems, is that allowing the return without errors is right, which currently is not. It's not clear whether you're saying VS2013 is compiling the OP's code or not, it looks like you're Harraying! because it it's.
@pepper_chico I edited my answer to contain code comments emphasizing that I had added the std::move calls (as suggested by the OP) which make the code standard-compliant (which - surprise! - compiles with no error).

Collectives™ on Stack Overflow

Converting std::unique_ptr<Derived> to std::unique_ptr<Base>

2 Answers 2

2 Comments

5 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

5 Comments

Linked

Related