Understanding `const int*`, `const int * const`, and `int * const` in C and C++

By the end of this page, you will understand how const applies to pointers in C and C++, how to read declarations from right to left, and what each form allows you to change: the value, the pointer, both, or neither. You will also see how these types behave in assignments and function parameters.

const with pointers can apply to two different things:

• the value being pointed to
• the pointer variable itself

That is why pointer declarations with const can look similar but behave differently.

Consider these three common forms:

const int *p;
int * const p;
const int * const p;

They mean:

• const int *p → pointer to a constant integer
• int * const p → constant pointer to an integer
• const int * const p → constant pointer to a constant integer

The key idea

A pointer has two separate properties:

1. What it points to
2. Whether the pointer itself can be changed

const can lock either one.

Why this matters

This is important in real programs because developers use const to:

Think of a pointer as a sticky note with an address written on it.

There are two things you might want to protect:

• the paper the sticky note points to
• the address written on the sticky note

const int *p

The address on the sticky note can change, but the paper is read-only through this pointer.

• you can move the sticky note to another address
• you cannot edit the value through this pointer

int * const p

The sticky note's address is permanent, but the paper is editable.

• you cannot move the sticky note to a new address
• you can edit the value at that address

const int * const p

Both are locked.

• you cannot move the sticky note
• you cannot edit the value through this pointer

This mental model helps because most confusion comes from mixing up:

• changing where the pointer points
• changing the data at that location

Core syntax

const int *p;        // pointer to const int
int const *p;        // same meaning as above
int * const p = &x;  // const pointer to int
const int * const p = &x; // const pointer to const int

const int *p and int const *p mean the same thing. The position of const around the base type does not change the meaning here.

Example 1: pointer to const int

int a = 10;
int b = 20;

const int *p = &a;

p = &b;     // valid: pointer can change
//*p = 30;  // invalid: cannot modify value through p

Explanation

• p can point to a, then later to b
• but *p is treated as read-only through

Consider this example:

#include <iostream>

int main() {
    int a = 10;
    int b = 20;

    const int *p1 = &a;
    int * const p2 = &a;
    const int * const p3 = &a;

    p1 = &b;
    *p2 = 15;

    std::cout << a << " " << b << '\n';
    std::cout << *p1 << " " << *p2 << " " << *p3 << '\n';
}

Step by step

1. int a = 10; int b = 20;

Two integers are created.

• a holds 10
• b holds 20

2. const int *p1 = &a;

p1 points to .

1. Read-only function parameters

void displayScore(const int *score) {
    std::cout << *score << '\n';
}

Use const int * when a function should inspect data without modifying it.

2. Protecting API inputs

In larger systems, functions often receive pointers to shared data. Marking data as const prevents accidental writes.

bool isPositive(const int *value) {
    return *value > 0;
}

3. Fixed internal references

A const pointer can be useful when a pointer member or local alias should never be redirected after setup.

int value = 42;
int * const fixedPtr = &value;

This is less common in everyday application code than const int *, but it can still be useful when pointer reassignment would be a bug.

4. Read-only handles to configuration data

In real projects, const with pointers is mostly about communicating intent and preventing bugs.

Common patterns

Guarding inputs

void logUserId(const int *userId) {
    if (userId == nullptr) return;
    std::cout << *userId << '\n';
}

This combines:

• a pointer validity check
• read-only access

Validation before mutation

bool setIfPositive(int *value, int newValue) {
    if (value == nullptr) return false;
    if (newValue < 0) return false;

    *value = newValue;
    return true;
}

When mutation is intended, use int *, not const int *.

1. Confusing “const data” with “const pointer”

Broken code:

int a = 10;
int b = 20;

int * const p = &a;
p = &b; // error

Why it fails:

• p itself is const
• the pointer cannot be reassigned

2. Trying to modify data through const int *

Broken code:

int a = 10;
const int *p = &a;
*p = 99; // error

Why it fails:

• the pointed-to value is treated as read-only through p

3. Removing const protection in assignment

Broken code:

const int x = 5;
int *p = &x; // error

Why it fails:

Pointer constness comparison

const int * vs

Quick reading rule

Start at the variable name and read outward.

• const int *p → p is a pointer to const int
• int * const p → p is a const pointer to int
• const int * const p → p is a const pointer to const int

What each form allows

int *p;

• change p ✅
• change *p ✅

const int *p;

• change p ✅
• change *p ❌

int * const p = &x;

• change p ❌
• change *p ✅

What is the easiest way to read pointer const declarations?

Start at the variable name and move outward. This usually makes the meaning clear.

Is const int *p the same as int const *p?

Yes. Both mean “pointer to const int.”

Can I assign an int * to a const int *?

Yes. That is safe because it adds const protection.

Can I assign a const int * to an int *?

No. That would remove const protection and could allow illegal modification.

Does const int *p mean the integer can never change?

No. It only means you cannot change it through p. The original variable may still change through another non-const name or pointer.

Why must int * const p be initialized immediately?

Because the pointer itself cannot be changed later, so it needs its final address at declaration time.

Should I use pointers or references in C++ for read-only parameters?

If null is not a valid state, const int & is often clearer in C++. If null is meaningful, use .

• const correctness — helps keep APIs and data access safe and consistent.
• pointers — this topic builds directly on basic pointer syntax and dereferencing.
• references in C++ — often compared with pointers for function parameters.
• function parameters — pointer constness is especially important when passing arguments.
• pass by pointer vs pass by reference — closely related to mutability and API design.
• nullptr and null pointer checks — important when working with pointer parameters.
• type qualifiers — const is one of the core qualifiers in C and C++.
• arrays and pointer decay — useful because arrays are commonly passed as pointer parameters.