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?
The rule is:
I prefer using const on the right of the thing to be const just because it is the "original" way const is defined.
But I think this is a very subjective point of view.
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. Encounteringconst
after*
means theconst
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.
I prefer the second syntax. It helps me keep track of 'what' is constant by reading the type declaration from right to left:
There are historical reasons that either left or right is acceptable. Stroustrup had added const to C++ by 1983, but it didn't make it to C until C89/C90.
In C++ there's a good reason to always use const on the right. You'll be consistent everywhere because const member functions must be declared this way:
The first rule is to use whichever format your local coding standards requires. After that: putting the
const
in front leads to no end of confusion when typedefs are involved, e.g.:If your coding standard allows typedef's of pointers, then it really should insist on putting the const after the type. In every case but when applied to the type, const must follow what it applies to, so coherence also argues in favor of the const after. But local coding guidelines trump all of these; the difference isn't normally important enough to go back and change all of the existing code.
The order of the keywords in a declaration isn't all that fixed. There are many alternatives to "the one true order". Like this
or should it be
??