It's a pointer to a type, not a variable with an asterisk in its name

It's something that I've seen in C and C++ code. It doesn't make sense. I'm going to have a little rant about it.

When you are declaring a pointer, put the asterisk next to the type, because you are modifying the type.

int* x ✔ Yes very good.

int *x ❌ No very bad.

That's it.

The following is my reasoning in more detail for people who need more convincing because they're too stuck in their ways.

If I write int* x I am writing "x is of type 'pointer to int'".

If I write int *x I am writing "*x is of type int" which makes no sense.

I know the compiler doesn't care. I could write int*x and the compiler would eat it up like a good doggy. I care, because I'm reading the code.

* is not part of the variable name.

If I write x = &intvariable that is different to writing *x = &intvariable. The * is not part of the variable name.

If I have done typedef int* intptr; and then write intptr *x I have created a pointer to a pointer to an int, NOT a pointer to an int called *x.

THE * IS NOT PART OF THE VARIABLE NAME.

So don't make it look like it is.

Thank you for your time.

Comments

[JoelBonetR 🥇]

You can also understand the asterisk as a prefix on the name to determine that int *x as X is a pointer storing a memory address of type int data or any other argument of your preference. That's the issue, that you can read and interpret it in different ways so it's a bit subjective... 😅

I understand that sometimes the notation is confusing, because different textbooks place the * differently. The three following declarations are equivalent:

 int *x; 
 int* x; 
 int * x; 

I always believed that the least confusing notation is int * x because when read from right to left you can interpret it as x is a pointer, hence allocating a memory address which references to an int value, plus you not "link" visibly the asterisk to the type nor to the var name.

There are some details into that, see:

int* x, y, z;

This is 1 pointer and 2 int variables.

int *x, y, z;

This is still 1 pointer and 2 int variables.

For the sake of clarity:

 int * x, * y, * z;

Those are effectively 3 pointers and we can understand the asterisk as a somewhat independent (keyword if you will) and use it just like that.

I haven't coded in C for around 10Y, maybe nowadays there is some linter out there that you can use to enforce one way or the other in your projects 😁

[Matt Ellen-Tsivintzeli]

Thank you for engaging in good faith.

I completely disagree with everything you said.

Apart from the bit about linters. Linters are great.

[JoelBonetR 🥇]

😂😂 you are truly angry around this topic I see.

I updated the comment above with a bit more of information around why I think that int * x is the least confusing, please check it.

I don't think I'll be able to stress it further, though 😅

[JoelBonetR 🥇]

PD: Just in case it's not clear in the text above I agree with you in that int* x is the worse way by far.

Between the other two:

int *x;
int * x;

it's just subjective opinion around readability and I won't care much if it's one or the other.

[wimachtendink]

you are correct.

[Paul J. Lucas]

Ritchie intentionally designed C's declaration syntax to be "the thing on the right, if it were used in an expression, has the type of the thing on the left." So int *x means *x when used in an expression has the type int — therefore, by implication, x must be a pointer to int.

C is what it is. No amount of ranting will change it. Many before you have ranted about this same thing using the same arguments, so you're not bringing anything new to the table. If you're going to read other people's C code, you just have to get used to it. If if bothers you so much, you're free not to use C at all.

Incidentally, it's trivial to make the counter argument: the * is not part of the type (no matter how badly you might want it to be), so don't make it look like it is.

[Matt Ellen-Tsivintzeli]

If that were the case then int * x would be a compiler error. Seems like Ritchie just made a mistake and forgot to point out that int* is a type, so everyone just kept making the same mistake.

[Paul J. Lucas]

No, it wouldn't because whitespace largely insignificant. In your example, the "thing on the right" is still * x. The space doesn't matter.

What's actually more annoying about C is that when you declare something like int f(int a[4]) that it's highly deceptive since C doesn't have array parameters.