Question

I was browsing for an alternative to using so many shared_ptrs, and found an excellent reply in a comment section:

Do you really need shared ownership?
If you stop and think for a few
minutes, I’m sure you can pinpoint one
owner of the object, and a number of
users of it, that will only ever use
it during the owner’s lifetime. So
simply make it a local/member object
of the owners, and pass references to
those who need to use it.

I would love to do this, but the problem becomes that the definition of the owning object now needs the owned object to be fully defined first. For example, say I have the following in FooManager.h:

class Foo; 
class FooManager
{
    shared_ptr<Foo> foo;
    shared_ptr<Foo> getFoo() { return foo; }
};

Now, taking the advice above, FooManager.h becomes:

#include "Foo.h"
class FooManager
{
    Foo foo;
    Foo& getFoo() { return foo; }
};

I have two issues with this. First, FooManager.h is no longer lightweight. Every cpp file that includes it now needs to compile Foo.h as well. Second, I no longer get to choose when foo is initialized. It must be initialized simultaneously with FooManager. How do I get around these issues?

Answer 1

You can use a shared_ptr ( or any smart pointer, or even a dumb pointer) but not have shared ownership.

E.g.

class Foo; 
class FooManager
{
  private:
    shared_ptr<Foo> foo;
  public:
    Foo& getFoo() { return *foo; }
};

(This is just a sketch – you still need a setFoo(), and perhaps getFoo() should return a Foo *. But the point is that you’re back to being lightweight, and you can control when foo is created.)