C++ Constexpr Variable

constexpr Type variable_name = constant_expression; // Copy initialization
constexpr Type variable_name{constant_expression};  // Direct list initialization
constexpr Type variable_name(constant_expression);  // Direct initialization

​

Core Mechanics and Compiler Rules

1. Constant Expression Initialization: The initialization expression must be a valid constant expression. This includes literal values, previously defined constexpr variables, or return values from constexpr functions evaluated with constant arguments.
2. Literal Type Requirement: The variable’s type must satisfy the LiteralType core language named requirement. This includes scalar types (e.g., int, double, char), references, arrays of literal types, aggregate types (which do not require explicitly defined constructors), and non-aggregate user-defined class types that possess at least one constexpr constructor and a constexpr destructor (as of C++20).
3. Implicit Constness: Declaring a variable as constexpr automatically applies the top-level const qualifier. The variable becomes immutable for its entire lifecycle.
4. Constant Destruction (C++20): The type of a constexpr variable must have constant destruction. While constexpr destructors can perform operations like freeing dynamically allocated memory during compile-time evaluation (transient allocation), any memory allocated during the compile-time initialization of a constexpr variable must also be deallocated before the evaluation completes. Allocations cannot escape the constant evaluation context to persist to runtime.

​

Syntax Visualization

// Valid: Initialized with a literal via direct list initialization
constexpr int max_connections{100};

// Valid: Initialized with a constant expression using another constexpr variable
constexpr int connection_pool_size = max_connections * 4;

// Valid: Initialized via a constexpr function
constexpr int get_multiplier() { return 5; }
constexpr int total_capacity = max_connections * get_multiplier();

// Invalid: Attempting to initialize with a runtime variable
int runtime_multiplier = 5;
constexpr int invalid_capacity = max_connections * runtime_multiplier; // COMPILER ERROR

// Invalid: Self-referential pointer to a subobject
// Note: std::string is a literal type in C++20, but Small String Optimization (SSO) 
// utilizes a self-referential pointer to its own internal buffer. C++ rules forbid 
// constant expressions from evaluating to a value that contains a pointer to a 
// subobject of the object being initialized.
constexpr std::string app_name = "MyApp"; // COMPILER ERROR

​

Mechanical Distinction: constexpr vs. const

• const dictates access semantics. It promises the compiler that the program will not modify the variable after initialization. A const variable can be initialized at runtime.
• constexpr dictates evaluation semantics. It promises the compiler that the variable’s value is fully computable before the program ever runs.

// Valid const: Evaluated at runtime, immutable thereafter
const int runtime_const = std::rand(); 

// Invalid constexpr: std::rand() cannot be evaluated at compile time
constexpr int compile_const = std::rand(); // COMPILER ERROR

​

Pointer and Reference Semantics

int global_value = 42;

// Valid: The pointer itself is a compile-time constant pointing to a static memory address
constexpr int* ptr = &global_value; 

// Valid: The reference is bound at compile time to a static memory address
constexpr int& ref = global_value;