What is a Mixin?

This is mixin as Jannis Smaragdakis calls it.

// Mixin

template <class Base>
class Mixin : public Base  { ... };

class Base { ... };

The interesting thing is, that in normal object-oriented style base is always implemented before derived. Here we can implement inheritance delaying the definition of the base.

//  suppose Graph has succ_node() and succ_edge()
template <class Graph>
class Counting : public Graph
    Counting() : nodes_visited(0), edges_visited(0)  { }
    node succ_node( node v)
        return Graph::succ_node(v);
    node succ_edge( node v)
        return Graph::succ_edge(v);
    int nodes_visited;
    int edges_visited;

Counting< Ugraph >  counted_ugraph;
Counting< Dgraph >  counted_dgraph;

Mixin issues

Be care with the lazy instantiation:

//  be care with lazy instantiation
template <class Sortable>
class WontWork : public Sortable
    void sort(X x)
        Sortable::srot(x);  // !!misspelled
WontWork w;

If the client never calls w.sort there is no error message!

Liskov substitutional principle

In 1977 Barbara Liskov defined her substitutional principle: an object from the subtype can appear in every place where its supertype's objects can. That is one of the most fundamental rule in object-orientation: a derived object can appear everywhere the base object can.

The problem is, that this does not hold for mixins.

lass Base { ... };
class Derived : public base { ... };

template <class T> class Mixin : public T { ... };

Base        b;
Derived     d;

Mixin<Base>     mb;
Mixin<Derived>  md;

b  = d      // OK
mb = md;    // Error!

We have seen a similar situation with auto_ptr. The auto_ptr<Derived> does not konvertible to auto_ptr<Base>.