convert std::shared_ptr to const shared_ptr&

Question

If I remember correctly (and according to this question), std::shared_ptr<Derived> cannot be bind to const std::shared_ptr<Base>&. But when I tried the following code, it doesn't give me even any warnings.

#include <memory>
struct A{};
struct B:A{};

void Do(const std::shared_ptr<A>&){}

template<typename T>
struct C{};
void DoC(const C<A>&){}

int main()
{
    std::shared_ptr<B> b = std::make_shared<B>();
    Do(b); //accept ?
    /*following lines generate error
    C<B> c;
    DoC(c); //error
    //*/
}

compiler is mingw g++ 5.3.0 with flag -std=c++14 -Wall -Wextra -pedantic -Werror

Same result with Coliru and many other online compiler.

Is there something I missed?

@KerrekSB I'm not sure I understand. Then why `DoC(c)` gives me error? — apple apple, Mar 15 '17 at 13:04
@appleapple: Because `C` doesn't know how to be converted to `C` (where also `C ` doesn't know how to be constructed from a `C`) they are unrelated whereas `shared_ptr` and `shared_ptr` are not unrelated. — Pixelchemist, Mar 15 '17 at 13:06
@Pixelchemist can you tell me the difference between my question and the question I linked? I cannot find where I missed. — apple apple, Mar 15 '17 at 13:15
There is no difference when it comes to the `shared_ptr` example. I think @KerrekSB got you wrong here. The other question is quite misldeading since you actually *can* convert `shared_ptr` to `shared_ptr const&` (on any up to date compiler i tried) . — Pixelchemist, Mar 15 '17 at 13:28
@Pixelchemist: Yes, true, the comment was too ambiguous anyway. — Kerrek SB, Mar 15 '17 at 13:32

score 4 · Accepted Answer · answered Mar 15 '17 at 13:04

std::shared_ptr has a constructor that allows the conversion from B to A:

(from cppreference)
template< class Y > 
shared_ptr( const shared_ptr<Y>& r );
9) Constructs a shared_ptr which shares ownership of the object managed by r. If r manages no object, *this manages no object too. The template overload doesn't participate in overload resolution if Y* is not implicitly convertible to T*.

DoC(c) gives you an error because you haven't defined a constructor that does the conversion - a similar constructor will not be implicitly generated for you.

score 1 · Answer 2 · answered Mar 28 '22 at 07:00

In addition to what already answered, I'd like to point out what passed to the function is a temporary shared_ptr. The code in question works because it's a constshared_ptr& which can bind a temporary.

#include <memory>
struct A{};
struct B:A{};

void Do(const std::shared_ptr<A>&){}
void DoNo(std::shared_ptr<A>&){}
void DoRvalue(std::shared_ptr<A>&&){}
void DoValue(std::shared_ptr<A>){}

int main()
{
    std::shared_ptr<B> b = std::make_shared<B>();
    Do(b); // a temporary is constructed and passed to Do 
    DoNo(b); // not work, temporary cannot bind to lvalue reference
    DoRvalue(b); // OK, temporary bind to rvalue reference
    DoValue(b); // OK
}

https://godbolt.org/z/sW8cf5ohe

convert std::shared_ptr to const shared_ptr&

2 Answers2

Linked