When to use private inheritance

[vineoff]

When to do like this:

class A { ... };
class B : private A { ... };

Thanks.

[Stephan Brönnimann]

vineoff wrote:

When to do like this:

class A { ... };
class B : private A { ... };

Thanks.

If the relationship between A and B is "B has an A" or
B is implemented in terms of A
AND
A has virtual functions (pure or not) that must be
overriden (implemented) in B.

Without the 2nd part it is usually a better choice
if B has a member A and wraps to it.

class B {
public:
void foo()
{
a_.foo();
}
private:
A a_;
};

Regards, Stephan
[e-mail]
Open source rating and billing engine for communication networks.

[Thomas Tutone]

vineoff wrote:

When to do like this:

class A { ... };
class B : private A { ... };

Infrequently. Unlike public inheritance, which indicates an "Is-a"
relationship, private inheritance indicates a "Is-Implemented-With"
relationship. But you can usually use composition instead of private
inheritance to accomplish that:

class B {
A a_;
public:
B();
};

There are always exceptions, of course. If A has virtual functions
that need to be overridden, some would advise having B inherit
privately from A and override those virtual functions. Others would
advise creating a new class, C, that inherits publicly from A and
overrides A's virtual functions, then having class B use composition to
include C:

class A {
virtual void func();
public:
~A();
};

class C : public A {
void func();
};

class B {
C c_;
};

Best regards,

Tom

[red floyd]

vineoff wrote:

When to do like this:

class A { ... };
class B : private A { ... };

Thanks.

Also, there are cases in the Standard Library where classes are designed
to be privately inherited.

Case in point: std::priority_queue

The container embedded in the priority_queue is declared protected, but
the priority_queue itself does not have a virtual destructor, so it is
clearly not intended for public inheritance. However, you can privately
inherit, if you need access to the underlying container.