Comprendre les mixins : une approche modulaire des extensions de classe

Un mixin est un modèle de conception logicielle qui permet la composition de plusieurs classes, fournissant un moyen d’étendre les capacités d’une classe de base sans en hériter directement. Cette technique est souvent appelée « sous-classes abstraites » car elle ressemble au concept d'héritage mais avec une approche plus flexible et granulaire.

Pour comprendre le fonctionnement d'un mixin, examinons l'exemple suivant :

// Number class
struct Number {
    int n;

    void set(int v) { n = v; }
    int get() const { return n; }
};

// Undoable mixin
template 
struct Undoable : public BASE {
    int before;

    void set(int v) {
        before = BASE::get();
        BASE::set(v);
    }

    void undo() { BASE::set(before); }
};

Dans cet exemple, le mixin Undoable fournit la fonctionnalité permettant d'annuler l'ensemble de valeurs précédent. Il s'enroule essentiellement autour d'une classe BASE, permettant à n'importe quelle classe d'en hériter et d'avoir la possibilité d'annuler sa méthode set.

Pour composer une nouvelle classe combinant plusieurs mixins, nous pouvons utiliser la métaprogrammation de modèles :

// ReUndoableNumber class
typedef Undoable UndoableNumber;
typedef Redoable ReUndoableNumber;

Dans ce cas, ReUndoableNumber hérite des mixins Undoable et Redoable et acquiert la possibilité d'annuler et de refaire ses valeurs définies.

Les mixins sont particulièrement utiles lorsque nous souhaitez étendre les classes existantes avec des fonctionnalités orthogonales qui peuvent ne pas être pertinentes pour le comportement principal de la classe. Ils offrent une approche plus modulaire et composable par rapport à l'héritage traditionnel, dans lequel les classes doivent directement hériter d'une classe parent pour obtenir ses fonctionnalités.

De plus, les mixins permettent la création de blocs de construction réutilisables qui peuvent être facilement combinés pour former des classes plus complexes. Cette flexibilité permet aux développeurs d'adapter leurs classes aux fonctionnalités spécifiques dont ils ont besoin, sans les contraintes de l'héritage traditionnel.