Namespaces
Variants

    std::variant<Types...>::visit

    Desde es.cppreference.net
     
    C++
    Soporte del compilador
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos nombrados
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de utilidades
    Soporte del lenguaje
    Soporte de tipos (tipos básicos, RTTI)
    Macros de prueba de características de la biblioteca (C++20)
    Utilidades de programa
    Funciones variádicas
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Soporte de corrutinas (C++20)
    Soporte de contratos (C++26)
    Comparación de tres vías
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Utilidades generales
    Operadores relacionales (obsoleto en C++20)
     
    std::variant
     
    template< class Self, class Visitor >
constexpr decltype(auto) visit( this Self&& self, Visitor&& vis );
    		(1) (desde C++26) 
    template< class R, class Self, class Visitor >
constexpr R visit( this Self&& self, Visitor&& vis );
    		(2) (desde C++26)

    Aplica el visitante vis (un Callable que puede ser llamado con cualquier combinación de tipos de la variante) a la variante contenida en self.

    Dado el tipo V como decltype(std::forward_like<Self>(std::declval<variant>())), la llamada equivalente es:

    1) return std::visit(std::forward<Visitor>(vis), (V) self);.
    2) return std::visit<R>(std::forward<Visitor>(vis), (V) self);.

    Parámetros

    vis - un Callable que acepta cada alternativa posible de la variante
    self - variante que se pasa al visitante

    Valor de retorno

    1) El resultado de la invocación std :: visit .
    2) Nada si R es (posiblemente calificado con cv) void ; de lo contrario, el resultado de la invocación std :: visit < R > .

    Excepciones

    Solo lanza si la llamada a std :: visit lanza.

    Notas

    Macro de prueba de características Valor Estándar Característica
    __cpp_lib_variant 202306L (C++26) member visit

    Ejemplo

    Ejecutar este código 
    #include <print>
#include <string>
#include <string_view>
#include <variant>
struct Base {};
struct Derived : Base {};
// tipo auxiliar para el visitor
template<class... Ts>
struct overloads : Ts... { using Ts::operator()...; };
// el variant a visitar
using var_t = std::variant<int, std::string, Derived>;
int main()
{
    const auto visitor = overloads
    {
        [](int i){ std::print("int = {}\n", i); },
        [](std::string_view s){ std::println("string = “{}”", s); },
        [](const Base&){ std::println("base"); }
    };
    const var_t var1 = 42, var2 = "abc", var3 = Derived();
#if (__cpp_lib_variant >= 202306L)
    var1.visit(visitor);
    var2.visit(visitor);
    var3.visit(visitor);
#else
    std::visit(visitor, var1);
    std::visit(visitor, var2);
    std::visit(visitor, var3);
#endif
}

    Salida: 

    int = 42
string = “abc”
base

    Véase también

    (C++17)
    		llama al funtor proporcionado con los argumentos contenidos en una o más variant s
    (plantilla de función)