shared_ptr vs unique_ptr uses in classes and children

Question

I've stared using smart pointer and trying to wrap my head around best uses for it. I've read plenty of articles but I'm confused on which to use in the following example. I've included a shared_ptr and unique_ptrexamples to show what I'm trying to accomplish:

class A
    public:  
        A();
    private:
        unique_ptr<B> ptrB;

    unique_ptr<SomeObject> ptrUnique;
    shared_ptr<SomeObject> ptrShared;

    A::A()
    {
        ptrB(new B());

        ptrUnique(new SomeObject());
        ptrB->PassUnique(ptrUnique);

        ptrShared(new SomeObject());
        ptrB->PassShared(ptrShared);
    }

class B:
    public:
        void PassUnique(unique_ptr<SomeObject> &ptr_unique);
        void PassShared(weak_ptr<SomeObject> &ptr_weak);
        void DoSomething();
    private:
        unique_ptr<SomeObject> ptrUnique;
        weak_ptr<SomeObject> ptrWeak;

    B::PassUnique(unique_ptr<SomeObject> &ptr_unique)
    {
        ptrUnique = ptr_unique;
    } 

    B::PassShared(weak_ptr<SomeObject> &ptr_weak)
    {
        ptrWeak = ptr_weak;
    }

    B::DoSomething()
    {
        ptrUnique->SomeMethod();

        shared_ptr<SomeObject> ptr1 = ptrWeak.lock();
        ptr1->SomeMethod();
    }

SomeObject class can be any class. A good example is a database handle that I pass from the parent class A were it was originally initiated to multiple class like B. And from B to C if it exists. My question is if I'm passing a unique_ptr as a reference will setting for example ptrUnqiue = ptr_unique in B:PassUnique create a copy which then is not correct? Or should this be done via shared_ptr? This understanding is what is confusing with smart pointers for me and would appreciate clarification.

Answer 1

Well, this is a question of lifetime. Do you need SomeObject to outlive A? Do B send or is being use outside of this context? You have to decide when your objects dies. If you think SomeObject exists only in this context, I would recommend A to be the owner, as it allocate the resource, and be to old a raw pointer to SomeObject. I would look like this:

class A
   public:  
     A();
   private:
     unique_ptr<B> ptrB;

     unique_ptr<SomeObject> ptrUnique;
};

A::A()
{
  ptrB(new B());

  ptrUnique(new SomeObject());
  ptrB->PassUnique(*ptrUnique);
}

class B:
  pubic:
    void PassUnique(SomeObject& obj);
    void DoSomething();
  private:
    SomeObject* ptrUnique;
};

B::PassUnique(SomeObject& obj)
{
   ptrUnique = &obj;
} 

B::DoSomething()
{
   ptrUnique->SomeMethod();
}

There is no such thing as

ptrUnique = ptr_unique;

If you need SomeObject to be used and owned outside of this structure, then go with std::shared_ptr like you did. There were no errors with your std::shared_ptr code.