Mixins in C++

A desirable property of C++ class libraries is to be able to leave the inheritance hierarchy up to the user of the library. For example, suppose you are writing a UI framework. You have a "Window" class - every window in the system is represented by an object of some subclass of Window. Windows can be animated, scrollable or dockable. Each of these attributes has some data and methods associated with it, so naturally forms a class. But any combination of these attributes also forms a class. So to be fully general your library would have to provide 2n possible classes - clearly not very practical.

A solution is to provide each attribute as a Mixin (the name was inspired by an ice cream parlour near MIT which allowed you to mix in extra items like crumbled cookies and jelly babies into your base ice cream flavour). A Mixin is a template class parameterized on its superclass, like so:

template<class Base> class Animated : public Base { ... }

Then you can specify a class hierarchy like:

Animated -> Scrollable -> Dockable -> Window

as the template class:

Animated<Scrollable<Dockable<Window> > >

The trouble with this is: how do we construct an object of such a type? An object's constructor needs to know how to construct its base class, which means that you'd still need to write 2n constructors. I found a paper which provides a rather convoluted solution using all sorts of macros and template programming wizardry, but I thought of a much simpler way.

All you need to do is have some sort of standard for constructing an object. For example:

template<class Base> class Animated : public Base
    class Params
        friend class Animated;
        Params(typename Base::Params bp, ...) : _bp(bp) { ... }
        typename Base::Params& _bp;
    Animated(Params p) : Base(p._bp) { }

And similar subclasses (with the same name) for all the other mixins and the base flavor class.

Then you can instantiate your composite class as follows:

Animated<Scrollable<Dockable<Window> > >
    window(Animated<Scrollable<Dockable<Window> > >::Params(
        Scrollable<Dockable<Windows> >::Params(
                Window::Params("blat"), "baz"), "bar"), "foo"));

or, if you don't like typing n2 identifiers:

Window::Params wp("blat");
typedef Dockable<Window> D;
D::Params dp(wp, "baz");
typedef Scrollable<D> S;
S::Params sp(dp, "bar");
typedef Animated<S> A;
A:Params ap(sp, "foo");
A window(ap);

You also get the advantage that your calling code says exactly which parameters belong to which mixin, improving type checking (similar to the named parameters construct described in D&E).

2 Responses to “Mixins in C++”

  1. Benjamin says:

    I follow the example up to a point, and for the most part it is very clear, thanks.

    Am I correct in thinking the parameters are out of order in the last two code samples? I.e., shouldn't "foo" or whatever parameters are specifically passed to an Animated come after the Base::Params object passed?

    Also, I'm assuming the ... in your example parameter list is not a syntactic ellipsis (necessarily anyway), but is a placeholder for whatever parameters I might use to initialize an Animated object.

    • Andrew says:

      Ah yes, you were absolutely right about the parameter order - good catch. I've fixed it now.

      Right, the ellipses are placeholders, not variadic function ellipses.

Leave a Reply