Question

In a new piece of code I have several different classes that refer to each other. Something like this (this is not my actual situation but an example of something similar):

class BookManager
   {
   ...
   };

class Book
   {
   public:
      void setBookManager(BookManager *bookManager) {m_bookManager = bookManager;}
   private:
      BookManager *m_bookManager;
   };

Every book refers to a book manager, but the problem is that many books will have its own specific BookManager, but some books may share a common BookManager.

The caller doesn’t really specify what the Book should do with its BookManager, but in about 90% of the cases, the BookManager can be destroyed together with the Book. In about 10% of the cases, the same BookManager is reused for multiple books, and the BookManager must not be deleted with the Book.

Deleting the BookManager together with the Book is handy in those 90% of the cases, as the caller of Book::setBookManager doesn’t need to remember the BookManager anymore. It just dies with the Book itself.

I see two alternative solutions for solving this.

First is to make extensive use of shared pointers. If the caller is not interested anymore in the BookManager afterwards, it doesn’t keep a shared pointer to it. If it is still interested in it, or if it wants the BookManager to be shared over multiple books, it keeps the shared pointer and passes it to those multiple books.

A second alternative is to tell the Book explicitly what to do with the ownership of the book, like this:

class Book
   {
   public:
      void setBookManager(BookManager *bookManager, book takeOwnership=true)
         {
         m_bookManager = bookManager;
         m_hasOwnership = takeOwnership;
         }
      ~Book()
         {
         if (m_hasOwnership && m_bookManager) delete m_bookManager;
         }
   private:
      BookManager *m_bookManager;
      bool m_hasOwnership;
   };

The second solution seems much easier and allows us to use normal pointer syntax (BookManager * as opposed to std::shared_ptr<BookManager>), but it seems less ‘clean’ than the shared pointer approach.

Another alternative might be to have a typedef in BookManager like this:

class BookManager
   {
   public:
      typedef std::shared_ptr<BookManager> Ptr;
      ...
   };

Which allows us to write this:

BookManager::Ptr bookManager;

Which looks more like the the normal pointer-syntax than the original shared pointer syntax.

Does anyone have experience with either approach?
Any other suggestions?

Answer 1

In C++ if you have shared, un-coordinated access to common objects then the most common approach is some kind of reference counting, which you get from shared_ptr.

The only downside is that it isn’t pervasive in C++ (especially libraries), so you sometimes need access to the raw pointer. In those cases, you need to be careful to keep the object alive.

I suggest that if you used shared_ptr — try to use it everywhere, unless it’s impossible. And yes, use the typedef if you want.