派生的 class 的智能指针如何隐式转换为基本 class？

Question

From cppreference ,

If T is a derived class of some base B , then std::unique_ptr<T> is implicitly convertible to std::unique_ptr<B>

which it obviously must be for polymorphism to work as it does with raw pointers. My question is, if a smart pointer is not generally convertible to a pointer as we can see here , then what is the mechanism used by the smart pointer to allow for runtime polymorphism? My thinking is that either in a constructor or std::make_unique<>() / std::make_shared<>() the internal pointer in the object is used for this conversion. But if these implicit conversions aren't allowed anywhere else, why don't we have to call get() when constructing our smart pointers?

As a very simple example I came up with the following test:

#include <iostream>
#include <memory>

class Base
{
public:
    virtual ~Base() = default;

    virtual void foo() const { std::cout << "Base foo() called." << std::endl; }
};

class Derived : public Base
{
public:
    virtual void foo() const override { std::cout << "Derived foo() called." << std::endl; }
};

void bar(Base* pBase) 
{
    std::cout << "bar() called." << std::endl;
    pBase->foo();
}

int main()
{
    std::unique_ptr<Base> pObject { std::make_unique<Derived>() };      // Implicit conversion here, why no call to get()?

    // bar(pObject);                                                    // Can't be converted, so we have to call get()
    bar(pObject.get());
}

Answer 1

My question is, if a smart pointer is not generally convertible to a pointer as we can see here, then what is the mechanism used by the smart pointer to allow for runtime polymorphism?

Smart pointers are explicitly designed to make such conversion possible. As you can see in std::unique_ptr constructors documentation :

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

this overload is created for this purpose.

This constructor only participates in overload resolution if all of the following is true:

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

b) U is not an array type

c) Either Deleter is a reference type and E is the same type as D, or Deleter is not a reference type and E is implicitly convertible to D

emphasis is mine. So as pointer to derived class is implicitly convertible to base this constructor overload makes such conversion possible.

Answer 2

The returned pointer from .get() does not transfer ownership to the caller (that would be .release() ).

If you use the pointer from .get() to construct another smart-pointer you will get a double-free.

So this is an error:

std::unique_ptr<Base> pObject { std::make_unique<Derived>().get() };

this works

std::unique_ptr<Base> pObject { std::make_unique<Derived>().release() };

And for shared_ptr constructing from both .get() and .release() is wrong because you could have other instances having the same shared-state that you're not tranferring. So you would potentially end up with two smart-pointers to the same pointer but with a different shared-state.