std::visit
Traiter les alternatives d’un variant
std::visit est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.
Pourquoi utiliser std::visit
Vérifier manuellement chaque alternative avec get_if devient verbeux. std::visit applique une fonction appelable au type que contient actuellement la variante et se charge de l’aiguillage pour vous.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 4;
std::visit([](auto x){ std::cout << x << "\n"; }, v);
}Un visiteur lambda générique
Une lambda qui prend auto fonctionne pour chaque alternative si son corps peut être compilé pour chacune d’elles. Ici, nous affichons le type actif, quel qu’il soit.
#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);
}Renvoyer une valeur
std::visit peut renvoyer une valeur. Chaque branche doit renvoyer le même type.
#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";
}Un comportement selon le type avec if constexpr
Pour agir différemment selon le type dans une seule lambda générique, combinez if constexpr avec std::decay_t et 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);
}Un visiteur sous forme de structure
Vous pouvez également écrire une structure comportant plusieurs surcharges de operator(), une par type. Le compilateur choisit la surcharge correspondante.
#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);
}L’idiome overloaded
Un utilitaire très répandu combine plusieurs lambdas en un seul visiteur. Chaque lambda traite un type précis.
#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);
}Exhaustivité
Un visiteur doit traiter chaque alternative, sinon le code ne compile pas. Cette vérification à la compilation évite d’oublier un cas.
Visiter et modifier
Si vous transmettez la variante par référence non constante, le visiteur peut modifier la valeur stockée sur place.
#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";
}Plusieurs variantes
std::visit peut prendre plusieurs variantes à la fois ; le visiteur reçoit alors un argument par variante.
#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";
}Choisir un style de visiteur
Utilisez une lambda générique auto pour un traitement uniforme, l’idiome overloaded pour une logique claire selon le type et un visiteur sous forme de structure lorsque le comportement doit être réutilisable à plusieurs endroits.
visit ou get_if
get_if convient pour une vérification rapide et unique, mais std::visit s’adapte mieux : il impose l’exhaustivité et regroupe toute la logique propre à chaque type au même endroit.
Vérification rapide
Vérifiez votre compréhension de std::visit.
Récapitulatif
Vous avez découvert std::visit :
- Il achemine une fonction appelable vers l’alternative active.
- Utilisez des lambdas génériques,
if constexpr, des visiteurs sous forme de structure ou l’idiome overloaded. - Les visiteurs doivent être exhaustifs (vérification à la compilation).
- Ils peuvent renvoyer des valeurs et visiter plusieurs variantes ensemble.
Questions Fréquemment Posées
La leçon « std::visit » est-elle gratuite ?
Oui — le texte complet de « std::visit » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « std::visit » ?
Traiter les alternatives d’un variant Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C++ Academy ?
Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « std::visit » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?
Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.