std::visit
Procese las alternativas de variant
std::visit es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 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.
¿Por qué std::visit?
Comprobar manualmente cada alternativa con get_if resulta muy verboso. std::visit aplica un objeto invocable al tipo que contiene actualmente el variant y se encarga de la selección por usted.
#include <iostream>
#include <variant>
int main() {
std::variant<int, double> v = 4;
std::visit([](auto x){ std::cout << x << "\n"; }, v);
}Un visitor con lambda genérica
Una lambda que recibe auto funciona para todas las alternativas si el cuerpo se puede compilar para cada una. Aquí imprimimos el tipo que esté activo.
#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);
}Devolver un valor
std::visit puede devolver un valor. Todas las ramas deben devolver el mismo tipo.
#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";
}Comportamiento por tipo con if constexpr
Para actuar de forma diferente según el tipo dentro de una sola lambda genérica, combine if constexpr con std::decay_t y 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 visitor basado en una estructura
También puede escribir una estructura con varias sobrecargas de operator(), una por tipo. El compilador selecciona la sobrecarga correspondiente.
#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);
}El modismo overloaded
Un ayudante habitual combina varias lambdas en un único visitor. Cada lambda gestiona un tipo específico.
#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);
}Exhaustividad
Un visitor debe gestionar todas las alternativas; de lo contrario, el código no se compila. Esta comprobación en tiempo de compilación evita olvidar algún caso.
Visitar y modificar
Si pasa el variant por referencia no constante, el visitor puede modificar el valor almacenado directamente.
#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";
}Varios variants
std::visit puede recibir varios variants a la vez; el visitor recibe entonces un argumento por cada 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";
}Elegir un estilo de visitor
Use una lambda genérica con auto para un tratamiento uniforme, el modismo overloaded para expresar claramente la lógica específica de cada tipo y un visitor basado en una estructura cuando el comportamiento se reutilice en distintos puntos de llamada.
Visit frente a get_if
get_if es adecuado para una única comprobación rápida, pero std::visit escala mejor: exige exhaustividad y mantiene toda la lógica específica de cada tipo en un solo lugar.
Comprobación rápida
Compruebe sus conocimientos sobre std::visit.
Resumen
Ha aprendido sobre std::visit:
- Envía un objeto invocable a la alternativa activa.
- Puede usar lambdas genéricas,
if constexpr, visitors basados en estructuras o el modismo overloaded. - Los visitors deben ser exhaustivos (comprobación en tiempo de compilación).
- Pueden devolver valores y visitar varios variants conjuntamente.
Preguntas frecuentes
¿La lección «std::visit» es gratis?
Sí — el texto completo de «std::visit» 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::visit»?
Procese las alternativas de variant 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 4 de 4.
¿Cuánto tiempo toma la lección «std::visit»?
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.