Question
To start you probably know that const
can be used to make either an object's
data or a pointer not modifiable or both.
const Object* obj; // can't change data
Object* const obj; // can't change pointer
const Object* const obj; // can't change data or pointer
However you can also use the syntax:
Object const *obj; // same as const Object* obj;
The only thing that seems to matter is which side of the asterisk you put the
const
keyword. Personally I prefer to put const
on the left of the type to
specify it's data is not modifiable as I find it reads better in my left-to-
right mindset but which syntax came first?
More importantly why is there two correct ways of specifying const
data and
in what situation would you prefer or need one over the other if any?
Edit
So it sounds like this was an arbitrary decision when the standard for how
compilers should interpret things was drafted long before I was born. Since
const
is applied to what is to the left of the keyword (by default?) I guess
they figured there was no harm in adding "shortcuts" to apply keywords and
type qualifiers in other ways at least until such a time as the declaration
changes by parsing a *
or &
...
This was the case in C as well then I'm assuming?
Answer
why is there two correct ways of specifying
const
data and in what situation would you prefer or need one over the other if any?
Essentially, the reason that the position of const
within specifiers prior
to an asterisk does not matter is that the C grammar was defined that way by
Kernighan and Ritchie.
The reason they defined the grammar in this way was likely that their C
compiler parsed input from left-to-right and finished processing each token as
it consumed that. Consuming the *
token changes the state of the current
declaration to a pointer type. Encountering const
after *
means the
const
qualifier is applied to a pointer declaration; encountering it prior
to the *
means the qualifier is applied to the data pointed to.
Because the semantic meaning does not change if the const
qualifier appears
before or after the type specifiers, it is accepted either way.
A similar sort of case arises when declaring function pointers, where:
-
void * function1(void)
declares a function which returnsvoid *
, -
void (* function2)(void)
declares a function pointer to a function which returnsvoid
.
Again the thing to notice is that the language syntax supports a left-to-right parser.