constexpr 기초와 임베디드 적용 — 컴파일 타임 계산 활용

1
// 런타임 계산
2
int factorial(int n) {
3
    return (n <= 1) ? 1 : n * factorial(n - 1);
4
}
5

6
int x = factorial(10);   // runtime에 계산

1
// 컴파일 타임 계산
2
constexpr int factorial(int n) {
3
    return (n <= 1) ? 1 : n * factorial(n - 1);
4
}
5

6
constexpr int x = factorial(10);   // 컴파일러가 3628800으로 치환

1
constexpr int kBufferSize = 1024;     // 정수
2
constexpr float kPi = 3.14159f;        // 실수
3
constexpr const char* kVersion = "1.2"; // 포인터/문자열
4

5
// 컴파일 타임에 계산
6
constexpr int kEntries = kBufferSize / sizeof(int);

1
int runtime_val = read_register();
2
const int a = runtime_val;        // OK — const는 runtime 값 가능
3
constexpr int b = runtime_val;    // ERROR — constexpr은 compile-time 필요
4
constexpr int c = 42;             // OK

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

5
constexpr int a = square(5);      // 25 — 컴파일 타임
6
int b = square(read_input());     // 런타임 호출 (compile-time 값 아니므로)

1
// C++14 — full constexpr
2
constexpr int factorial(int n) {
3
    int result = 1;
4
    for (int i = 2; i <= n; ++i) {
5
        result *= i;
6
    }
7
    return result;
8
}

1
// Sin 테이블 256 entry
2
constexpr std::array<float, 256> generate_sin_table() {
3
    std::array<float, 256> table{};
4
    for (int i = 0; i < 256; ++i) {
5
        // 컴파일 타임에 sin 계산 (C++26 정도까지 std::sin은 안 됨, 직접 Taylor)
6
        float angle = (i * 2.0f * 3.14159f) / 256.0f;
7
        table[i] = taylor_sin(angle);
8
    }
9
    return table;
10
}
11

12
constexpr auto sin_table = generate_sin_table();   // Flash에 박힘

1
constexpr float taylor_sin(float x) {
2
    // x를 [-pi, pi]로 정규화 (생략)
3
    float result = x;
4
    float term = x;
5
    for (int n = 1; n < 7; ++n) {
6
        term *= -x * x / ((2 * n) * (2 * n + 1));
7
        result += term;
8
    }
9
    return result;
10
}

1
constexpr std::array<uint32_t, 256> generate_crc_table() {
2
    std::array<uint32_t, 256> table{};
3
    constexpr uint32_t poly = 0xEDB88320;
4
    for (uint32_t i = 0; i < 256; ++i) {
5
        uint32_t crc = i;
6
        for (int j = 0; j < 8; ++j) {
7
            crc = (crc & 1) ? (crc >> 1) ^ poly : crc >> 1;
8
        }
9
        table[i] = crc;
10
    }
11
    return table;
12
}
13

14
constexpr auto crc_table = generate_crc_table();
15

16
uint32_t compute_crc(const uint8_t* data, size_t len) {
17
    uint32_t crc = 0xFFFFFFFF;
18
    for (size_t i = 0; i < len; ++i) {
19
        crc = (crc >> 8) ^ crc_table[(crc ^ data[i]) & 0xFF];
20
    }
21
    return ~crc;
22
}

1
# C — 첫 호출 시 lazy 초기화 또는 main 시작 시 초기화
2
# 코드 사이즈: +200 바이트 (초기화 함수) + 1024 (테이블)
3

4
# C++ constexpr — 컴파일 타임 생성
5
# 코드 사이즈: 1024 (테이블만)

1
constexpr uintptr_t gpio_base(int port) {
2
    return 0x40020000 + port * 0x400;   // STM32 GPIOA, GPIOB, ...
3
}
4

5
constexpr uintptr_t kGpioAOdrAddr = gpio_base(0) + 0x14;
6
constexpr uintptr_t kGpioBOdrAddr = gpio_base(1) + 0x14;
7

8
#define GPIOA_ODR (*reinterpret_cast<volatile uint32_t*>(kGpioAOdrAddr))

1
template<typename T>
2
void serialize(uint8_t* buf, T value) {
3
    if constexpr (sizeof(T) == 1) {
4
        buf[0] = value;
5
    } else if constexpr (sizeof(T) == 2) {
6
        buf[0] = value >> 8;
7
        buf[1] = value & 0xFF;
8
    } else if constexpr (sizeof(T) == 4) {
9
        buf[0] = value >> 24;
10
        buf[1] = (value >> 16) & 0xFF;
11
        buf[2] = (value >> 8) & 0xFF;
12
        buf[3] = value & 0xFF;
13
    }
14
}
15

16
// 사용
17
uint8_t buf[4];
18
serialize(buf, uint16_t(0x1234));   // 2바이트 분기만 컴파일됨

1
constexpr int kMaxBufferSize = 4096;
2
constexpr int kSlotCount = 16;
3

4
static_assert(kMaxBufferSize % kSlotCount == 0,
5
              "Buffer size must be divisible by slot count");
6

7
constexpr int kSlotSize = kMaxBufferSize / kSlotCount;

1
// V1 — 런타임 계산
2
int compute_threshold(int level) {
3
    int base = 100;
4
    for (int i = 0; i < level; ++i) base *= 2;
5
    return base;
6
}
7

8
int threshold = compute_threshold(5);
9

10
// V2 — constexpr
11
constexpr int compute_threshold(int level) {
12
    int base = 100;
13
    for (int i = 0; i < level; ++i) base *= 2;
14
    return base;
15
}
16

17
constexpr int threshold = compute_threshold(5);   // = 3200

1
compute_threshold:
2
    movs    r3, #100
3
    cbz     r0, .L2
4
    mov     r2, r0
5
.L3:
6
    lsls    r3, r3, #1
7
    subs    r2, r2, #1
8
    bne     .L3
9
.L2:
10
    mov     r0, r3
11
    bx      lr

1
# threshold 변수 직접 사용 — 함수 호출 없음
2
ldr     r0, =3200

1
// 안 됨 (C++17)
2
constexpr int* ptr() { return new int(42); }   // dynamic alloc
3

4
// 됨 (C++20)
5
constexpr int* ptr() { return new int(42); }

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

5
constexpr int a = square(5);     // OK — 컴파일 타임
6
int b = square(read_input());    // ERROR — 런타임 인자 불가

1
constinit int counter = compute_initial();   // 컴파일 타임에 초기화
2

3
// 컴파일 에러 — runtime 초기화 시도
4
constinit int x = read_register();

1
const int n = read();     // OK, but not compile-time
2
int arr[n];               // C VLA — 표준 C++ 아님 (gnu++만)
3

4
constexpr int n = 100;
5
int arr[n];               // OK — 컴파일 타임 크기

1
constexpr float my_sin(float x) {
2
    return std::sin(x);   // ERROR (C++ 표준 sin이 constexpr 아님)
3
}

1
constexpr auto huge = generate_table<1000000>();   // 컴파일 30초+

1
constexpr int f(int x) { /* */ }
2
int y = f(some_var);   // some_var가 const 아니면 런타임 호출

1
# C — runtime 초기화
2
.text       : +180 B (init function)
3
.bss        : +1024 B (table, runtime filled)
4
init time   : ~50 us at startup
5

6
# C++ constexpr
7
.text       : +0 B (no init)
8
.rodata     : +1024 B (Flash, compile-time)
9
init time   : 0 us