C++ class design with shared pointers methods [closed]

Question

I dont exactly know, how to handle the problem, where one class uses shared pointers but I want to call its method from inside other class via this pointer.

class Bar {
public:
   Bar() = default;
   ~Bar() = default;

   void OnChange(std::shared_ptr<Foo> foo) { ... }
}


class Foo {
public:
   Foo(std::shared_ptr<Bar> bar) : bar(bar) {};
   ~Foo() = default;

   void Run() { 
      bar->OnChange(this); // <=== this wont work 
   }

private:
   std::shared_ptr<Bar> bar;
}

How can I create "clean" design so that Foo can cann OnChange form Bar?

• Should I use std::enable_shared_from_this for Foo?
• Should I add OnChange(Foo* foo) to Bar?
• Some other solution?

Answer 1

The problem in your design is that shared_ptr is meant to manage memory allocation and destruction of objects if they are no longer used. There is no guarantee in your design that the foo object was allocated dynamically, i.e. that a shared_ptr could be made with this .

For this design to work you must let Foo inherit from enable_shared_from_this<Foo> and return shared_from_this(). The link has an example for using it. But it's a little bit tricky. So here a nice step-by-step explanation about how to use it and the pitfalls to avoid: article

Additional thoughts: The option of using an OnChange(Foo* foo) looks easier but it might weaken your overall design: you might have to repeat yourself as both OnChange() would have to stay aligned. And you'd risk dangling pointers since OnChange() could store a copy of its parameter in a non local place, defeating in some subtle cases the reference counting.