shared_ptr and private inheritance

Question

Here's a toy example illustrating a problem I encounter. The application is fairly irrelevant (it's essentially a linked list of elements with a special behavior at the end). I'm unable to construct a base class shared_ptr with a derived pointer and it's for some reason linked to the fact that I'm using private inheritance.

#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>

using namespace std;

// An Item in a linked list
class A
{
public:
  //friend class B;
  typedef boost::shared_ptr<A> APtr;
  A() : next_() {}
  A(APtr n) : next_(n) {}
  APtr next() { return next_; }
  void setNext(APtr n) { next_ = n; }

  virtual void doIt() { /* standard behavior */ }  

private:
  APtr next_;
};


class B : private A // B really is a special A
                    // that should have different behavior
                    // at the tail of the chain
                    // but I want to hide A's interface
                    // to external clients
{
public:
  typedef boost::shared_ptr<B> BPtr;
  B(A::APtr prev) 
  { // Set this object as the tail
    prev->setNext(APtr(this));  /* WHY CAN'T I CONSTRUCT APtr(this) 
                                   WITH PRIVATE INH. */
  }
  void doIt() {/*special behavior at end */}

};

int main()
{
  A::APtr dummyPtr;
  A::APtr head = boost::make_shared<A>(dummyPtr);
  B::BPtr tail = boost::make_shared<B>(head);

  for(A::APtr curr = head; curr; curr=curr->next()){
    curr->doIt();
  }

  return 0;
}

and I get this

/usr/include/boost/smart_ptr/shared_ptr.hpp: In constructor ‘boost::shared_ptr<T>::shared_ptr(Y*) [with Y = B, T = A]’:
derived_shared.cpp:31:   instantiated from here
/usr/include/boost/smart_ptr/shared_ptr.hpp:352: error: ‘A’ is an inaccessible base of ‘B’

I was under the impression that private inheritance allows the Derived class to still access the public interface of the base class but hides that interface to external clients. Why does private inheritance cause this error (it works if I inherit publicly)?

