Comment les mixins peuvent-ils étendre les fonctionnalités de classe sans utiliser l'héritage ?

Mixins : extension des capacités des classes sans héritage

Les mixins sont un concept de programmation orientée objet qui permet aux développeurs d'étendre les capacités des classes sans en utilisant l'héritage traditionnel. Ils sont souvent appelés « sous-classes abstraites » car ils ressemblent à des classes abstraites mais offrent une approche différente de la composition.

Pour comprendre les mixins, considérez la situation suivante : Vous disposez de plusieurs concepts orthogonaux que vous souhaitez modéliser en tant que classes. . Bien que chaque concept soit distinct, ils peuvent avoir des fonctionnalités qui peuvent être combinées pour créer des classes plus complexes.

Traditionnellement, vous pouvez y parvenir en utilisant l'héritage, où chaque concept devient une sous-classe d'une classe d'interface commune. Cependant, cette approche limite votre capacité à combiner facilement ces classes concrètes en nouveaux types.

Les mixins résolvent ce problème en introduisant un ensemble de classes primitives qui représentent des concepts orthogonaux de base. Ces primitives servent de blocs de construction qui peuvent être assemblés pour créer des classes complexes dotées de fonctionnalités spécifiques. Cette extensibilité vous permet d'ajouter de nouvelles primitives sans affecter celles existantes.

En C , les mixins peuvent être implémentés à l'aide de modèles et d'héritage. En passant les blocs de construction en tant que paramètres de modèle, vous pouvez les connecter et les enchaîner via des typedefs pour former de nouveaux types avec la fonctionnalité souhaitée.

Exemple : fonctionnalités d'annulation et de rétablissement

Considérons un exemple d'ajout de fonctionnalités d'annulation et de rétablissement à une classe Number. Voici à quoi pourrait ressembler une implémentation de mixin :

<code class="cpp">#include <iostream>
using namespace std;

struct Number {
  typedef int value_type;
  int n;
  void set(int v) { n = v; }
  int get() const { return n; }
};

template <typename BASE, typename T = typename BASE::value_type>
struct Undoable : public BASE {
  typedef T value_type;
  T before;
  void set(T v) { before = BASE::get(); BASE::set(v); }
  void undo() { BASE::set(before); }
};

template <typename BASE, typename T = typename BASE::value_type>
struct Redoable : public BASE {
  typedef T value_type;
  T after;
  void set(T v) { after = v; BASE::set(v); }
  void redo() { BASE::set(after); }
};

typedef Redoable<Undoable<Number>> ReUndoableNumber;

int main() {
  ReUndoableNumber mynum;
  mynum.set(42);
  mynum.set(84);
  cout << mynum.get() << '\n'; // 84
  mynum.undo();
  cout << mynum.get() << '\n'; // 42
  mynum.redo();
  cout << mynum.get() << '\n'; // back to 84
}</code>

En combinant les mixins Undoable et Redoable avec la classe Number, nous créons une nouvelle classe, ReUndoableNumber, qui possède la fonctionnalité permettant d'annuler et de refaire les modifications. Cela démontre comment les mixins peuvent étendre les capacités d'une classe sans héritage traditionnel.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!