C++ Constant Initialization | "Guide to Constant Initialization"

What is Constant Initialization?

Constant initialization refers to initialization where the value is determined at compile time. It is often used alongside constexpr functions, constexpr if, and is distinct from value initialization and zero initialization.

constexpr int x = 10;  // Constant initialization
int y = compute();     // Dynamic initialization

constexpr Variables

constexpr int MAX = 100;
constexpr double PI = 3.14159;
constexpr const char* MSG = "Hello";

// Compile-time computation
constexpr int square(int x) {
    return x * x;
}

constexpr int result = square(5);  // 25

Practical Examples

Example 1: Array Size

constexpr size_t SIZE = 10;
int arr[SIZE];  // OK: Compile-time constant

void func(int n) {
    // int arr2[n];  // Error: VLA (non-standard in C++)
}

Example 2: Static Variables

struct Config {
    int width;
    int height;
};

constexpr Config defaultConfig = {800, 600};

int main() {
    Config cfg = defaultConfig;
}

Example 3: constinit (C++20)

// constinit: Forces constant initialization
constinit int x = 10;  // OK: Compile-time

// constinit int y = compute();  // Error: Runtime

// constexpr vs constinit
constexpr int a = 10;  // Compile-time constant
constinit int b = 10;  // Constant initialization, but can be modified at runtime

int main() {
    // a = 20;  // Error: constexpr
    b = 20;  // OK: constinit
}

Example 4: Static Initialization Order

// file1.cpp
constexpr int x = 10;
constexpr int y = x + 1;  // OK: Order guaranteed

// file2.cpp
int a = 10;
int b = a + 1;  // Order not guaranteed (dynamic initialization)

Initialization Order

// 1. Zero initialization
static int x;  // 0

// 2. Constant initialization
constexpr int y = 10;

// 3. Dynamic initialization
int z = compute();

Common Issues

Issue 1: Dynamic Initialization

// ❌ Runtime computation
int getValue() { return 42; }
constexpr int x = getValue();  // Error

// ✅ constexpr function
constexpr int getValue() { return 42; }
constexpr int x = getValue();  // OK

Issue 2: Static Initialization Order Problems

// file1.cpp
int x = compute1();

// file2.cpp
extern int x;
int y = x + 1;  // x might not be initialized yet

// ✅ Use constexpr
constexpr int x = 10;
constexpr int y = x + 1;  // Order guaranteed

Issue 3: constinit Restrictions

// ❌ Local variables
void func() {
    // constinit int x = 10;  // Error
}

// ✅ Only for static variables
constinit static int x = 10;
constinit int global = 10;

Issue 4: Pointers

// ❌ Runtime address
int x = 10;
constexpr int* ptr = &x;  // Error

// ✅ constexpr variable
constexpr int y = 10;
constexpr const int* ptr = &y;  // OK (C++20)

Performance Benefits

// Dynamic initialization: runtime cost
int x = expensiveComputation();

// Constant initialization: no cost
constexpr int x = 42;

FAQ

Q1: What is constant initialization?

A: Initialization at compile time.

Q2: constexpr vs constinit?

A:

• constexpr: Compile-time constant.
• constinit: Forces constant initialization but allows runtime modification.

Q3: Performance?

A: No runtime cost.

Q4: Initialization order?

A: Zero -> Constant -> Dynamic.

Q5: When to use?

A:

• For compile-time constants.
• To prevent static initialization order issues.

Q6: Resources for learning constant initialization?

A:

• “Effective Modern C++”
• “C++20 The Complete Guide”
• cppreference.com

Related Posts: constexpr functions, constexpr if, value initialization, zero initialization.

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ constexpr 함수 | “컴파일 타임 함수” 가이드
• C++ constexpr if | “컴파일 타임 분기” 가이드
• C++ Value Initialization | “값 초기화” 가이드
• C++ Zero Initialization | “0 초기화” 가이드

---

---

이 글에서 다루는 키워드 (관련 검색어)

C++, constant-initialization, constexpr, constinit, C++20 등으로 검색하시면 이 글이 도움이 됩니다.