Namespaces
Variants

std::optional<T>:: transform

From cppreference.net
C++
Utilities library
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 de valor contenido en el resultado (denotado por U a continuación) debe ser un tipo de objeto no-array, y no debe ser std::in_place_t o std::nullopt_t ). De lo contrario, el programa está mal formado.

1) Sea U igual a std:: remove_cv_t < std:: invoke_result_t < F, T & >> . Si * this contiene un valor, retorna 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 retornar un std::optional directamente). De lo contrario, retorna 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 igual a std:: remove_cv_t < std:: invoke_result_t < F, T >> . Si * this contiene un valor, retorna un std:: optional < U > cuyo valor contenido está inicializado directamente desde std:: invoke ( std:: forward < F > ( f ) , std :: move ( ** this ) ) . De lo contrario, retorna 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 >> .

Contenidos

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)