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

참고 항목