std::visit
Bearbeta variantalternativ
std::visit är en gratis lektion i C++ Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för C++ Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C++ Academy innehåller totalt 4 lektioner.
Varför std::visit?
Att manuellt kontrollera varje alternativ med get_if blir omständligt. std::visit tillämpar en anropsbar funktion på den typ som varianten innehåller för närvarande och hanterar anropet åt dig.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 4;
std::visit([](auto x){ std::cout << x << "\n"; }, v);
}En generisk lambda som visitor
En lambda som tar auto fungerar för alla alternativ om kroppen kan kompileras för samtliga. Här skriver vi ut den typ som är aktiv.
#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);
}Returnera ett värde
std::visit kan returnera ett värde. Varje gren måste returnera samma typ.
#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";
}Typberoende beteende med if constexpr
Om du vill agera olika för olika typer i en och samma generiska lambda kombinerar du if constexpr med std::decay_t och 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);
}En visitor som struct
Du kan också skriva en struct med flera överlagringar av operator(), en för varje typ. Kompilatorn väljer den matchande överlagringen.
#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);
}Det överlagrade idiomet
En populär hjälpkomponent kombinerar flera lambdor till en visitor. Varje lambda hanterar en specifik 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);
}Fullständighet
En visitor måste hantera varje alternativ, annars misslyckas kompileringen. Denna kontroll vid kompilering förhindrar att du glömmer ett fall.
Besöka och ändra
Om du skickar varianten som en icke-const-referens kan visitorn ändra det lagrade värdet på plats.
#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";
}Flera varianter
std::visit kan ta emot flera varianter samtidigt; visitorn får då ett argument per 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";
}Välj visitor-stil
Använd en generisk auto-lambda för enhetlig hantering, det överlagrade idiomet för ren logik per typ och en visitor som struct när beteendet ska kunna återanvändas på flera anropsplatser.
Visit jämfört med get_if
get_if passar bra för en enda snabb kontroll, men std::visit skalar bättre: den kräver fullständig hantering och samlar all logik per typ på ett ställe.
Snabbtest
Kontrollera att du har förstått std::visit.
Sammanfattning
Du har lärt dig om std::visit:
- Den skickar en anropsbar funktion till det aktiva alternativet.
- Använd generiska lambdor,
if constexpr, visitors som struct eller det överlagrade idiomet. - Visitors måste vara fullständiga (kontroll vid kompilering).
- De kan returnera värden och besöka flera varianter tillsammans.
Lär dig C++ med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 51
- Lektioner
- 203
Vanliga frågor
Är lektionen ”std::visit” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen C++ Academy, inklusive ”std::visit”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i C++ Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”std::visit”?
Bearbeta variantalternativ Ni övar på C++ Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig C++ Academy?
Du behöver inga förkunskaper. Utbildningen i C++ Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”std::visit”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här C++ Academy-lektionen?
Ja. Varje C++ Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.