Pourquoi le pointeur c++ * est-il associé à la variable déclarée, et non au type?

Question

Pourquoi C++ a-t-il été conçu de telle sorte que la bonne manière de déclarer deux int * sur la même ligne soit

int *x, *y;

et non

int* x, y;

Je sais que certaines personnes pensent que vous devriez éviter les deux formes et déclarer chaque variable sur sa propre ligne, mais je suis intéressé par la raison de cette décision de langage.

Answer 1

Pour garder la compatibilité avec le code C, car c'est ainsi que fonctionne C.

Bjarne soulève un bon point dans sa foire aux questions sur le style et la technique:

Le choix entre int* p; et int *p; ne concerne pas le bien ou le mal, mais le style et l'accent. C met l'accent sur les expressions; les déclarations étaient souvent considérées comme peu plus qu'un mal nécessaire. C++, en revanche, met l'accent sur les types.

Un programmeur C typique écrit int *p; et l'explique *p est un int en mettant l'accent sur la syntaxe, et peut se référer à la grammaire de déclaration C (et C++) pour argumenter la justesse du style. En effet, le * se lie au nom p dans la grammaire.

Un programmeur C++ typique écrit int* p; et l'explique p est un pointeur sur un int en mettant l'accent sur le type. En effet, le type de p est int*. Je préfère clairement cet accent et le considère comme important pour bien utiliser les parties plus avancées de C++.

Ainsi, la motivation pour que cela fonctionne ainsi en C++ est liée à la manière dont cela fonctionne en C.

La motivation pour laquelle cela fonctionne ainsi en C est que, comme indiqué ci-dessus, C met l'accent sur les expressions plutôt que sur les types.

Answer 2

La réponse simple est : parce que c'est ainsi que C le fait. Ce qui, bien sûr, ne fait que soulever la question : pourquoi C le fait-il de cette façon ?

La philosophie originale, au début de C, est que la déclaration doit être une image exacte de l'utilisation. Donc lorsque vous écrivez :

int *p;

, vous déclarez que l'expression *p a le type int (et le compilateur détermine le type réel de p en conséquence).

Cela, bien sûr, a cessé d'être vrai le jour où C a introduit typedef, et plus tard struct. Et toute ressemblance a complètement disparu avec const (introduit d'abord en C++, puis rétrofité en C), où des choses comme

int *const p;

n'ont aucun rapport avec l'utilisation. Mais à ce moment-là, le mal était fait.

Answer 3

Réponse

Cela vient de "C" ( "c pur", "c brut", peu importe ).

Quand une variable pointeur est déjà déclarée, elle est utilisée de cette façon :

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

J'ai lu que les inventeurs originaux de "C" voulaient que les programmeurs déclarent les variables pointeurs avec la même syntaxe qu'ils sont utilisés, avec l'étoile avant l'identifiant de variable :

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

Il en va de même pour les tableaux :

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

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

Certains enseignants que j'ai eus insistent pour déclarer les types pour les variables et les fonctions de cette manière (l'étoile proche de l'identifiant) :

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

Au lieu de cela (l'étoile à côté de l'identifiant du type) :

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

Extra

En Java et dans d'autres langages, comme C#, la déclaration des tableaux ou pointeurs est à côté du type, laissant l'identifiant de variable ou de fonction seul, comme dans ce pseudocode :

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

Je préfère cette technique.

Santé.