Reading pointer declarations

Read layer by layer starting from the name

Find the name first, then identify the declaration structure that immediately surrounds it. In int* slots[3] the name first forms an array declaration, so slots is an array of three pointers. In int (*row)[3] parentheses bind the name to the star first, so row is a pointer to an array of three integers. They differ not only in syntax but also in the unit of stepping.

Functions work the same way: int* make() declares a function that returns a pointer to int; int (*apply)(int) declares a pointer to a function that takes an int and returns an int. Do not rely on a vague clockwise mnemonic. Parentheses determine the layer first; array and function suffixes then decide the type of that layer.

Locate const layer by layer

const int* p and int const* p both mean you must not modify the integer through p, but p may be repointed. int* const p fixes the pointer itself while still allowing the target to be modified. const int* const p restricts both; it does not mean no other alias can modify an originally non-const object.

Multi-level pointers must still be analyzed layer by layer. int** cannot be converted directly to const int**, otherwise you could, through the second-level pointer, stuff the address of a truly read-only object into a writable integer pointer. Adding one layer of const is not safe everywhere; having the compiler reject this conversion protects write permission.

Use aliases to express intent, not to hide complexity

using Unary = int (*)(int) extracts a function pointer into a readable name, so a callback interface can write Unary directly. An alias does not create a new type and does not change const semantics: if using P = int*, then const P is a constant pointer, not a pointer to a constant integer.

The example operates on an array of pointers, a pointer to an array, and a function pointer, and uses static_assert to confirm the alias meaning. Stars in a declaration list belong to their own declarators; in int* a, b only a is a pointer. In real maintenance, writing one name per declaration is usually more reliable than asking readers to keep peeling declarations apart.

Pitfalls

• int (*p)[3] is not int**; the former points to a complete array. You cannot force-cast a two-dimensional array to disguise it as the latter.
• const on a type alias qualifies the whole aliased type. You cannot treat the alias as a text macro, expand it, and then guess what is qualified.

Minimum C++11 · complete program · Download .cpp

#include <cassert>
#include <type_traits>

int increment(int value) { return value + 1; }

int main() {
    int values[]{3, 5, 7};
    int* slots[3]{&values[0], &values[1], &values[2]};
    int (*row)[3] = &values;
    using Unary = int (*)(int);
    Unary apply = &increment;
    assert(*slots[1] == 5);
    assert((*row)[2] == 7);
    assert(apply((*row)[0]) == 4);
    using P = int*;
    static_assert(std::is_same<const P, int* const>::value, "const qualifies pointer");
}

Compile locally

g++ -std=c++11 -Wall -Wextra -Wpedantic -pthread memory-pointer-declarations.cpp -o example && ./example

Expected result

Expected: exit 0, no output; every assert holds.

CHECK YOUR UNDERSTANDING

Close the answer. Explain it.

Explain const int* table[2], and write a pointer to an array of two read-only integers.

Check the sources

• cppreference：Pointer declaration 语法与 const 限定

Drafts and official chapters change. The version mark is only the example’s minimum.