std::expected 분석 — C++23 결과 타입과 에러 전파

1
std::optional<int> divide(int a, int b);
2
// b == 0이라 실패? 또는 overflow? — 모름

1
enum class Error { DivideByZero, Overflow };
2

3
std::expected<int, Error> divide(int a, int b) {
4
    if (b == 0) return std::unexpected(Error::DivideByZero);
5
    if (a == INT_MIN && b == -1) return std::unexpected(Error::Overflow);
6
    return a / b;
7
}
8

9
auto r = divide(10, 0);
10
if (!r) {
11
    switch (r.error()) {
12
        case Error::DivideByZero: /* */ break;
13
        case Error::Overflow:     /* */ break;
14
    }
15
}

1
#include <expected>
2

3
// 성공
4
std::expected<int, Error> success() {
5
    return 42;   // value
6
}
7

8
// 실패
9
std::expected<int, Error> failure() {
10
    return std::unexpected(Error::SomeError);
11
}
12

13
// 결과 확인
14
auto r = some_function();
15
if (r) {                    // 또는 r.has_value()
16
    int value = *r;         // 또는 r.value()
17
} else {
18
    Error e = r.error();
19
}

1
sizeof(std::expected<int, ErrorEnum>);
2
// 보통 8 byte (int 4 + bool 1 + 정렬 패딩)
3

4
sizeof(std::expected<HugeStruct, ErrorCode>);
5
// max(sizeof HugeStruct, sizeof ErrorCode) + 정렬

1
#include <tl/expected.hpp>
2

3
tl::expected<int, Error> divide(int a, int b);

1
// 4단계 처리
2
auto result = read_register(0x10)
3
    .and_then([](uint8_t raw) -> Result<float> {
4
        return raw_to_celsius(raw);
5
    })
6
    .and_then([](float c) -> Result<float> {
7
        return apply_calibration(c);
8
    })
9
    .transform([](float c) {
10
        return c * 1.8f + 32.0f;   // celsius → fahrenheit
11
    })
12
    .or_else([](Error e) -> Result<float> {
13
        if (e == Error::NotReady) return last_known_value;
14
        return tl::unexpected(e);
15
    });

1
struct SensorReading {
2
    float temperature;
3
    float pressure;
4
    uint16_t timestamp;
5
};
6

7
Result<SensorReading> read_sensor() {
8
    return read_temperature()
9
        .and_then([](float t) -> Result<std::pair<float, float>> {
10
            return read_pressure().transform([t](float p) {
11
                return std::pair{t, p};
12
            });
13
        })
14
        .transform([](auto pair) {
15
            return SensorReading{pair.first, pair.second, get_timestamp()};
16
        });
17
}
18

19
auto data = read_sensor();
20
if (data) {
21
    transmit(*data);
22
} else {
23
    handle_error(data.error());
24
}

1
std::expected<void, Error> write_register(uint8_t addr, uint8_t val) {
2
    if (addr >= MAX_ADDR) return std::unexpected(Error::InvalidAddr);
3
    bus_write(addr, val);
4
    return {};   // 성공, void
5
}
6

7
auto r = write_register(0x10, 0xFF);
8
if (!r) handle_error(r.error());

1
enum class LowError { BusTimeout, ChecksumFail };
2
enum class HighError { CommunicationFailed, DataCorrupted };
3

4
Result<Data, LowError> low_level_read();
5

6
Result<Data, HighError> high_level_read() {
7
    return low_level_read().transform_error([](LowError le) {
8
        switch (le) {
9
            case LowError::BusTimeout: return HighError::CommunicationFailed;
10
            case LowError::ChecksumFail: return HighError::DataCorrupted;
11
        }
12
    });
13
}

1
template<typename T1, typename T2, typename E>
2
auto combine(std::expected<T1, E> a, std::expected<T2, E> b)
3
    -> std::expected<std::pair<T1, T2>, E>
4
{
5
    if (!a) return std::unexpected(a.error());
6
    if (!b) return std::unexpected(b.error());
7
    return std::pair{*a, *b};
8
}
9

10
auto t_and_p = combine(read_temp(), read_pressure());
11
if (t_and_p) {
12
    auto [t, p] = *t_and_p;
13
    process(t, p);
14
}

1
Result<HugeData> create_data() {
2
    HugeData d;
3
    // ... heavy initialization
4
    return d;   // move
5
}
6

7
auto r = create_data();
8
HugeData d = std::move(*r);   // owner 이전

1
auto r = read();
2
auto v = r.value();   // r이 error면 std::bad_expected_access throw

1
std::expected<int, int> r = 42;   // value or error? — value
2
return 0;   // 0이 error로 의도? — 모호

1
if (r == true) { /* */ }   // 직관에 어긋남

1
auto r = risky();
2
proceed();   // r 확인 안 함

1
Result<TypeA> ...
2
Result<TypeB> ...
3
// 각 T마다 expected 인스턴스

1
auto r = compute()
2
    .and_then([big_obj = std::move(b)](int v) { ... });

1
# bool 반환
2
bool f() { return true; }
3
sizeof: 1 (or 4 with alignment)
4

5
# error code
6
ErrorCode f() { return Ok; }
7
sizeof: 4
8

9
# optional<int>
10
std::optional<int> f() { return 42; }
11
sizeof: 8
12

13
# expected<int, ErrorCode>
14
std::expected<int, ErrorCode> f() { return 42; }
15
sizeof: 8 (int + ErrorCode + flag, well aligned)
16

17
# 호출 어셈블리 (Cortex-M4 -O2)
18
모든 형태: 거의 동일 (4-8 instructions)