In C++ is "const" after type ID acceptable?
My co-worker is 0 for 2 on questions he has inspired (1, 2), so I thought I'd give him a chance to catch up.
Our latest disagreement is over the style issue of where to put "const" on declarations.
He is of the opinion that it should go either in front of the type, or after the pointer. The reasoning is that this is what is typically done by everyone else, and other styles are liable to be confusing. Thus a pointer to a constant int, and a constant pointer to int would be respectively:
const int *i;
int * const i;
However, I'm confused anyway. I need rules that are consistent and easy to understand, and the only way I can make sense of "const" is that it goes after the thing it is modifying. There's an exception that allows it to go in front of the final type, but that's an exception, so it's easier on me if I don't use it.
Thus a pointer to a constant int, and a constant pointer to int would be respectively:
int const * i;
int * const i;
As an added benefit, doing things this way makes deeper levels of indirection easier to understand. For example, a pointer to a constant pointer to int would clearly be:
int * const * i;
My contention is that if someone just learns it his way, they'll have little trouble figuring out what the above works out to.
The ultimate issue here is that he thinks that putting const after int is so unspeakably ugly, and so harmful to readability that it should be banned in the style guide. Of course, I think if anything the guide should suggest doing it my way, but either way we shouldn't be banning one approach.
Edit: I've gotten a lot of good answers, but none really directly address my last paragraph ("The ultimate issue"). A lot of people argue for consistency, but is that so desirable in this case that it is a good idea to ban the other way of doing it, rather that just discouraging it?
The most important thing is consistency . If there aren't any coding guidelines for this, then pick one and stick with it. But, if your team already has a de facto standard, don't change it!
That said, I think by far the more common is
const int* i;
int* const j;
because most people write
const int n;
instead of
int const n;
A side note -- an easy way to read pointer const ness is to read the declaration starting at the right.
const int* i; // pointer to an int that is const
int* const j; // constant pointer to a (non-const) int
int const* aLessPopularWay; // pointer to a const int
There's a class of examples where putting the const on the right of the type also helps avoid confusion.
If you have a pointer type in a typedef, then it is not possible to change the constness of the to type:
typedef int * PINT;
const PINT pi;
'pi' still has the type 'int * const', and this is the same no matter where you write the 'const'.
I hope this explanation from B. Stroustrup's FAQ on Style & Techniques will give you a definite answer.
Bjarne Stroustrup's C++ Style and Technique FAQ
I personaly prefer:
int const* pi;
int* const pi;
Because const identifies the left token which is intended to be const.
And you definitely keep the same consistency when using smth like that:
int const* const pi;
Instead of writing inconsistently:
const int* const pi;
And what happens if you have a pointer to pointer and so on:
int const* const* const pi;
Instead of:
const int* const* const pi;
Regards,
Ovanes
链接地址: http://www.djcxy.com/p/21242.html