std::variant
Utiliser une union sûre du point de vue des types
std::variant est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Une union sûre du point de vue des types
std::variant contient exactement une valeur parmi une liste fixe de types et mémorise laquelle. Incluez <variant> pour l’utiliser.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 10;
std::cout << std::get<int>(v) << "\n";
}Affecter différents types
Vous pouvez réaffecter une variante à n’importe lequel de ses types alternatifs. Elle met automatiquement à jour l’alternative active.
#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";
}Vérifier le type actif
std::holds_alternative<T>(v) vous indique si la variante contient actuellement le type T.
#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";
}La fonction index()
v.index() renvoie la position, à partir de zéro, du type actif dans la liste des types.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double, char> v = (char)65;
std::cout << v.index() << "\n"; // 2
}Accès sûr avec std::get
std::get<T> renvoie la valeur si T est actif, sinon il lève une exception std::bad_variant_access. Aucune valeur incohérente silencieuse.
#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";
}
}get_if sans exception
std::get_if<T>(&v) renvoie un pointeur vers la valeur ou nullptr si T n’est pas actif. Très pratique pour effectuer des vérifications sans branchement.
#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";
}Construction par défaut
Une variante construite par défaut contient une version initialisée par valeur de son premier type. Ordonnez vos types de sorte que le premier fournisse une valeur par défaut pertinente.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v; // holds int 0
std::cout << std::get<int>(v) << "\n";
}Stocker des chaînes de caractères
Contrairement aux unions brutes, une variante peut contenir en toute sécurité des types non triviaux comme std::string ; leur durée de vie est gérée pour vous.
#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";
}Une variante comme type de retour
Une fonction peut renvoyer l’un de plusieurs types en retournant une variante. Les appelants l’inspectent ensuite pour déterminer quel type a été renvoyé.
#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 pour modifier sur place
v.emplace<T>(args...) construit directement une nouvelle valeur de type T dans la variante et change l’alternative active.
#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";
}Pourquoi préférer une variante
std::variant vous offre l’efficacité mémoire d’une union avec une sécurité complète du point de vue des types : il suit le type actif, gère les durées de vie et refuse les accès à un type incorrect. La prochaine leçon présente la manière la plus claire de la traiter.
Vérification rapide
Vérifiez votre compréhension de std::variant.
Récapitulatif
Vous avez découvert std::variant :
- Il contient l’un de plusieurs types et suit lequel est actif.
holds_alternative/index()permettent d’inspecter le type actif.std::getlève une exception en cas de type incorrect ;get_ifrenvoie un pointeur ou une valeur nulle.- Il stocke en toute sécurité des types non triviaux comme
std::string.
Questions Fréquemment Posées
La leçon « std::variant » est-elle gratuite ?
Oui — le texte complet de « std::variant » 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::variant » ?
Utiliser une union sûre du point de vue des types 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 3 sur 4.
Combien de temps prend la leçon « std::variant » ?
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.