std::variant
Una unión con seguridad de tipos
std::variant es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.
Una unión con seguridad de tipos
std::variant contiene exactamente un valor de una lista fija de tipos y recuerda cuál es. Incluya <variant> para usarlo.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 10;
std::cout << std::get<int>(v) << "\n";
}Asignar tipos diferentes
Puede reasignar un variant a cualquiera de sus tipos alternativos. El tipo alternativo activo se actualiza automáticamente.
#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";
}Comprobar el tipo activo
std::holds_alternative<T>(v) indica si el variant contiene actualmente el tipo 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 función index()
v.index() devuelve la posición, empezando en cero, del tipo activo en la lista de tipos.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double, char> v = (char)65;
std::cout << v.index() << "\n"; // 2
}Acceso seguro con std::get
std::get<T> devuelve el valor si T está activo; de lo contrario, lanza std::bad_variant_access. No se obtienen valores basura silenciosamente.
#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 sin excepciones
std::get_if<T>(&v) devuelve un puntero al valor o nullptr si T no está activo. Es ideal para comprobaciones sin ramificaciones.
#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";
}Construcción predeterminada
Un variant construido de forma predeterminada contiene una versión inicializada por valor de su primer tipo. Ordene los tipos de modo que el primero sea un valor predeterminado razonable.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v; // holds int 0
std::cout << std::get<int>(v) << "\n";
}Almacenar cadenas
A diferencia de las uniones sin procesar, un variant puede contener de forma segura tipos no triviales, como std::string; el ciclo de vida se gestiona automáticamente.
#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 como tipo de retorno
Una función puede devolver uno de varios tipos si devuelve un variant. Después, quien la llama puede inspeccionarlo para descubrir qué tipo se ha devuelto.
#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 para cambiar en el lugar
v.emplace<T>(args...) construye un nuevo valor de tipo T directamente dentro del variant y cambia el tipo alternativo activo.
#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";
}¿Por qué preferir Variant?
std::variant ofrece la eficiencia de memoria de una unión con seguridad completa de tipos: controla el tipo activo, gestiona los ciclos de vida y rechaza el acceso al tipo equivocado. La siguiente lección muestra la forma más limpia de procesarlo.
Comprobación rápida
Compruebe sus conocimientos sobre std::variant.
Resumen
Ha aprendido sobre std::variant:
- Contiene uno de varios tipos y lleva el control de cuál es.
holds_alternativeeindex()permiten inspeccionar el tipo activo.std::getlanza una excepción si no coincide;get_ifdevuelve un puntero o null.- Almacena de forma segura tipos no triviales, como
std::string.
Preguntas frecuentes
¿La lección «std::variant» es gratis?
Sí — el texto completo de «std::variant» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué aprenderé en «std::variant»?
Una unión con seguridad de tipos Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C++ Academy?
No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «std::variant»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C++ Academy?
Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.