Menu
CoddyTech

Mixins mittels CRTP

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy. Lektion 77 von 104.

Das Curiously Recurring Template Pattern (CRTP) ist eine Technik, bei der eine Klasse von einer Vorlagenbasisklasse erbt und sich selbst als Vorlagenargument übergibt. Dies ermöglicht Polymorphie zur Compile-Zeit und erlaubt es Basisklassen, ohne virtuelle Funktionen auf die Member abgeleiteter Klassen zuzugreifen.

Die grundlegende CRTP-Struktur sieht so aus:

template <typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class MyClass : public Base<MyClass> {
public:
    void implementation() {
        std::cout << "MyClass implementation\n";
    }
};

CRTP ist besonders leistungsstark, wenn es darum geht, Mixins zu erstellen – wiederverwendbare Funktionalität, die in Klassen „hineingemischt“ werden kann. Anders als bei herkömmlicher Vererbung fügen Mixins Funktionen hinzu, ohne tiefe Hierarchien zu erzeugen:

template <typename Derived>
class Printable {
public:
    void print() const {
        const Derived& self = static_cast<const Derived&>(*this);
        std::cout << self.toString() << "\n";
    }
};

class Person : public Printable<Person> {
    std::string name;
public:
    Person(const std::string& n) : name(n) {}
    std::string toString() const { return "Person: " + name; }
};

// Verwendung:
Person p("Alice");
p.print();  // Ausgabe: Person: Alice

Der entscheidende Vorteil besteht darin, dass alle Methodenaufrufe zur Kompilierzeit aufgelöst werden, wodurch der Aufwand für virtuelle Funktionen entfällt. Du kannst mehrere CRTP-Mixins kombinieren, um Funktionalität zusammenzustellen. Das macht sie zu einer flexiblen Alternative zur Laufzeitpolymorphie, wenn die Typen zur Kompilierzeit bekannt sind.

challenge icon

Aufgabe

Einfach

Erstellen wir ein Protokollierungssystem, das CRTP-Mixins verwendet, um verschiedenen Klassen wiederverwendbare Funktionalität ohne den Mehraufwand virtueller Funktionen hinzuzufügen. Du erstellst zwei Mixins, die in beliebige Klassen „eingemischt“ werden können: eines zum Zählen von Instanzen und eines zum Erzeugen von Zeichenfolgendarstellungen.

Du organisierst deinen Code auf drei Dateien:

  • Mixins.h: Definiere zwei CRTP-Mixin-Vorlagen, die wiederverwendbare Funktionalität bereitstellen.

    Erstelle eine Countable-Mixin-Vorlage, die erfasst, wie viele Instanzen einer abgeleiteten Klasse existieren. Sie sollte einen statischen Zähler haben, der im Konstruktor erhöht und im Destruktor verringert wird. Stelle eine statische Methode getCount() bereit, die den aktuellen Zählerstand zurückgibt.

    Erstelle eine Describable-Mixin-Vorlage, die eine describe()-Methode bereitstellt. Diese Methode sollte static_cast verwenden, um auf die abgeleitete Klasse zuzugreifen und ihre getDescription()-Methode aufzurufen, und anschließend das Ergebnis gefolgt von einem Zeilenumbruch ausgeben.

    Beachte, dass CRTP-Mixins static_cast<Derived*>(this) verwenden, um zur Kompilierzeit auf die Member der abgeleiteten Klasse zuzugreifen.

  • Entities.h: Definiere zwei Entitätsklassen, die von beiden Mixins erben.

    Erstelle eine Player-Klasse, die sowohl von Countable<Player> als auch von Describable<Player> erbt. Sie sollte einen Namen und ein Level speichern und eine getDescription()-Methode bereitstellen, die eine Zeichenfolge im folgenden Format zurückgibt: Player: [name] (Level [level])

    Erstelle eine Enemy-Klasse, die ebenfalls von beiden Mixins erbt. Sie sollte einen Typ und Lebenspunkte speichern und eine getDescription()-Methode bereitstellen, die Folgendes zurückgibt: Enemy: [type] with [health] HP

    Vergiss nicht, den statischen Zähler für jede Klasse zu initialisieren.

  • main.cpp: Lies vier Eingaben ein (jeweils in einer eigenen Zeile):
    1. Spielername (Zeichenfolge)
    2. Spielerlevel (Ganzzahl)
    3. Gegnertyp (Zeichenfolge)
    4. Lebenspunkte des Gegners (Ganzzahl)

    Erstelle mit den angegebenen Werten einen Spieler und einen Gegner. Führe anschließend die Mixins vor:

    1. Gib Player count: [count] mit der statischen Methode getCount() aus
    2. Gib Enemy count: [count] aus
    3. Rufe für den Spieler describe() auf
    4. Rufe für den Gegner describe() auf
    5. Erstelle einen zweiten Spieler mit dem Namen "Guest" und dem Level 1
    6. Gib erneut Player count: [count] aus, um den aktualisierten Zählerstand zu zeigen
    7. Rufe für den zweiten Spieler describe() auf

Zum Beispiel mit den Eingaben Hero, 10, Dragon und 500:

Player count: 1
Enemy count: 1
Player: Hero (Level 10)
Enemy: Dragon with 500 HP
Player count: 2
Player: Guest (Level 1)

Diese Herausforderung zeigt, wie CRTP-Mixins unabhängigen Klassen Funktionalität (Zählen und Beschreiben) hinzufügen, ohne virtuelle Funktionen zu verwenden. Sowohl Player als auch Enemy erhalten dieselben Fähigkeiten, indem sie von denselben Mixin-Vorlagen erben. Jede Klasse behält jedoch ihren eigenen separaten Instanzzähler, da die Vorlage mit unterschiedlichen Typen instanziiert wird.

Probier es selbst

#include <iostream>
#include <string>
#include "Entities.h"

using namespace std;

int main() {
    // Eingaben einlesen
    string playerName;
    int playerLevel;
    string enemyType;
    int enemyHealth;
    
    cin >> playerName;
    cin >> playerLevel;
    cin >> enemyType;
    cin >> enemyHealth;
    
    // TODO: Erstelle einen Player mit dem angegebenen Namen und Level
    
    // TODO: Erstelle einen Enemy mit dem angegebenen Typ und Gesundheitswert
    
    // TODO: Gib "Player count: [count]" mit Player::getCount() aus
    
    // TODO: Gib "Enemy count: [count]" mit Enemy::getCount() aus
    
    // TODO: Rufe describe() für den Spieler auf
    
    // TODO: Rufe describe() für den Gegner auf
    
    // TODO: Erstelle einen zweiten Spieler mit dem Namen "Guest" und Level 1
    
    // TODO: Gib "Player count: [count]" erneut aus
    
    // TODO: Rufe describe() für den zweiten Spieler auf
    
    return 0;
}
quiz iconTeste dich selbst

Diese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.

Alle Lektionen in Objektorientierte Programmierung

Übe selbstständig: Online-C++-Compiler