Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::visit — invocar una función con las alternativas activas

std::visit, declarada en <variant>, invoca un objeto invocable con el valor activo de cada objeto std::variant que se le pasa. Si no se pasa ninguna variante, std::visit(visitor) invoca a visitor sin argumentos, siempre que esa invocación sea válida. Las alternativas se seleccionan en tiempo de ejecución, pero la validez de la invocación se comprueba en tiempo de compilación para cada combinación de alternativas.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <variant>
std::visit(visitor, variants...)
std::visit<R>(visitor, variants...)

std::visit(visitor, variants...), de <variant>, pasa los valores activos a visitor. Si hay varias variantes, pasa un valor de cada una. Conserva la calificación const y la categoría de valor de los argumentos.

La invocación debe ser válida para todas las combinaciones de alternativas, no solo para la combinación activa en ese momento. Sin especificar R, todos los resultados deben tener el mismo tipo y la misma categoría de valor. La forma std::visit<R>(visitor, variants...) especifica el tipo de resultado; cada invocación debe cumplir los requisitos de conversión a R, mientras que R = void descarta el resultado.

Si alguna variante está en estado valueless_by_exception(), la función lanza std::bad_variant_access. El ejemplo usa sobrecargas de Describe que devuelven std::string. La salida esperada es int: 42 seguida de text: hello, cada una en una línea distinta.

Esta entrada trata la función libre en C++23. La dirección proporcionada apunta a un borrador de estándar en evolución, no a un documento C++23 definitivo. Establecer una opción del compilador no acredita el funcionamiento en un entorno de ejecución de producción.

Ejemplos

#include <iostream>
#include <string>
#include <variant>

struct Describe {
    std::string operator()(int value) const {
        return "int: " + std::to_string(value);
    }
    std::string operator()(const std::string& value) const {
        return "text: " + value;
    }
};

int main() {
    std::variant<int, std::string> value{42};
    std::cout << std::visit(Describe{}, value) << '\n';
    value = std::string{"hello"};
    std::cout << std::visit(Describe{}, value) << '\n';
}

Resultado

int: 42
text: hello

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes