consteval과 constinit 분석 — C++20 컴파일 타임 강제 메커니즘

1
constexpr int square(int x) { return x * x; }
2

3
constexpr int a = square(5);        // 컴파일 타임
4
int b = square(read_input());        // 런타임 — 의도 아님

1
consteval int square(int x) {
2
    return x * x;
3
}
4

5
constexpr int a = square(5);     // OK — 25, 컴파일 타임
6

7
int input = read_input();
8
int b = square(input);            // ERROR — input은 런타임 값

1
struct PinId {
2
    int port;
3
    int pin;
4
};
5

6
consteval PinId make_pin(int port, int pin) {
7
    if (port < 0 || port > 7) throw "invalid port";   // 컴파일 에러로 변환
8
    if (pin < 0 || pin > 15) throw "invalid pin";
9
    return {port, pin};
10
}
11

12
constexpr PinId kLed = make_pin(0, 5);   // OK
13
constexpr PinId kBad = make_pin(9, 5);   // ERROR at compile time

1
// 매크로 — 타입 없음, 디버깅 안 됨
2
#define PIN_MASK(p) (1u << (p))
3

4
// consteval — 타입 안전
5
consteval uint32_t pin_mask(int pin) {
6
    if (pin < 0 || pin > 31) throw "invalid pin";
7
    return 1u << pin;
8
}
9

10
constexpr uint32_t led_mask = pin_mask(5);   // OK
11
constexpr uint32_t bad      = pin_mask(35);  // 컴파일 에러

1
consteval int f(int);
2
constexpr int g(int);
3

4
auto p1 = &g;   // OK — constexpr은 런타임 호출 가능
5
auto p2 = &f;   // ERROR — consteval은 함수 포인터 안 됨

1
constinit int counter = 0;                    // OK
2
constinit int pi_thousand = 3141;             // OK
3
constinit int from_register = read_io();      // ERROR — runtime
4

5
constinit auto* g_logger = make_logger();     // OK if make_logger is constexpr

1
const int     a = 10;          // 컴파일 또는 런타임에 초기화 가능
2
constinit int b = 10;          // 컴파일 타임에 초기화 강제, 이후 변경 가능
3
constexpr int c = 10;          // 컴파일 타임에 초기화 강제, 이후 변경 불가

1
// 안전 — constexpr static
2
constexpr Logger g_logger = make_logger(LogLevel::Info);   // OK if Logger constexpr
3

4
// 위험 — 런타임 dynamic init
5
Logger g_logger2 = make_logger(read_config());   // runtime, fiasco 위험
6

7
// 안전 — constinit으로 강제 차단
8
constinit Logger g_logger3 = make_logger(LogLevel::Info);   // 컴파일 타임만 허용

1
class Color {
2
public:
3
    constexpr Color(uint8_t r, uint8_t g, uint8_t b)
4
        : r_(r), g_(g), b_(b) {}
5

6
    consteval Color(uint32_t hex)
7
        : r_((hex >> 16) & 0xFF), g_((hex >> 8) & 0xFF), b_(hex & 0xFF)
8
    {
9
        if (hex > 0xFFFFFF) throw "invalid color";
10
    }
11

12
    constexpr uint32_t to_hex() const {
13
        return (r_ << 16) | (g_ << 8) | b_;
14
    }
15

16
private:
17
    uint8_t r_, g_, b_;
18
};
19

20
constexpr Color a(255, 0, 0);     // OK — RGB
21
constexpr Color b(0xFF0000);      // OK — hex constructor (consteval)
22
constexpr Color c(0x1FFFFFF);     // ERROR — invalid hex (consteval 검증)

1
constexpr int compute(int x) {
2
    if consteval {
3
        // 컴파일 타임 호출 — 더 정확한 알고리즘
4
        return slow_but_precise(x);
5
    } else {
6
        // 런타임 호출 — 빠른 근사
7
        return fast_approximate(x);
8
    }
9
}
10

11
constexpr int a = compute(10);   // slow_but_precise
12
int b = compute(read_input());    // fast_approximate

1
constexpr auto times_two = [](int x) consteval { return x * 2; };
2

3
constexpr int a = times_two(5);    // 10
4
int b = times_two(read_input());    // ERROR

1
consteval int f(int x) { return x * 2; }
2
constexpr int g(int x) { return f(x); }   // OK in C++23, ERROR in C++20
3

4
constexpr int a = g(5);      // OK — 컴파일 타임 chain
5
int b = g(read_input());     // ERROR — g가 f를 런타임으로 호출 못 함

1
constinit int counter = 0;
2
counter++;   // OK — constinit은 mutable

1
// 모두 같은 결과 (Flash에 상수 박힘)
2
// 차이는 — 잘못된 사용을 *컴파일러가 차단*하는지
3

4
constexpr int a = 42;          // 0 운영비
5
consteval int f() { return 42; }
6
constexpr int b = f();         // 0 운영비 + 강제 컴파일 타임
7

8
constinit int c = 42;          // 0 운영비 + 강제 정적 초기화

1
// 의도 명확
2
consteval PinId make_pin(int port, int pin);
3

4
// "이 함수는 컴파일 타임 인자만 받습니다" — 시그니처 자체가 문서