What is the difference between const, constexpr, and volatile in C++?

In C++, const, constexpr, and volatile are three distinct keywords that serve different purposes related to variables and code behavior. Here’s how they differ:

1. const: Constant Variables

Declares a variable whose value cannot be changed after initialization. Used to ensure the variable is read-only. Example:

const int x = 10; // x cannot be modified

Key Point: const does not guarantee compile-time evaluation. For example:

const int runtimeValue = someFunction(); // Valid even if computed at runtime

2. constexpr: Compile-Time Constants

Introduced in C++11, constexpr ensures that the value of a variable or function can be evaluated at compile-time (if the inputs are also constants). Stricter than const and enforces determinism. Example:

constexpr int square(int x) { return x * x; }
constexpr int result = square(5); // Computed at compile-time

Key Point: constexpr helps in performance optimization by embedding computed results directly into the binary.

3. volatile: Prevent Compiler Optimizations

Used for variables that can change unexpectedly, such as hardware registers or shared memory in multithreading. It tells the compiler not to optimize access to the variable. Example:

volatile int flag = 0;
while (flag == 0) { /* Wait until flag changes */ }

Key Point: Useful in scenarios involving concurrency or hardware communication.

Summary

• const: Makes variables read-only but doesn’t enforce compile-time evaluation.
• constexpr: Ensures variables/functions are evaluated at compile-time (for constants).
• volatile: Ensures the compiler reads the variable directly every time, avoiding optimizations.

These keywords are used for different purposes: const for immutability, constexpr for performance and compile-time safety, and volatile for interacting with hardware or concurrency safely.