Why does unique_ptr<Derived> implicitly cast to unique_ptr<Base>?

Question

I wrote the following code that uses unique_ptr<Derived> where a unique_ptr<Base> is expected

class Base {     int i;  public:     Base( int i ) : i(i) {}     int getI() const { return i; } };  class Derived : public Base {     float f;  public:     Derived( int i, float f ) : Base(i), f(f) {}     float getF() const { return f; } };  void printBase( unique_ptr<Base> base ) {     cout << "f: " << base->getI() << endl; }  unique_ptr<Base> makeBase() {     return make_unique<Derived>( 2, 3.0f ); }  unique_ptr<Derived> makeDerived() {     return make_unique<Derived>( 2, 3.0f ); }  int main( int argc, char * argv [] ) {     unique_ptr<Base> base1 = makeBase();     unique_ptr<Base> base2 = makeDerived();     printBase( make_unique<Derived>( 2, 3.0f ) );      return 0; } 

and i expected this code to not compile, because according to my understanding unique_ptr<Base> and unique_ptr<Derived> are unrelated types and unique_ptr<Derived> isn't in fact derived from unique_ptr<Base> so the assignment shouldn't work.

But thanks to some magic it works, and i don't understand why, or even if it's safe to do so. Can someone explain please?

Answer 1

The bit of magic you're looking for is the converting constructor #6 here:

template<class U, class E> unique_ptr(unique_ptr<U, E> &&u) noexcept; 

It enables constructing a std::unique_ptr<T> implicitly from an expiring std::unique_ptr<U> if (glossing over deleters for clarity):

unique_ptr<U, E>::pointer is implicitly convertible to pointer

Which is to say, it mimicks implicit raw pointer conversions, including derived-to-base conversions, and does what you expect™ safely (in terms of lifetime – you still need to ensure that the base type can be deleted polymorphically).