GCO4020/CSC428 - Advanced Object Oriented Techniques In C++
Week 4

Sidebar: Preventing Inheritance

Introduction

This sidebar demonstrates a simple technique which can be used to prevent a class from being used as a base class in an inheritance hierarchy.

Synopsis

Analyzing the problem
Virtual inheritance to the rescue
Generalizing Uninheritable

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.