Is there a difference between int *x and int* x in C++? [duplicate]

Answer 1

Both are the same thing.

The former is although preferred. Suppose you want to declare 2 pointers p & q in the same line.

int* p, q;

This actually means 'p' is a pointer to an int, while 'q' is an int.

The correct syntax would be:

int* p, *q;

Hence, we include the * in the pointer's name.

Answer 2

In my opinion, in the expression int * x,y; x and y are names of variables. When these names are declared like this by programmer, it means they have same type and int * is the type.

Answer 3

To the compiler they are the same

But at the same time the difference is readabilty when there are multiple variables

int *x,y

However this is more misleading

int* x,y

Answer 4

The famous Bjarne Stroustrup, notable for the creation and the development of the C++, said ...

The choice between "int* p;" and "int *p;" is not about right and wrong, but about style and emphasis. C emphasized expressions; declarations were often considered little more than a necessary evil. C++, on the other hand, has a heavy emphasis on types.

A "typical C programmer" writes "int *p;" and explains it "*p is what is the int" emphasizing syntax, and may point to the C (and C++) declaration grammar to argue for the correctness of the style. Indeed, the * binds to the name p in the grammar.

A "typical C++ programmer" writes "int* p;" and explains it "p is a pointer to an int" emphasizing type. Indeed the type of p is int*. I clearly prefer that emphasis and see it as important for using the more advanced parts of C++ well.

So, there's no difference. It is just a code style.

From here

Answer 5

There is no difference. I use the int* x form because I prefer to keep all of the type grouped together away from the name, but that kind of falls apart with more complex types like int (*x)[10].

Some people prefer int *x because you can read it as "dereferencing x gives you an int". But even that falls apart when you start to use reference types; int &x does not mean that taking the address of x will give you an int.

Another reason that you might prefer int *x is because, in terms of the grammar, the int is the declaration specifier sequence and the *x is the declarator. They are two separate parts of the declaration. This becomes more obvious when you have multiple declarators like int *x, y;. It might be easier to see that y is not a pointer in this case.

However, many people, like myself, prefer not to declare multiple variables in a single declaration; there isn't exactly much need to in C++. That might be another reason for preferring the int* x form.

There's only one rule: be consistent.

Answer 6

To the compiler, they have exactly the same meaning.

Stylistically, there are arguments for and against both.

One argument is that the first version is preferable because the second version:

int* x, y, z;

implies that x, y and z are all pointers, which they are not (only x is).

The first version does not have this problem:

int *x, y, z;

In other words, since the * binds to the variable name and not the type, it makes sense to place it right next to the variable name.

The counter-argument is that one shouldn't mix pointer and non-pointer type in the same declaration. If you don't, the above argument doesn't apply and it makes sense to place the * right next to int because it's part of the type.

Whichever school of thought you decide to subscribe to, you'll encounter both styles in the wild, and more (some people write int * x).