std::optional<T>::transform

template< class F >
constexpr auto transform( F&& f ) &;

template< class F >
constexpr auto transform( F&& f ) const&;

template< class F >
constexpr auto transform( F&& f ) &&;

template< class F >
constexpr auto transform( F&& f ) const&&;

如果 *this 含值，则以所含值作为实参调用 f，并返回一个所含值为该次调用结果的 std::optional；否则返回空的 std::optional。

结果中的所含值类型（下文中以 U 指代）必须是非数组对象类型，且不能是 std::in_place_t 或 std::nullopt_t）。否则程序非良构。

参数

返回值

一个包含 f 函数结果的 std::optional 或空的 std::optional ，如上所述。

注释

由于 transform 直接在目标位置构造 U 对象，而非将其传递给构造函数，因此 std:: is_move_constructible_v < U > 可能为 false 。

由于可调用对象 f 无法返回引用类型，因此它不能是 指向数据成员的指针 。

某些语言将此操作称为 map 。

示例

#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( {} );
}

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

参见