Wie können Mixins die Klassenfunktionalität erweitern, ohne Vererbung zu nutzen?

Mixins: Erweiterung der Klassenfähigkeiten ohne Vererbung

Mixins sind ein Konzept in der objektorientierten Programmierung, das es Entwicklern ermöglicht, die Fähigkeiten von Klassen ohne zu erweitern Verwendung der traditionellen Vererbung. Sie werden oft als „abstrakte Unterklassen“ bezeichnet, weil sie abstrakten Klassen ähneln, aber einen anderen Ansatz für die Komposition bieten.

Um Mixins zu verstehen, bedenken Sie die folgende Situation: Sie haben mehrere orthogonale Konzepte, die Sie als Klassen modellieren möchten . Obwohl jedes Konzept unterschiedlich ist, verfügen sie möglicherweise über Funktionalitäten, die kombiniert werden können, um komplexere Klassen zu erstellen.

Traditionell können Sie dies durch Vererbung erreichen, bei der jedes Konzept zu einer Unterklasse einer gemeinsamen Schnittstellenklasse wird. Dieser Ansatz schränkt jedoch Ihre Fähigkeit ein, diese konkreten Klassen einfach zu neuen Typen zu kombinieren.

Mixins lösen dieses Problem, indem sie eine Reihe primitiver Klassen einführen, die grundlegende orthogonale Konzepte darstellen. Diese Grundelemente dienen als Bausteine, die zu komplexen Klassen mit spezifischen Funktionalitäten zusammengesetzt werden können. Diese Erweiterbarkeit ermöglicht es Ihnen, neue Grundelemente hinzuzufügen, ohne die vorhandenen zu beeinträchtigen.

In C können Mixins mithilfe von Vorlagen und Vererbung implementiert werden. Indem Sie die Bausteine ​​als Vorlagenparameter übergeben, können Sie sie verbinden und über Typedefs miteinander verketten, um neue Typen mit der gewünschten Funktionalität zu bilden.

Beispiel: Rückgängig- und Wiederherstellungsfunktionen

Betrachten wir ein Beispiel für das Hinzufügen von Rückgängig- und Wiederherstellungsfunktionen zu einer Number-Klasse. So könnte eine Mixin-Implementierung aussehen:

<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>

Durch die Kombination der Undoable- und Redoable-Mixins mit der Number-Klasse erstellen wir eine neue Klasse, ReUndoableNumber, die über die Funktionalität zum Rückgängigmachen und Wiederherstellen von Änderungen verfügt. Dies zeigt, wie Mixins die Fähigkeiten einer Klasse ohne traditionelle Vererbung erweitern können.

Das obige ist der detaillierte Inhalt vonWie können Mixins die Klassenfunktionalität erweitern, ohne Vererbung zu nutzen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!