Mixins mit CRTP
Verhalten zur Compile-Zeit zusammensetzen
Mixins mit CRTP ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist ein Mixin?
Ein Mixin ist eine kleine, wiederverwendbare Verhaltenseinheit, die Sie in eine Klasse einbauen. Mit CRTP fügen Mixins zur Compile-Zeit Funktionalität hinzu und rufen dabei weiterhin die Host-Klasse auf.
Ein einfaches Mixin
Dieses Mixin fügt eine print_twice-Methode hinzu, die voraussetzt, dass der Host value() bereitstellt.
#include <iostream>
template <typename T>
struct PrintTwice {
void print_twice() const {
auto v = static_cast<const T*>(this)->value();
std::cout << v << " " << v << "\n";
}
};
struct Box : PrintTwice<Box> {
int value() const { return 7; }
};
int main() {
Box{}.print_twice();
return 0;
}Mehrere Mixins kombinieren
Sie können gleichzeitig von mehreren CRTP-Mixins erben und so unabhängige Verhaltensweisen in einer Klasse stapeln.
#include <iostream>
template <typename T>
struct Loggable {
void log() const { std::cout << "log: " << static_cast<const T*>(this)->id() << "\n"; }
};
template <typename T>
struct Resettable {
void reset() { static_cast<T*>(this)->set(0); }
};
struct Device : Loggable<Device>, Resettable<Device> {
int v = 5;
int id() const { return v; }
void set(int x) { v = x; }
};
int main() {
Device d;
d.log();
d.reset();
d.log();
return 0;
}Mixins können auch Zustand enthalten
Ein Mixin kann eigene Datenelemente enthalten, die Teil des Layouts des zusammengesetzten Objekts werden.
#include <iostream>
template <typename T>
struct Tagged {
int tag = 0;
void set_tag(int t) { tag = t; }
int get_tag() const { return tag; }
};
struct Item : Tagged<Item> {
const char* name = "item";
};
int main() {
Item it;
it.set_tag(42);
std::cout << it.name << " " << it.get_tag() << "\n";
return 0;
}Mixin vs. gewöhnliche Vererbung
Ein CRTP-Mixin unterscheidet sich von gewöhnlicher Vererbung, weil die Basisklasse in die abgeleitete Klasse „hinunter“ aufrufen kann. Gewöhnliche Basisklassen können ohne virtuelle Funktionen keine Methoden aufrufen, die nur im abgeleiteten Typ vorhanden sind.
Policy-basiertes Design
Mixins ermöglichen Policy-basiertes Design: Verhaltensweisen werden zur Compile-Zeit ausgewählt, indem Sie festlegen, von welchen Mixins Sie erben – ähnlich wie std::vector eine Allocator-Policy übernimmt.
Reihenfolge und Layout
Beim Stapeln von Mixins beeinflusst die Reihenfolge der Basisklassen die Konstruktionsreihenfolge und das Objektlayout. Halten Sie Mixins unabhängig, damit die Reihenfolge die Korrektheit nicht beeinflusst.
- Konstruktion in der Deklarationsreihenfolge der Basisklassen
- Vermeiden Sie voneinander abhängige Mixins
Ein Equality-Mixin hinzufügen
Hier erzeugt ein Mixin operator!= aus dem Gleichheitsoperator des Hosts.
#include <iostream>
template <typename T>
struct EqualityMixin {
friend bool operator!=(const T& a, const T& b) { return !(a == b); }
};
struct P : EqualityMixin<P> {
int x;
P(int v) : x(v) {}
friend bool operator==(const P& a, const P& b) { return a.x == b.x; }
};
int main() {
std::cout << (P(1) != P(2)) << "\n";
return 0;
}Bedingte Mixins
Sie können ein Mixin nur dann einbinden, wenn eine Bedingung erfüllt ist, indem Sie Vererbung mit std::conditional kombinieren und zwischen einem echten Mixin und einem leeren Mixin wählen.
Empty Base Optimization
Mixins ohne Datenelemente profitieren von der Empty Base Optimization: Der Compiler reserviert dafür null zusätzliche Bytes, sodass das Stapeln vieler zustandsloser Mixins hinsichtlich der Größe kostenlos ist.
#include <iostream>
template <typename T>
struct A {};
template <typename T>
struct B {};
struct C : A<C>, B<C> {
int x;
};
int main() {
std::cout << (sizeof(C) == sizeof(int)) << "\n";
return 0;
}Wann Sie Mixins einsetzen sollten
Mixins sind besonders nützlich, wenn viele Klassen dieselben orthogonalen Verhaltensweisen benötigen (Logging, Zählen, Vergleiche). Sie halten jedes Verhalten an einer zentralen Stelle und lassen sich ohne Laufzeitkosten kombinieren.
Kurzer Test
Testen Sie Ihr Verständnis von CRTP-Mixins.
Zusammenfassung
Sie haben gelernt, mit CRTP Mixins zu erstellen.
- Mixins kombinieren orthogonales Verhalten zur Compile-Zeit
- Sie können in den Host zurückrufen und Zustand enthalten
- Zustandslose Mixins sind dank der Empty Base Optimization kostenlos
- Ideal für Logging-, Vergleichs- und Zähl-Policies
Häufig gestellte Fragen
Ist die Lektion „Mixins mit CRTP“ kostenlos?
Ja — der vollständige Text von „Mixins mit CRTP“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Mixins mit CRTP“?
Verhalten zur Compile-Zeit zusammensetzen Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C++ Academy zu starten?
Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Mixins mit CRTP“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?
Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.