Private inheritance in C++

C++ standard supports three types of inheritance: public, protected and private. Usage of public inheritance is pretty common; but what about the other ones? This post will discuss private inheritance.

What’s the difference between private and public inheritance in C++? Unlike public inheritance, private inheritance is not an “is-a” relationship.

Such piece of code will not compile:

class Base
{
};

class Derived: private Base 
{
};

void doSmthOnBase(const Base& base){}

Derived d;
doSmthOnBase(d); // error !

The compiler will complain about error: ‘Base’ is an inaccessible base of ‘Derived’ doSmthOnBase(d). Of course changing ‘private’ to ‘public’ would allow this code to compile correctly.

Second difference is the scope of derived members/methods: all members and methods from base class (protected and public) will become private in derived class. Private members from base class will not be accessible from derived class.

So what’s the use of private inheritance?

Private inheritance means “has-a” relationship (or: “is implemented in terms of”). Similar to composition, you should use private inheritance when you want to make use of the implementation details of base class, but you do not want to inherit the interface.

When private inheritance is better than composition?

You will have to use private inheritance when you need to have access to protected members/member functions of base class. In other cases almost always you should use composition. Private inheritance will make your code harder to maintain and increase the compilation dependencies (in case of composition, you can use forward declaration and a member-pointer to object).

Empty Base Optimization (EBO)

There is one more specific case when private inheritance can be reasonable: so called Empty Base Optimization. Imagine EmptyClass with zero non-static members and zero virtual functions nor base classes. Composition of EmptyClas will increase the size of OtherClass_composition.

class EmptyClass{};
class OtherClass_composition 
{ 
    private: 
        EmptyClass m_empty; 
        int m_member;
};

But if you use private inheritance:

class OtherClass_inheritance : private EmptyClass
{   
    private: 
        int m_member;
};

the size of OtherClass_inheritance should not increase (but it’s dependant on the compiler). With the use of MinGW 4.9.1 the size of OtherClass_composition was 8, while the size of OtherClass_inheritance was 4.

Read more about private inheritance on isocpp webpage and take a look on Composition over inheritance rule.