C++ const and Constants: const, constexpr, and consteval

Why Constants Exist

A constant is a value you promise never to change after you set it. Marking something const does two jobs at once: it documents your intent to anyone reading the code, and it lets the compiler enforce that intent - any line that tries to modify the value becomes a compile error rather than a silent runtime bug.

Where the auto keyword let the compiler infer a variable's type, const constrains what you can do with that variable. The two combine freely: const auto limit = 100; is a read-only int.

Declaring a const Value

Put const before the type. A const variable must be initialized on the same line, because there is no later moment when you are allowed to assign to it.

#include <iostream>
using namespace std;

int main() {
    const int maxUsers = 100;
    const double pi = 3.14159;

    cout << "Max users: " << maxUsers << "\n";
    cout << "Pi: " << pi << "\n";

    // maxUsers = 200; // error: assignment of read-only variable
    return 0;
}

Uncomment the assignment and the program will not compile - the compiler reports "assignment of read-only variable". That is exactly the point: the mistake is caught before the program ever runs.

A common beginner habit carried from C is #define MAX_USERS 100. Avoid it. A macro is a blind text substitution with no type and no respect for scope, so it cannot be inspected in a debugger and produces confusing error messages. A const (or constexpr) variable is type-checked and scoped like any other.

const vs constexpr

Both keywords give you a value that cannot change, but they answer different questions. const says "this never changes after it is set". constexpr says the stronger "this can be computed at compile time" - and anything constexpr is automatically const too.

#include <iostream>
using namespace std;

int main() {
    int n = 5;
    const int a = n;          // OK: runtime value, just read-only
    constexpr int b = 10;     // OK: known at compile time
    // constexpr int c = n;   // error: n is not a compile-time constant

    int grid[b];              // legal: array size must be a compile-time constant
    cout << "Array length: " << sizeof(grid) / sizeof(grid[0]) << "\n";
    cout << a << " " << b << "\n";
    return 0;
}

The rule of thumb: reach for constexpr whenever the value is a fixed literal or a calculation the compiler can do (array sizes, buffer lengths, switch labels, template arguments). Use plain const when the value is decided at runtime but should not change afterward - like a const copy of a function argument.

Since C++20 there is also consteval, used on functions that must run at compile time:

consteval int square(int x) { return x * x; }
constexpr int area = square(8); // computed during compilation

A constexpr function may run at compile time; a consteval function always must, or it is an error.

Pointers and const: Read Right-to-Left

This is where const trips people up, because the keyword can sit on either side of the * and the two meanings are opposite. The trick is to read the declaration from right to left.

#include <iostream>
using namespace std;

int main() {
    int x = 1, y = 2;

    const int* p1 = &x;   // pointer to const int: can repoint, can't edit *p1
    p1 = &y;              // OK
    // *p1 = 5;           // error: *p1 is const

    int* const p2 = &x;   // const pointer to int: can edit *p2, can't repoint
    *p2 = 99;             // OK
    // p2 = &y;           // error: p2 is const

    const int* const p3 = &x; // const pointer to const int: neither allowed

    cout << *p1 << " " << *p2 << " " << *p3 << "\n";
    return 0;
}

Read int* const p2 right-to-left: "p2 is a const pointer to int". Read const int* p1 as "p1 is a pointer to const int". Get this wrong and you will spend real time confused by an error that says you cannot modify something you thought was mutable.

A practical gotcha: never take the address of a const and cast the const away to modify the underlying object. Doing so is undefined behavior if the original object was truly const, and the compiler is free to assume the value never changes - your "write" may simply be ignored.

const References as Function Parameters

The most common everyday use of const is passing large objects by reference without copying them. A const& parameter avoids the copy and promises the function will not modify the caller's argument.

#include <iostream>
#include <string>
using namespace std;

// No copy of the string is made, and we can't accidentally mutate it.
void greet(const string& name) {
    // name += "!"; // error: name is const
    cout << "Hello, " << name << "!\n";
}

int main() {
    string user = "Ada";
    greet(user);
    greet("Grace"); // const& also binds to a temporary literal
    return 0;
}

Pass-by-const& is the default choice for any parameter bigger than a couple of bytes (strings, vectors, your own classes). Note it also lets the function accept a temporary like "Grace" - a plain non-const reference cannot bind to a temporary, so dropping the const here would reject that second call.

const Member Functions

When you write a class, mark any method that does not modify the object with a trailing const. This is what makes the method callable on const instances and on const& parameters - without it, you cannot read your own object through a const handle.

#include <iostream>
#include <string>
using namespace std;

class Account {
    double balance = 0;
public:
    void deposit(double amount) { balance += amount; } // modifies -> not const
    double getBalance() const { return balance; }       // read-only -> const
};

int main() {
    Account a;
    a.deposit(50);

    const Account& ref = a;        // a read-only view
    cout << ref.getBalance() << "\n"; // works only because getBalance() is const
    // ref.deposit(10);            // error: deposit() is not const
    return 0;
}

The discipline of marking read-only methods const is called const correctness. Get it right early - a method that should have been const is easy to add, but retrofitting const across a large codebase later is painful because every caller through a const reference depends on it.

Next: Operators

Now that your values can be locked down with const, the next step is doing things with them. The operators page covers arithmetic, comparison, logical, and assignment operators - including the gotchas around integer division, operator precedence, and how const interacts with the assignment operators you are not allowed to use.