You should read this page http://stackoverflow.com/questions/860339/difference-between-private-public-and-protected-inheritance — Robert Jacobs, Jun 10 '15 at 18:28
friend boost::shared_ptr, but your design is flawed (passing the address of a non dynamically allocated B) — , Jun 10 '15 at 18:29
You should have a look at [enable_shared_from_this](http://www.boost.org/doc/libs/1_58_0/libs/smart_ptr/enable_shared_from_this.html). — Andreas Haferburg, Jun 10 '15 at 18:32
@DieterLücking yes, you are right...that was just an oversight in my toy example...sorry. so I'd make boost::shared_ptr a friend of B or A? — innocent_bystander, Jun 10 '15 at 18:33
@RobertJacobs thank you for your help but can you be more specific as to what portion I should refer to, I feel like I've read through that and understand the concepts of public, private, and protected inheritance. I'm not seeing where I'm going wrong... — innocent_bystander, Jun 10 '15 at 18:34
then what was your intent with the comment: 'friend boost::shared_ptr' — innocent_bystander, Jun 10 '15 at 18:38
@RobertJacobs I guess what I'm saying is that this would work if I used raw pointers — innocent_bystander, Jun 10 '15 at 18:41
@DieterLücking wait, B is dynamically allocated isn't it (make_shared??)...what's the flaw? — innocent_bystander, Jun 10 '15 at 18:51
@innocent_bystander what Dieter means, is that (if inhteritance would be public) head is known as shared_ptr AND as shared_ptr, 2 different shared pointers. When leaving main, both reference count go to 0 and and attempt is made to delete the object twice. The same raw pointer should not be used to create shared pointers of different types. — Christophe, Jun 10 '15 at 18:57
Just as a comment, the standard library now include [`shared_ptr`](http://en.cppreference.com/w/cpp/memory/shared_ptr) and [`make_shared`](http://en.cppreference.com/w/cpp/memory/shared_ptr/make_shared). — Parham, Jun 10 '15 at 19:12

Persixty · Answer 1 · 2015-06-10T20:34:21.763

Change this single line:

prev->setNext(APtr(this));

to

prev->setNext(APtr(static_cast<A*>(this)));

And it compiles.

Or at least it does when using the std library. It is usually similar for boost.

There are other errors but that gets round casting B* to A*.

Why does that work? Because the template for the constructor std::shared_ptr<A> isn't what you think it is! It is more like template <class X> std::shared_ptr(X* v). So the actual B* to A* cast is postponed and failing in a non-friend member.

But if you cast the B* pointer (i.e. this) to A* inside a method of class B (the only place that is legal without a friend declaration) you're in.

NB: There is nothing in principle wrong with private inheritance. It isn't an anti-pattern and is provided for good reason. Do think about composition but objects that forbid some parts of the application from 'accessing' their 'real' type have lots of uses. For example pass out an object A that has some B bolt ons that only the object factory can access.

PS: The reason why the constructor is template<class T> shared_ptr<T* v> is so that shared_ptr uses the deleter of the type passed into it. As you're not doubt aware share_ptr cleverly calls the 'right' destructor even if it isn't virtual. My 'fix' actually subverts that cleverness so beware to pass in the right deleter or (recommended) make the destructor of A virtual.

PPS:

And finally a fully working program (using STL. Sorry I don't have Boost):

#include <iostream>
#include <memory>

// An Item in a linked list
class A
{
public:
  //friend class B;
  typedef std::shared_ptr<A> APtr;
  A() : next_() {}
  A(APtr n) : next_(n) {}
  APtr next() { return next_; }
  void setNext(APtr n) { next_ = n;}

  virtual void doIt() { std::cout<<"normal thing"<<std::endl; }  

  virtual ~A(){}
private:
  APtr next_;
};

class B : public std::enable_shared_from_this<A>, private A // B really is a special A
                    // that should have different behavior
                    // at the tail of the chain
                    // but I want to hide A's interface
                    // to external clients
{
public:
  template<class X> friend class std::enable_shared_from_this;

  typedef std::shared_ptr<B> BPtr;


  static BPtr makeit(A::APtr prev){
    BPtr B(std::make_shared<B>());
    prev->setNext(B->shared_from_this());
    return B;
  } 

  void doIt() {std::cout<<"end thing"<<std::endl;}
private: 
  B(){}
};

int main()
{
  A::APtr dummyPtr;
  A::APtr head = std::make_shared<A>(dummyPtr);
  B::BPtr tail = B::makeit(head);

  for(A::APtr curr = head; curr; curr=curr->next()){
    curr->doIt();
  }

  return 0;
}

You need to use enable_shared_from_this because otherwise you're trying to create two 'families' of shared_ptr and that won't work.

I've made a factory method because fixing the constructor just wouldn't work! There is a precondition of enable_shared_from_this that there has to be a std::shared_ptr in existence and I suppose that means 'fully constructed'.

The following constructor will not work for me:

B(A::APtr prev){
   prev->setNext(shared_from_this());
}

That said, if you do inherit from enable_shared_from_this it's a good idea to make all the constructors private and provide factories that return shared_ptr. Otherwise you can get in a right mess if calling code doesn't itself ensure that 'pre-existing shared_ptr' condition. A nasty piece of coupling if ever there was one.

score 2 · Answer 2 · edited Jun 10 '15 at 18:45

2

When you use private inheritance, you're basically saying "I want B to be implemented in terms of A, but I don't want it to be used like a A (is-a A)"

Here, you're giving boost::shared_ptr a pointer to B as if it was an A.

That's a contradiction in your design. Maybe declaring boost::shared_ptr<A> a friend of B would help, but it's still a weird design.

Additional note: If you want B to be a special A that doesn't expose A's interface, consider composition instead of private inheritance

edited Jun 10 '15 at 18:45

Andreas Haferburg

5,189
3
37
63

answered Jun 10 '15 at 18:36

KABoissonneault

2,359
18
17

Well that's a first thought. However, if you make it protected inheritance, you get the same resutlt. Should'nt members of a class get access to the protected base ? – Christophe Jun 10 '15 at 18:40
2

@Christophe `shared_ptr` is a type completely separate from `B`. If `B` protectedly inherits from `A`, then all the children of `B` will also inherit from `A`, but a separate type like `shared_ptr ` won't know that (unless you make it a friend). – Andreas Haferburg Jun 10 '15 at 18:43
Okay thanks...I guess I am just a bit confused because if you use raw pointers (A* and B*) everything compiles (i.e. I can do prev->next(this) ). I undestand that since shared_ptr is a different object that it doesn't have access to the A constructor. But this then is a non-transparent difference between raw pointer capability and shared_ptr<> [said w/ no judgement...just noting it] – innocent_bystander Jun 10 '15 at 18:50
@innocent_bystander `shared_ptr` doesn't get any special treatment, it's a regular citizen. `shared_ptr` has nothing to do with `A`, same as `vector` has nothing to do with `int`. Casting the `B* this` to an `A*` only works in `B::B()`. If you were to do that anywhere else (i.e. in a non-friend of `B`), say in `main()` or `shared_ptr`, it wouldn't work. – Andreas Haferburg Jun 10 '15 at 18:58

shared_ptr and private inheritance

2 Answers2