C - initialization of pointers, asterisk position [duplicate]

Answer 1

I've heard it argued that technically the * is a modifier to the variable, and this is evidenced by the need to use * multiple times in multi variable declarations eg. int *p, *q, *r;

However I like to think of it as a modifier to the base type because that is what appears in prototypes. eg. void func(int*);

.PMCD.

PS. I know I haven't helped your problem :)

Answer 2

It does not matter as far as you are declaring only one pointer. It is usually writen like in the second example (in the code I usually read/write) but for the compiler it's the same.

The trouble can come out if you are declaring more than one pointer. For example, this is not declaring two pointer, instead it declares one pointer and one var of type type.

type* var1, var2;

You need to do instead:

type* var1, *var2;

I prefer to use the * by the var always.

Answer 3

Pointer is the type, and I think it makes most sense to group the type information:

int* foo;

This can lead to confusion if several variables are defined on the same line:

int* foo, bar;  // foo will be int*, bar will be int

The solution to this is, never declare several variables on the same line. Something that Code Complete advocates, anyway.

Answer 4

That would rather be a coder's preference.

For me, I declare pointers by:

int * var1, var2;

Wherein var1 is a pointer, and var2 is not. If you want to declare multiple pointers in a line:

int * var1, * var2;

And of course, using the other ways are valid.

Answer 5

There is no single "most proper place".

Usually it is the place the rest of the code uses.

If you're writing your own code from the beginning and can choose your own convention: choose your own convention and stick with it.

If you choose something other than type * var you will meet 'awkward' situations:

/* write these with another style */
int * var;
int const * var;
int * restrict var;

_{PS. It shouldn't matter, but I usually use type *var;}

Answer 6

Declaration semantics follow expression semantics (specifically operator precedence) and I find more complex declarations easier to read using the second style.

You can think of

int *foo;

declaring the type of the expression *foo (ie indirection operator applied to foo) to be int instead of foo being declared to be of type int *.

Whatever convention you choose, just try to be consistent.