C/C++ convention for pointers and `const`

Question

I have read this (Pasted below as well) on Wikipedia:

Following usual C convention for declarations, declaration follows use, and the * in a pointer is written on the pointer, indicating dereferencing. For example, in the declaration int *ptr, the dereferenced form *ptr is an int, while the reference form ptr is a pointer to an int. Thus const modifies the name to its right. The C++ convention is instead to associate the * with the type, as in int* ptr, and read the const as modifying the type to the left. int const * ptrToConst can thus be read as "*ptrToConst is a int const" (the value is constant), or "ptrToConst is a int const *" (the pointer is a pointer to a constant integer).

I really am not able to get a satisfying interpretation:

• In which sense does it modify?

• What is intended with name vs type (see the above link)?

• And why should it be on the right side of const?

Answer 1

The const, volatile and restrict (C99 onwards) keywords are considered type qualifiers. They are an integral part of type signatures and describe additional semantics about a type.

If they appear at the topmost level of a declaration, they affect the declared identifier:

const int a = 5; // prevents modifications of "a"
int *const p = &x; // prevents modifications of "p", but not "*p"
int **const q = &y; // prevents modifications of "q", but not "*q" and "**q"

If they appear in pointer subtypes (before an asterisk), they affect the pointed-to value at the particular level of dereferencing:

const int *p = &x; // prevents modifications of "*p", but not "p"
const int **q = &y; // prevents modifications of "**q", but not "*q" and "q"
const int *const *r = &z; // prevents modifications of "**r" and "*r", but not "r"
const int *const *const s = &a; // prevents modifications of "**s", "*s" and "s"

The Wikipedia excerpt discusses two different conventions for declaring pointers:

int *p; // more common in C programming
int* p; // more common in C++ programming

I would say that the "true" convention is the first one because it works according to the syntax of the language (declarations mirror use). The asterisk in that declaration is in fact the same dereferencing operator that you would use on the pointer in normal expressions. Thus the int type is returned after applying * (indirection) on p (the pointer itself).

Also note that the ordering of type qualifiers with respect to type specifiers and other type qualifiers does not matter, so these declarations are equivalent:

const int a; // preferred
int const a; // same, not preferred

const volatile int b; // preferred
volatile const int b; // same, not preferred
volatile int const b; // same, not preferred

const int *p; // preferred
int const *p; // same, not preferred

Answer 2

In which sense does it modify?

Modifies in the sense that it makes it constant, meaning it can't be modifed (assigned to, or passed to a function which might modify it).

What is intended with name vs type (see the above link)?

Name means the word written in the source code here, I think.

And why should it be on the right side of const?

"Modifies name to its right" means, by example:

const char * str, here const modifies char, in other words the characters are constant, you can't modify them. You can make str point to a new char, but you still can't modify it either (at least not through str). *str = 'a'; is compiler error, str = "foo"; is ok.

char * const str, here const modifies str, in other words the value of str can't be modified. It points to some char, and you can modify that char through str, but you can't make str to point to another char. *str = 'a'; is now ok, str = "foo"; is error.