Why does c++ pointer * associate to the variable declared, not the type?

Question

Why was C++ designed such that the correct way to declare two int *s on the same line is

int *x, *y;

not

int* x,y;

I know some people think you should avoid either form and declare every variable on its own line, but I'm interested in why this language decision was made.

may be they thought to be more flexible that a user can declare both a pointer and a normal variable at the same time. — Vijay, Jun 14 '12 at 12:14
Read this http://www.research.att.com/~bs/bs_faq2.html#whitespace for the reason in C++, for C reasons: http://cm.bell-labs.com/cm/cs/who/dmr/chist.html — Adriano Repetti, Jun 14 '12 at 12:18
I would say the strangest part is with initialization. Let's say we have `int* p = new int[5];` Then `int* a = &p;` would be fine: "Give to the pointer a the address of p". But `int *b = &p;` is strange: "Give to the integer *b the address of p". Considering *b is an int, why giving addresses? That's why I find the chained declarations of pointer make no sense. — Morwenn, Jun 14 '12 at 12:49
possible duplicate of [What are the distinctions between the various symbols (*,&, etc) combined with parameters?](http://stackoverflow.com/questions/9636903/what-are-the-distinctions-between-the-various-symbols-etc-combined-with-p) — bames53, Jun 14 '12 at 13:38

score 24 · Accepted Answer · edited Jan 13 '21 at 17:30

24

To keep compatibility with C code, because that's how C works.

Bjarne makes a good point in his style and technique faq:

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, the motivation for this working as this in C++ is how it works in C.

The motivation it works like that in C is that, as stated above, C emphasizes expressions rather than types.

edited Jan 13 '21 at 17:30

Deduplicator

44,692
7
66
118

answered Jun 14 '12 at 12:12

Luchian Grigore

253,575
64
457
625

4

@illEatYourPuppies ah but that's an entirely different question :P – Luchian Grigore Jun 14 '12 at 12:14
The short answer is above: "C emphasized expressions; declarations were often considered little more than a necessary evil." – Mike DeSimone Jun 14 '12 at 12:22
1

@LuchianGrigore only if you have no curiosity whatsoever :) – Sideshow Bob Jun 14 '12 at 13:55
2

I usually run with `int * p` because I find both ways ugly :) – nikolas Jun 14 '12 at 13:59
1

@nijansen that's the ugliest of all, I read that as "calculate the product of `int` and `p` (by multiplication)"! – leftaroundabout Jun 14 '12 at 15:06
1

You would have to observe that Bjarne's last paragraph is wrong. I've never seen a C++ programmer do that, and it is inoonsistent with the actual meaning. Consider the OP's example: int* p,q; does not mean that q is a pointer to int. – user207421 Jun 17 '12 at 21:51

score 8 · Answer 2 · answered Jun 14 '12 at 12:39

The simple answer is: because that's the way C does it. Which, of course, only begs the question: why does C do it this way?

The original philosophy, in early C, is that the declaration be an exact image of the use. So when you write:

int *p;

, you are declaring that the expression *p has type int (and the compiler works out the actual type of p accordingly).

This, of course, ceased to be true the day C introduced typedef, and later struct. And any resemblance disappeared completely with const (first introduced in C++, then retrofitted into C), where things like

int *const p;

have no relationship with use. But by then, the die was cast.

score 1 · Answer 3 · answered Jun 14 '12 at 14:42

Answer

That comes from "C" ( "plain c", "pure c", whatever ).

When a pointer variable is already declared, its used like this:

...
*p = &x;
*q = SomePointerFunc();
....

I read that the original inventors of "c" wanted programmers to declare pointers variables with the same syntax as they are used, with the star before the variable identifier:

...
int *p;
int *q;
...

The same goes for arrays:

...
x[5]  = 'a';
y[77] = SomeItemFunc();
...

...
char x[5];
int  y[100];
...

Some teachers that I had, insist to declare types for variables & functions this way (star close to identifier):

...
int *p;
int *q;
...

Instead of this (star next to type identifier):

...
int* p;
int* q;
...

Extra

In Java, and other languages, like C#, the declaration of arrays, or pointers are next to the type, leaving the variable or function identifier alone, like this pseudocode:

*int p;
*int q;
char[5] x;
int[100]  y;

I prefer this technique.

Cheers.

Why does c++ pointer * associate to the variable declared, not the type?

3 Answers3

Linked

Related