No-Exception C++ 설계 — 코드 크기·결정성 트레이드오프

1
enum class ErrorCode {
2
    Ok,
3
    InvalidInput,
4
    NotFound,
5
    NoMemory,
6
    Timeout,
7
    HardwareFault,
8
};
9

10
ErrorCode read_register(uint8_t addr, uint8_t& value) {
11
    if (addr >= MAX_ADDR) return ErrorCode::InvalidInput;
12
    if (!is_ready()) return ErrorCode::Timeout;
13

14
    value = bus_read(addr);
15
    return ErrorCode::Ok;
16
}
17

18
// 사용
19
uint8_t v;
20
auto err = read_register(0x10, v);
21
if (err != ErrorCode::Ok) {
22
    log_error("read failed");
23
    return err;
24
}
25
process(v);

1
[[nodiscard]] ErrorCode read_register(uint8_t addr, uint8_t& value);
2

3
read_register(0x10, v);   // WARNING — return 값 무시

1
#include <optional>
2

3
std::optional<uint8_t> read_register(uint8_t addr) {
4
    if (addr >= MAX_ADDR) return std::nullopt;
5
    if (!is_ready()) return std::nullopt;
6
    return bus_read(addr);
7
}
8

9
// 사용
10
if (auto v = read_register(0x10)) {
11
    process(*v);
12
} else {
13
    log_error("read failed");
14
}

1
class TempSensor {
2
public:
3
    std::optional<float> read_celsius() {
4
        if (!sensor_ready()) return std::nullopt;
5
        return raw_to_celsius(read_raw());
6
    }
7
};
8

9
// 사용
10
TempSensor sensor;
11
if (auto t = sensor.read_celsius()) {
12
    if (*t > kThresholdCelsius) trigger_alarm();
13
}

1
#include <expected>
2

3
enum class ReadError { InvalidAddr, Timeout, BusError };
4

5
std::expected<uint8_t, ReadError> read_register(uint8_t addr) {
6
    if (addr >= MAX_ADDR) return std::unexpected(ReadError::InvalidAddr);
7
    if (!is_ready()) return std::unexpected(ReadError::Timeout);
8
    return bus_read(addr);
9
}
10

11
// 사용
12
auto result = read_register(0x10);
13
if (result) {
14
    process(*result);
15
} else {
16
    switch (result.error()) {
17
        case ReadError::InvalidAddr: log_error("bad addr"); break;
18
        case ReadError::Timeout:     log_error("timeout"); break;
19
        case ReadError::BusError:    log_error("bus error"); break;
20
    }
21
}

1
#include <tl/expected.hpp>
2

3
tl::expected<uint8_t, ReadError> read_register(uint8_t addr) {
4
    if (addr >= MAX_ADDR) return tl::unexpected(ReadError::InvalidAddr);
5
    return bus_read(addr);
6
}

1
std::vector<int> v = {1, 2, 3};
2

3
v.at(10);                    // throw std::out_of_range
4
v[10];                       // UB (but no throw)
5

6
std::string s("hello");
7
s.at(100);                   // throw
8

9
std::stoi("not a number");   // throw

1
if (idx < v.size()) v[idx];
2

3
// std::stoi 대신
4
int result = 0;
5
auto [ptr, ec] = std::from_chars(str, str + len, result);
6
if (ec == std::errc{}) { /* OK */ }

1
// 저수준 — bit-level error
2
enum class HwError {
3
    DeviceNotFound,
4
    BusTimeout,
5
    ChecksumMismatch,
6
};
7

8
tl::expected<uint8_t, HwError> read_sensor_register(uint8_t addr);
9

10
// 중수준 — 측정 변환
11
enum class MeasurementError {
12
    HardwareFault,    // hw 변환
13
    OutOfRange,
14
    Calibrating,
15
};
16

17
tl::expected<float, MeasurementError> read_temperature() {
18
    auto raw = read_sensor_register(0x00);
19
    if (!raw) return tl::unexpected(MeasurementError::HardwareFault);
20

21
    if (*raw == 0xFF) return tl::unexpected(MeasurementError::OutOfRange);
22
    if (sensor_calibrating()) return tl::unexpected(MeasurementError::Calibrating);
23

24
    return convert_to_celsius(*raw);
25
}
26

27
// 응용 — 알람 결정
28
void check_alarm() {
29
    auto t = read_temperature();
30
    if (!t) {
31
        log_error_with_code(static_cast<int>(t.error()));
32
        return;
33
    }
34

35
    if (*t > 80.0f) trigger_alarm();
36
}

1
auto result = read_register(0x10)
2
    .and_then([](uint8_t raw) -> std::expected<float, Error> {
3
        return raw_to_celsius(raw);
4
    })
5
    .and_then([](float celsius) -> std::expected<float, Error> {
6
        return apply_calibration(celsius);
7
    });
8

9
if (result) {
10
    process(*result);
11
}

1
// BAD — dynamic string
2
struct Error {
3
    std::string message;
4
};
5

6
// GOOD — enum + static lookup
7
enum class Error { /* ... */ };
8

9
constexpr const char* error_message(Error e) {
10
    switch (e) {
11
        case Error::InvalidAddr: return "Invalid address";
12
        case Error::Timeout: return "Timeout";
13
        default: return "Unknown";
14
    }
15
}

1
class Resource {
2
public:
3
    Resource() {
4
        // throw 못 함 — 실패 시 어떻게?
5
    }
6
};
7

8
// 대안 — factory function
9
class Resource {
10
    Resource() = default;   // private default
11

12
public:
13
    static std::optional<Resource> create(int param) {
14
        if (!validate(param)) return std::nullopt;
15
        return Resource{};
16
    }
17
};
18

19
if (auto r = Resource::create(42)) {
20
    r->use();
21
}

1
ErrorCode foo();
2
foo();   // ignored

1
std::optional<HugeStruct> result;   // sizeof(HugeStruct) + 1

1
bool foo();   // 성공/실패만 — 이유 모름

1
auto v = read1();
2
if (!v) return /* propagate */;
3
auto w = read2(*v);
4
if (!w) return /* propagate */;
5
auto x = read3(*w);
6
// 매번 if 분기

1
-fexceptions:
2
  .text       : 42 KB
3
  .ARM.extab  : 4.2 KB (unwind table)
4
  .ARM.exidx  : 3.1 KB (exception index)
5
  total       : ~49 KB
6

7
-fno-exceptions:
8
  .text       : 38 KB
9
  total       : ~38 KB