std::visit
Variant-Alternativen verarbeiten
std::visit ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.
Warum std::visit?
Das manuelle Überprüfen jeder Alternative mit get_if wird schnell umfangreich. std::visit wendet eine aufrufbare Funktion auf den Typ an, den die Variant momentan enthält, und übernimmt die Auswahl für Sie.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 4;
std::visit([](auto x){ std::cout << x << "\n"; }, v);
}Ein generischer Lambda-Visitor
Eine Lambda-Funktion, die auto entgegennimmt, funktioniert für jede Alternative, sofern der Funktionskörper für alle Alternativen kompiliert werden kann. Hier geben wir den jeweils aktiven Typ aus.
#include <iostream>
#include <string>
#include <variant>
int main() {
std::variant<int, std::string> v = std::string("hi");
std::visit([](const auto& x){ std::cout << x << "\n"; }, v);
}Einen Wert zurückgeben
std::visit kann einen Wert zurückgeben. Jeder Zweig muss denselben Typ zurückgeben.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 2.5;
double d = std::visit([](auto x){ return x * 2.0; }, v);
std::cout << d << "\n";
}Typspezifisches Verhalten mit if constexpr
Um innerhalb einer generischen Lambda-Funktion je nach Typ unterschiedlich zu handeln, kombinieren Sie if constexpr mit std::decay_t und std::is_same_v.
#include <iostream>
#include <string>
#include <variant>
#include <type_traits>
int main() {
std::variant<int, std::string> v = 5;
std::visit([](const auto& x){
using T = std::decay_t<decltype(x)>;
if constexpr (std::is_same_v<T, int>) std::cout << "int " << x << "\n";
else std::cout << "str " << x << "\n";
}, v);
}Ein Struct-Visitor
Sie können auch eine Struktur mit mehreren Überladungen von operator() schreiben, eine pro Typ. Der Compiler wählt die passende Überladung aus.
#include <iostream>
#include <string>
#include <variant>
struct Printer {
void operator()(int i) const { std::cout << "int " << i << "\n"; }
void operator()(const std::string& s) const { std::cout << "str " << s << "\n"; }
};
int main() {
std::variant<int, std::string> v = std::string("yo");
std::visit(Printer{}, v);
}Das Overloaded-Idiom
Ein beliebtes Hilfsmuster kombiniert mehrere Lambda-Funktionen zu einem Visitor. Jede Lambda-Funktion verarbeitet einen bestimmten Typ.
#include <iostream>
#include <string>
#include <variant>
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
int main() {
std::variant<int, std::string> v = 8;
std::visit(overloaded{
[](int i){ std::cout << "i=" << i << "\n"; },
[](const std::string& s){ std::cout << "s=" << s << "\n"; }
}, v);
}Vollständigkeit
Ein Visitor muss jede Alternative verarbeiten, sonst schlägt die Kompilierung fehl. Diese Prüfung zur Compile-Zeit verhindert, dass Sie einen Fall vergessen.
Besuchen und ändern
Wenn Sie die Variant als nicht-konstante Referenz übergeben, kann der Visitor den gespeicherten Wert direkt an Ort und Stelle ändern.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 10;
std::visit([](auto& x){ x += 1; }, v);
std::cout << std::get<int>(v) << "\n";
}Mehrere Varianten
std::visit kann mehrere Varianten gleichzeitig annehmen; der Visitor erhält dann ein Argument pro Variant.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> a = 2;
std::variant<int, double> b = 3.0;
auto sum = std::visit([](auto x, auto y){ return x + y; }, a, b);
std::cout << sum << "\n";
}Den Visitor-Stil auswählen
Verwenden Sie eine generische auto-Lambda-Funktion für einheitliche Verarbeitung, das Overloaded-Idiom für übersichtliche typspezifische Logik und einen Struct-Visitor, wenn das Verhalten an mehreren Aufrufstellen wiederverwendet werden soll.
Visit oder get_if
get_if eignet sich für eine einzelne schnelle Prüfung, aber std::visit lässt sich besser erweitern: Es erzwingt die vollständige Verarbeitung aller Alternativen und hält die gesamte typspezifische Logik an einer Stelle.
Kurzer Test
Überprüfen Sie Ihr Verständnis von std::visit.
Zusammenfassung
Sie haben std::visit kennengelernt:
- Leitet eine aufrufbare Funktion an die aktive Alternative weiter.
- Verwenden Sie generische Lambdas,
if constexpr, Struct-Visitor oder das Overloaded-Idiom. - Visitor müssen alle Alternativen abdecken (Prüfung zur Compile-Zeit).
- Kann Werte zurückgeben und mehrere Varianten gemeinsam besuchen.
Häufig gestellte Fragen
Ist die Lektion „std::visit“ kostenlos?
Ja — der vollständige Text von „std::visit“ 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::visit“?
Variant-Alternativen verarbeiten 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 4 von 4.
Wie lange dauert die Lektion „std::visit“?
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.