constexpr 고급 활용 — 룩업 테이블·CRC·해시 컴파일 타임 생성

1
template<typename T, size_t N>
2
constexpr void bubble_sort(std::array<T, N>& arr) {
3
    for (size_t i = 0; i < N - 1; ++i) {
4
        for (size_t j = 0; j < N - 1 - i; ++j) {
5
            if (arr[j] > arr[j + 1]) {
6
                T tmp = arr[j];
7
                arr[j] = arr[j + 1];
8
                arr[j + 1] = tmp;
9
            }
10
        }
11
    }
12
}
13

14
constexpr std::array<int, 5> make_sorted() {
15
    std::array<int, 5> arr = {5, 2, 8, 1, 4};
16
    bubble_sort(arr);
17
    return arr;
18
}
19

20
constexpr auto sorted = make_sorted();   // {1, 2, 4, 5, 8} at compile time

1
constexpr auto make_sorted() {
2
    std::array arr = {5, 2, 8, 1, 4};
3
    std::sort(arr.begin(), arr.end());   // C++20 constexpr
4
    return arr;
5
}

1
template<typename T, size_t N>
2
constexpr int binary_search(const std::array<T, N>& arr, T value) {
3
    int low = 0;
4
    int high = N - 1;
5
    while (low <= high) {
6
        int mid = (low + high) / 2;
7
        if (arr[mid] == value) return mid;
8
        if (arr[mid] < value) low = mid + 1;
9
        else high = mid - 1;
10
    }
11
    return -1;
12
}
13

14
constexpr std::array<int, 8> sorted = {1, 3, 7, 15, 31, 63, 127, 255};
15
constexpr int idx = binary_search(sorted, 31);   // = 4, compile time
16

17
static_assert(idx == 4);

1
#include <string_view>
2

3
constexpr bool starts_with(std::string_view s, std::string_view prefix) {
4
    if (prefix.size() > s.size()) return false;
5
    for (size_t i = 0; i < prefix.size(); ++i) {
6
        if (s[i] != prefix[i]) return false;
7
    }
8
    return true;
9
}
10

11
constexpr bool a = starts_with("hello world", "hello");   // true
12
constexpr bool b = starts_with("hi", "hello");            // false
13

14
static_assert(a);
15
static_assert(!b);

1
constexpr uint32_t fnv1a(std::string_view s) {
2
    uint32_t hash = 2166136261u;
3
    for (char c : s) {
4
        hash ^= static_cast<uint32_t>(c);
5
        hash *= 16777619u;
6
    }
7
    return hash;
8
}
9

10
constexpr uint32_t kEventStart    = fnv1a("event_start");
11
constexpr uint32_t kEventStop     = fnv1a("event_stop");
12
constexpr uint32_t kEventError    = fnv1a("event_error");
13

14
// 런타임 switch
15
switch (event_hash) {
16
    case kEventStart: /* */ break;
17
    case kEventStop:  /* */ break;
18
    case kEventError: /* */ break;
19
}

1
// 기본 데이터
2
constexpr std::array<float, 8> raw_thresholds = {
3
    10.5f, 22.3f, 45.7f, 78.1f, 100.0f, 150.5f, 200.0f, 300.0f
4
};
5

6
// 컴파일 타임 변환 — fixed-point Q16.16
7
constexpr std::array<int32_t, 8> make_fixed_point() {
8
    std::array<int32_t, 8> result{};
9
    for (size_t i = 0; i < raw_thresholds.size(); ++i) {
10
        result[i] = static_cast<int32_t>(raw_thresholds[i] * (1 << 16));
11
    }
12
    return result;
13
}
14

15
constexpr auto fixed_thresholds = make_fixed_point();
16
// 컴파일 타임 변환된 fixed-point 값들이 Flash에

1
constexpr int kMaxTasks = 16;
2
constexpr int kStackSize = 2048;
3
constexpr int kTotalStackMemory = kMaxTasks * kStackSize;
4

5
constexpr int kAvailableRamForStacks = 64 * 1024;   // 64 KB
6

7
static_assert(kTotalStackMemory <= kAvailableRamForStacks,
8
              "Stack memory exceeds available RAM");
9

10
// kMaxTasks를 32로 늘리면 — 컴파일 에러

1
constexpr uint32_t pin_mask(int pin) {
2
    return 1u << pin;
3
}
4

5
constexpr uint32_t pins_mask(std::initializer_list<int> pins) {
6
    uint32_t mask = 0;
7
    for (int p : pins) mask |= pin_mask(p);
8
    return mask;
9
}
10

11
constexpr uint32_t kLedMask = pins_mask({13, 14, 15});   // 0xE000
12

13
GPIOA->ODR |= kLedMask;   // 런타임에 그냥 상수 OR

1
enum class State { Idle, Running, Paused, Stopped };
2

3
constexpr const char* to_string(State s) {
4
    switch (s) {
5
        case State::Idle:    return "Idle";
6
        case State::Running: return "Running";
7
        case State::Paused:  return "Paused";
8
        case State::Stopped: return "Stopped";
9
    }
10
    return "Unknown";
11
}
12

13
constexpr const char* name = to_string(State::Running);   // "Running"

1
// C++20
2
constexpr int sum_vector() {
3
    std::vector<int> v;   // 컴파일 타임 vector
4
    for (int i = 1; i <= 100; ++i) v.push_back(i);
5
    int total = 0;
6
    for (int x : v) total += x;
7
    return total;   // v는 여기서 destruction
8
}
9

10
constexpr int sum = sum_vector();   // = 5050

1
struct DeviceConfig {
2
    const char* name;
3
    uintptr_t base_address;
4
    int irq_number;
5
    int priority;
6
};
7

8
constexpr DeviceConfig devices[] = {
9
    {"UART1", 0x40011000, 37, 5},
10
    {"UART2", 0x40004400, 38, 5},
11
    {"SPI1",  0x40013000, 35, 6},
12
    {"I2C1",  0x40005400, 31, 7},
13
};
14

15
constexpr size_t kDeviceCount = std::size(devices);
16

17
// 컴파일 타임 검색
18
constexpr int find_irq(const char* name) {
19
    for (size_t i = 0; i < kDeviceCount; ++i) {
20
        // 컴파일 타임 string 비교 (C++17 string_view 또는 직접)
21
        // ...
22
    }
23
    return -1;
24
}

1
constexpr int f(int x) { /* */ }
2
int y = f(read_input());   // 런타임 호출 — constexpr 효과 없음

1
constexpr float f(float x) {
2
    return std::sin(x);   // ERROR — std::sin은 constexpr 아님 (대부분)
3
}

1
static_assert(kSize <= 4096);   // 실패 시 메시지 없음

1
# 런타임 초기화 (main에서)
2
.text       : +312 B (init function with sin loop)
3
.bss        : +1024 B (table)
4
init time   : ~12 ms (256 * sin calls)
5
boot time   : main까지 +12 ms
6

7
# constexpr
8
.text       : 0 B
9
.rodata     : +1024 B (Flash)
10
init time   : 0
11
boot time   : main까지 +0 ms