const in C++: variables, pointers, references, methods

In C++, const marks something as read-only: once a const variable has its value, the compiler rejects any direct change to it. The same keyword makes a pointer or a reference read-only for what it refers to, and on a member function it promises not to change the object. Use it wherever a value should not change.

A login limit, in a whole program:

#include <iostream>

int main() {
    const int max_attempts = 3;

    for (int attempt = 1; attempt <= max_attempts; ++attempt) {
        std::cout << "Attempt " << attempt << " of " << max_attempts
                  << '\n';
    }
}

It printed:

Attempt 1 of 3
Attempt 2 of 3
Attempt 3 of 3

Try to change the limit, and the program no longer compiles:

const int max_attempts = 3;
max_attempts = 5;  // error: max_attempts is const

Clang said:

error: cannot assign to variable 'max_attempts' with const-qualified type 'const int'

The samples are standard C++17, built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++). All four accepted and rejected the same lines; Since When lists the compiler releases for each standard.

How do you declare a const variable?

Write const before the type and give the value in the same declaration, as const int max_attempts = 3; does; int const means the same. A const int with no value does not compile, since nothing could set it later (default-initialization): const int limit; stopped all four, GCC with uninitialized 'const limit'.

A const member of a class cannot be assigned later either. It takes its value from a default in the class, as in const int attempts_ = 3;, or in the constructor’s member initializer list, the part after the colon (how a C++ constructor sets its members).

What is the difference between const int* and int* const?

Read the declaration from right to left: const int* p is a pointer to a const int, and int* const p is a const pointer to an int. A pointer is a variable that holds the address of another (&balance is the address of balance, and *view the int that view points to). const before the * applies to the int, after it to the pointer itself, so int const* p is the same as const int* p (pointer declarations):

int balance = 100;
int savings = 500;

const int* view = &balance;  // pointer to a const int
view = &savings;             // fine: view points elsewhere
std::cout << *view << '\n';  // 500

int* const account = &balance;  // const pointer to an int
*account = 150;                 // fine: the int changes
std::cout << balance << '\n';   // 150

const int* const fixed = &savings;  // both are locked
std::cout << *fixed << '\n';        // 500

All four printed 500, 150 and 500. Each pointer refuses the other operation. Writing through view does not compile:

*view = 200;  // error: the int is const through view

GCC said assignment of read-only location '* view'. Pointing account at another int fails too:

account = &savings;  // error: the pointer itself is const

GCC: assignment of read-only variable 'account'.

What is a const reference?

A const reference lets a function read the caller’s object without copying it and without being able to change it. A reference is another name for an existing object, so const std::string& name refers to the caller’s own string: nothing is copied, and name is read-only inside the function.

#include <iostream>
#include <string>

void greet(const std::string& name) {
    std::cout << "Hello, " << name << '\n';
}

int main() {
    std::string owner = "Ada";
    greet(owner);    // name refers to owner: no copy
    greet("Grace");  // a temporary std::string binds to name
}

It printed Hello, Ada and Hello, Grace. A const reference also accepts a literal: for greet("Grace") C++ builds a temporary std::string for name to refer to (reference initialization). A plain std::string& name would not: C++ binds a temporary to a const reference, not to a plain one, and all four rejected greet("Grace") with that parameter. Inside greet, name += "!"; stopped all four; MSVC said binary '+=': no operator found which takes a left-hand operand of type 'const std::string'.

Whether a parameter should be a const reference or a plain value depends on its type and on what the function does with it; pass by value or by const reference has the rule.

What is a const member function?

A const member function promises not to change the object it is called on: write const after the parameter list, as in int balance() const. A member function is a function declared inside a class, and these are what “const functions” means in C++. A free function, one outside any class, cannot be const: there is no object for the promise to cover.

class Account {
public:
    int balance() const { return balance_; }  // only reads
    void deposit(int amount) { balance_ += amount; }

private:
    int balance_ = 0;
};

void print_balance(const Account& account) {
    std::cout << "Balance: " << account.balance() << '\n';
}

It printed Balance: 100 after a deposit of 100. Only const member functions can be called on a const object or through a const reference, so print_balance can call balance() but not deposit():

void add_bonus(const Account& account) {
    account.deposit(10);  // error: deposit() is not const
}

Clang said:

error: 'this' argument to member function 'deposit' has type 'const Account', but function is not marked const

this is the pointer to the object a member function was called on. Through a const Account& that object is const, and deposit() does not promise to leave it alone, so the call is refused.

The compiler holds a const member function to its promise, too: balance_ -= 1; inside balance() const stopped all four, MSVC with 'balance_' cannot be modified because it is being accessed through a const object. Defined outside the class, the function needs const in both its declaration and its definition. Mark every member function that only reads as const, or code holding a const reference cannot call it (const-qualified member functions).

const vs constexpr: what is the difference?

const means a value does not change once it is set, and that value may be worked out while the program runs. constexpr means the value is known when the program is compiled, so it can go where the compiler needs a number, such as an array size or a static_assert, a check the compiler makes:

const int typed = read_number();  // fixed when the program runs
constexpr int size = 10;          // known when it is compiled

int deposits[size] = {};    // an array size must be known
static_assert(size == 10);  // checked by the compiler

std::cout << typed << ' ' << std::size(deposits) << '\n';

Here read_number() reads an int typed in; given 7, all four printed 7 10. A const int set from a constant, such as const int size = 10;, can be an array size too; what constexpr adds is the guarantee: constexpr int typed = read_number(); does not compile, and Clang said constexpr variable 'typed' must be initialized by a constant expression.

A constexpr variable is const as well ([dcl.constexpr]), so choose by when the value is known: constexpr for one the compiler can work out, const for one the program reads or computes as it runs.

When should you use const?

By default, wherever a value is not meant to change: “By default, make objects immutable” is the first rule of the C++ Core Guidelines on constants and immutability. Each const is a promise the compiler checks, so a change you did not mean becomes a compile error, as max_attempts = 5; did, instead of a bug you find later.

• const on every variable whose value does not change after it is set.
• A reference or pointer to const for a parameter the function only reads.
• const after the parameter list of every member function that only reads.
• constexpr for a value known when the program is compiled.

The Language section has the other answers on the core language.