Analyzing the problem
The problem is very simple: create a mechanism whereby it's possible to mark a class (say, NotABase
) as being uninheritable, such that attempting to derive a class from that uninheritable class results in a compile-time error of some kind.
To achieve this behaviour we have to set up class NotABase
so that it must do something that classes derived from it cannot do. That implies that we must make use of some property of base classes which is not inherited by their derived classes.
One such property is class friendship. If we made NotABase
the only friend of some special class (say, Uninheritable
) then no class derived from NotABase
can (directly) access the private members of Uninheritable
.
If we then arrange that those derived classes must access some such private member of Uninheritable
, the derived classes immediately become invalid.
The most obvious way of making the derived classes access a private member of Uninheritable
is to make Uninheritable
's constructor private, and then make NotABase
inherit Uninheritable
. NotABase
itself can call Uniheritable
's private constructor (being a friend), but classes derived from NotABase
cannot directly call that constructor (because the friendship isn't inherited).
Such an arrangement looks something like this:
class Uninheritable
{
friend class NotABase;
private:
Uninheritable(void) {}
};
class NotABase: public Uninheritable
{
// WHATEVER
};
class NotADerived: public NotABase
{
// WHATEVER ELSE
};
Unfortunately, this does not generate the hoped-for compile-time errors, because NotADerived
's constructor only calls the (public) constructor for NotABase
, which in turn calls the (private, but friendly-to-NotABase
) constructor for Uninheritable
. All of which is perfectly legal.
To make this idea work (or rather, to make it not work), we need to arrange for the constructor of NotADerived
to try and call Uninheritable::Uninheritable()
directly.
Virtual inheritance to the rescue
Fortunately, the rules of virtual inheritance (TDCS, § 12.1) require that a virtual base class's constructor is directly invoked by the most derived class. Hence, if Uninheritable
were a virtual base class of NotABase
, then the NotADerived
constructor would have to call Uninheritable::Uninheritable()
directly (rather than indirectly through NotABase
) and the code would be invalid.
This is relatively easy to arrange - we simply make NotABase
virtually inherit from Uninheritable
:
class Uninheritable
{
friend class NotABase;
Uninheritable(void) {}
};
class NotABase: virtual public Uninheritable
{
// WHATEVER
};
class NotADerived: public NotABase
{
// WHATEVER ELSE
};
Now NotADerived
(or any other class derived from NotABase
!) is obliged to call the Uninheritable
constructor directly, which it can't do, not being a friend. Therefore classes derived from NotABase
can never compile.
Generalizing Uninheritable
The above technique works well provided we only ever want to make one class (namely, NotABase
) uninheritable. If we want to create many such classes we need a more general solution.
What we would like is a mechanism that automatically creates special "Uninheritable
-like" classes to order. These special classes would declare friendship to the specific classes which were to be made uninheritable, and those specific classes would then become uninheritable by virtually inheriting from the automatically-generated "Uninheritable
-like" classes (!)
This merry-go-round of class relationships is reminiscent of the class hierarchy in "Topic 4: Self Linking Lists", and the solution - "recursive" inheritance through a template - is the same:
template <class OnlyFriend>
class Uninheritable
{
friend class OnlyFriend;
Uninheritable(void) {}
};
class NotABase : virtual public Uninheritable<NotABase>
{
// WHATEVER
};
class NotADerived: public NotABase
{
// THIS CLASS GENERATES A COMPILER ERROR
};
class AnotherUninheritable
: virtual public Uninheritable<AnotherUninheritable>
{
// WHATEVER
};
// ETC.
Now, to create a class X
which cannot be inherited from, we simply ensure that X
(virtually) inherits from Uninheritable<X>
.
Note that classes like Uninheritable
(and SelfLinking
) are known as mixins¤, because they "mix-in" some additional useful property, independent from any other behaviour of the class which inherits them.