weak_ptr vs unique_ptr reference - 将接口impl传递给其他对象

Question

Here is an example code:

class Interface
{
public:
    virtual ~Interface(){}
    virtual void fun() = 0;
};

class InterfaceImpl: public Interface
{
public:
    void fun() override
    {}
};

class B
{
public:
    B(const std::shared_ptr<Interface>& impl /*std::unique_ptr<Interface>& impl* ?*/): impl_(impl){}
private:
    std::weak_ptr<Interface> impl_;
    //std::unique_ptr<Interface>& impl_; ?
};

class A
{
public:
    A(): impl_(std::make_shared<InterfaceImpl>()), b(impl_){}
private:
    std::shared_ptr<Interface> impl_;
    //std::unique_ptr<Interface> impl_ ?
    B b;
};

Class A contains an interface implementation and other object of type B. That object also need to use an interface implementation. I wonder which types of smart pointers should be used to create interface impl in class A and pass that impl to class B. Should I use shared_ptr in class A and weak_ptr in class B or unique_ptr in class A and a reference to unique ptr in class B ?

Answer 1

I believe the default choice should be that A , that owns the Interface , should hold it by unique_ptr . Then B , which does not own the Interface , should hold it by normal reference or raw pointer.

A reference to a unique_ptr rarely makes sense. It offers no additional safety guarantees over a raw pointer or a normal reference but adds confusion over ownership.

class Interface
{
public:
    virtual ~Interface(){}
    virtual void fun() = 0;
};

class InterfaceImpl: public Interface 
{

public:
    void fun() override
    {}
};

class B
{
public:
    B(const Interface& impl): impl_(impl){}
private:
    const Interface& impl_;
};

class A
{
public:
    A(): impl_(std::make_unique<InterfaceImpl>()), b(*impl_){}
private:
    std::unique_ptr<Interface> impl_;
    B b;
};

This is assuming the lifetime of B is shorter than the lifetime of A so that B can guarantee that the Interface is alive. If you can't make that guarantee then you can start thinking about shared_ptr and weak_ptr pair but I don't think that should be your first choice. It looks like in your case you can make that guarantee.

As for whether B should hold a normal reference or a raw pointer that comes down to whether impl_ can be null (which doesn't seem to be the case here). Also, holding a reference restricts what you can do with B . It makes it unassignable and you can't reseat the reference to point to a different impl.