std::variant
Eine typsichere Union
std::variant 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.
Eine typsichere Union
std::variant enthält genau einen Wert aus einer festen Liste von Typen und merkt sich, um welchen es sich handelt. Binden Sie <variant> ein, um ihn zu verwenden.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 10;
std::cout << std::get<int>(v) << "\n";
}Verschiedene Typen zuweisen
Sie können einer Variant nacheinander Werte jedes ihrer alternativen Typen zuweisen. Dabei wird automatisch aktualisiert, welche Alternative aktiv ist.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 5;
v = 3.14; // now holds a double
std::cout << std::get<double>(v) << "\n";
}Den aktiven Typ überprüfen
std::holds_alternative<T>(v) zeigt an, ob die Variant momentan den Typ T enthält.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 2.0;
std::cout << std::holds_alternative<double>(v) << "\n";
std::cout << std::holds_alternative<int>(v) << "\n";
}Die Funktion index()
v.index() gibt die nullbasierte Position des aktiven Typs in der Typenliste zurück.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double, char> v = (char)65;
std::cout << v.index() << "\n"; // 2
}Sicherer Zugriff mit std::get
std::get<T> gibt den Wert zurück, wenn T aktiv ist, und löst andernfalls eine Ausnahme aus: std::bad_variant_access. Es entstehen keine unbemerkt unbrauchbaren Werte.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 7;
try {
std::cout << std::get<double>(v) << "\n";
} catch (const std::bad_variant_access& e) {
std::cout << "wrong type!\n";
}
}Nicht auslösendes get_if
std::get_if<T>(&v) gibt einen Zeiger auf den Wert zurück oder nullptr, wenn T nicht aktiv ist. Das eignet sich hervorragend für Prüfungen ohne Verzweigungen.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 9;
if (auto p = std::get_if<int>(&v))
std::cout << "int " << *p << "\n";
}Standardkonstruktion
Eine standardkonstruierte Variant enthält eine wertinitialisierte Version ihres ersten Typs. Ordnen Sie Ihre Typen so an, dass der erste einen sinnvollen Standardwert darstellt.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v; // holds int 0
std::cout << std::get<int>(v) << "\n";
}Strings speichern
Im Gegensatz zu einfachen Unions kann eine Variant sicher nicht-triviale Typen wie std::string enthalten; die Lebensdauer wird für Sie verwaltet.
#include <iostream>
#include <string>
#include <variant>
int main() {
std::variant<int, std::string> v = std::string("hello");
std::cout << std::get<std::string>(v) << "\n";
}Variant als Rückgabetyp
Eine Funktion kann einen von mehreren Typen zurückgeben, indem sie eine Variant zurückgibt. Die aufrufende Stelle untersucht sie anschließend, um herauszufinden, welcher Typ zurückgegeben wurde.
#include <iostream>
#include <string>
#include <variant>
std::variant<int, std::string> parse(bool ok) {
if (ok) return 42;
return std::string("error");
}
int main() {
auto r = parse(false);
if (auto s = std::get_if<std::string>(&r)) std::cout << *s << "\n";
}emplace für Änderungen an Ort und Stelle
v.emplace<T>(args...) konstruiert direkt innerhalb der Variant einen neuen Wert des Typs T und aktiviert dabei die entsprechende Alternative.
#include <iostream>
#include <string>
#include <variant>
int main() {
std::variant<int, std::string> v = 1;
v.emplace<std::string>("switched");
std::cout << std::get<std::string>(v) << "\n";
}Warum sollten Sie Variant bevorzugen?
std::variant bietet die Speichereffizienz einer Union mit vollständiger Typsicherheit: Die Variant verfolgt den aktiven Typ, verwaltet Lebensdauern und verweigert den Zugriff auf den falschen Typ. Die nächste Lektion zeigt die sauberste Möglichkeit, sie zu verarbeiten.
Kurzer Test
Überprüfen Sie Ihr Verständnis von std::variant.
Zusammenfassung
Sie haben std::variant kennengelernt:
- Enthält einen von mehreren Typen und verfolgt, um welchen es sich handelt.
holds_alternativeundindex()untersuchen den aktiven Typ.std::getlöst bei einer Abweichung eine Ausnahme aus;get_ifgibt einen Zeiger oder null zurück.- Speichert nicht-triviale Typen wie
std::stringsicher.
Häufig gestellte Fragen
Ist die Lektion „std::variant“ kostenlos?
Ja — der vollständige Text von „std::variant“ 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 „std::variant“?
Eine typsichere Union 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 „std::variant“?
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.