Namespaces
Variants

    std::optional<T>::transform

    De es.cppreference.net
     
    C++
    Soporte de compiladores
    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 de 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::optional
     
    template< class F >
constexpr auto transform( F&& f ) &;
    		(1) (desde C++23) 
    template< class F >
constexpr auto transform( F&& f ) const&;
    		(2) (desde C++23) 
    template< class F >
constexpr auto transform( F&& f ) &&;
    		(3) (desde C++23) 
    template< class F >
constexpr auto transform( F&& f ) const&&;
    		(4) (desde C++23)

    Si *this contiene un valor, invoca f con el valor contenido como argumento, y devuelve un std::optional que contiene el resultado de esa invocación; de lo contrario, devuelve un std::optional vacío.

    El tipo del valor contenido en el resultado (denotado por U a continuación) debe ser un tipo de objeto que no sea un arreglo, y no debe ser std::in_place_t o std::nullopt_t). De lo contrario, el programa está mal formado.

    1) Sea U siendo std::remove_cv_t<std::invoke_result_t<F, T&>>. Si *this contiene un valor, devuelve un std::optional<U> cuyo valor contenido es inicializado directamente desde std::invoke(std::forward<F>(f), **this) (a diferencia de and_then(), que debe devolver un std::optional directamente). De lo contrario, devuelve un std::optional<U> vacío.
    • El programa está mal formado si la definición de variable U x(std::invoke(std::forward<F>(f), **this)); está mal formada.
    2) Igual que (1), excepto que U es std::remove_cv_t<std::invoke_result_t<F, const T&>>.
    3) Sea U siendo std::remove_cv_t<std::invoke_result_t<F, T>>. Si *this contiene un valor, devuelve un std::optional<U> cuyo valor contenido se inicializa directamente desde std::invoke(std::forward<F>(f), std::move(**this)). De lo contrario, devuelve un std::optional<U> vacío.
    • El programa está mal formado si la definición de variable U x(std::invoke(std::forward<F>(f), std::move(**this))); está mal formada.
    4) Igual que (3), excepto que U es std::remove_cv_t<std::invoke_result_t<F, const T>>.

    Parámetros

    f - una función adecuada u Callable objeto cuya firma de llamada retorna un tipo que no es referencia

    Valor de retorno

    Un std::optional que contiene el resultado de f o un std::optional vacío, como se describe anteriormente.

    Notas

    Debido a que transform construye directamente un objeto U en la ubicación correcta, en lugar de pasarlo a un constructor, std:: is_move_constructible_v < U > puede ser false .

    Como el objeto invocable f no puede devolver un tipo referencia, no puede ser un puntero a miembro de datos .

    Algunos lenguajes llaman a esta operación map .

    Macro de prueba de características Valor Estándar Característica
    __cpp_lib_optional 202110L (C++23) Operaciones mónadicas en std::optional

    Ejemplo

    Ejecutar este código 
    #include <iostream>
#include <optional>
struct A { /* ... */ };
struct B { /* ... */ };
struct C { /* ... */ };
struct D { /* ... */ };
auto A_to_B(A) -> B { /* ... */ std::cout << "A => B \n"; return {}; }
auto B_to_C(B) -> C { /* ... */ std::cout << "B => C \n"; return {}; }
auto C_to_D(C) -> D { /* ... */ std::cout << "C => D \n"; return {}; }
void try_transform_A_to_D(std::optional<A> o_A)
{
    std::cout << (o_A ? "o_A has a value\n" : "o_A is empty\n");
    std::optional<D> o_D = o_A.transform(A_to_B)
                              .transform(B_to_C)
                              .transform(C_to_D);
    std::cout << (o_D ? "o_D has a value\n\n" : "o_D is empty\n\n");
};
int main()
{
    try_transform_A_to_D( A{} );
    try_transform_A_to_D( {} );
}

    Salida: 

    o_A has a value
A => B
B => C
C => D
o_D has a value
o_A is empty
o_D is empty

    Véase también

    		devuelve el valor contenido si está disponible, otro valor en caso contrario
    (función miembro pública)
    (C++23)
    		devuelve el resultado de la función dada sobre el valor contenido si existe, o un optional vacío en caso contrario
    (función miembro pública)
    (C++23)
    		devuelve el propio optional si contiene un valor, o el resultado de la función dada en caso contrario
    (función miembro pública)