const and constexpr

Introduction

While working on a personal project, I learned about constexpr. I understood the difference between const and constexpr. However, I wondered why constexpr is necessary when const seems sufficient. I want to share what I found in…


This content originally appeared on DEV Community and was authored by MinBapE

Introduction

While working on a personal project, I learned about constexpr. I understood the difference between const and constexpr. However, I wondered why constexpr is necessary when const seems sufficient. I want to share what I found in this article.

const

A keyword that promises the compiler that a value cannot be changed.
Once initialized, the value cannot be modified.

const int MAX_USERS = 100;
MAX_USERS = 200;  // Compilation error!

Characteristics

  • The initialization value can be known at compile time or at runtime. 
int A;
std::cin >> A;
const int B = A;  // Valid
// Constant B is determined at runtime, but cannot be changed afterwards.
// The value doesn't need to be known at compile time, but once set, it cannot be changed.
  • It becomes more powerful when used with references and pointers. 
const int* ptr1;        // Cannot change the pointed value
int* const ptr2;        // Cannot change the pointer itself
const int* const ptr3;  // Cannot change both
  • When const is added to a class member function, the function promises not to change the object's state. 
class User {
private:
    std::string name;
    int age;
public:
    // Does not modify member variables
    std::string getName() const {
        return name;
        // age = 30;  // Error occurs
    }

    void setAge(int newAge) {
        age = newAge; // Valid
    }
};

Limitations

  • If a member variable is declared as mutable, it can be modified even in const member functions.
  • const can be forcibly removed using const_cast.

constexpr

constexpr is short for "constant expression".
Unlike const, it is a keyword that guarantees the compiler that the value is determined at compile time.
It was first introduced in C++11, and most restrictions have been lifted through version updates.

constexpr int func(int n) {
    return n * n;
}
constexpr int A = 1;        // Initialized to 1 at compile time
constexpr int B = func(2);  // Calculated to 4 at compile time
constexpr int C = func(B);  // Calculated to 16 at compile time

The critical difference from const is as follows:

int func() { 
    int value;
    std::cin >> value;
    return value;
}
const int a = func();      // Valid -> because it's determined at runtime
constexpr int b = func();  // Error occurs

Reasons to Use

  • Performance is improved as complex calculations can be completed at compile time through compile-time computation.
  • In C++, array sizes and template arguments must be compile-time constants.
  • Incorrect calculations can be caught before execution.
  • The compiler can perform more verification. 
// 1. Performance improvement
constexpr int factorial(int n) {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}
constexpr int result = factorial(10);  // Zero calculation cost at runtime

// 2. Array size
constexpr int SIZE = 100;
int buffer[SIZE];  // OK

const int size = getSize();
int arr[size];  // Error in most cases

// 3. Compile-time verification
constexpr int divide(int a, int b) {
    return b == 0 ? throw "error" : a / b;
}
constexpr int x = divide(10, 0);  // Compilation error occurs

When to Use const vs constexpr?

When to use const

  • Use when the value can be known at runtime, such as user input, configuration values read from files.
  • Use const to express the intention not to modify arguments passed to a function.
  • Member functions that do not change the object's state should be declared as const.

When to use constexpr

  • C++ array sizes must be compile-time constants.
  • Template parameters must be determined at compile time.
  • Use when you want to pre-calculate complex computations.
  • Use in switch statement case labels, static_assert, etc.
Situation const constexpr
User input value O X
Array size △ O
Template argument X O
Function parameter O X
Compile-time calculation △ O

Summary

const is a promise of immutability, and constexpr is a guarantee of compile-time calculation.
const can accept runtime values, but constexpr is determined only at compile time.


This content originally appeared on DEV Community and was authored by MinBapE


Print Share Comment Cite Upload Translate Updates
APA

MinBapE | Sciencx (2025-11-24T15:08:57+00:00) const and constexpr. Retrieved from https://www.scien.cx/2025/11/24/const-and-constexpr/

MLA
" » const and constexpr." MinBapE | Sciencx - Monday November 24, 2025, https://www.scien.cx/2025/11/24/const-and-constexpr/
HARVARD
MinBapE | Sciencx Monday November 24, 2025 » const and constexpr., viewed ,<https://www.scien.cx/2025/11/24/const-and-constexpr/>
VANCOUVER
MinBapE | Sciencx - » const and constexpr. [Internet]. [Accessed ]. Available from: https://www.scien.cx/2025/11/24/const-and-constexpr/
CHICAGO
" » const and constexpr." MinBapE | Sciencx - Accessed . https://www.scien.cx/2025/11/24/const-and-constexpr/
IEEE
" » const and constexpr." MinBapE | Sciencx [Online]. Available: https://www.scien.cx/2025/11/24/const-and-constexpr/. [Accessed: ]
rf:citation
» const and constexpr | MinBapE | Sciencx | https://www.scien.cx/2025/11/24/const-and-constexpr/ |

Please log in to upload a file.



There are no updates yet.
Click the Upload button above to add an update.

You must be logged in to translate posts. Please log in or register.

Related Posts