C – initialisation des pointeurs, position de l’astérisque

Dupliquer possible:
clarations de pointeurs en C ++: placement de l’astérisque

Quel est le moyen le plus approprié de placer un astérisque? Pourquoi?

1) type* var; 2) type *var; 

Peu importe si vous ne déclarez qu’un seul pointeur. Il est généralement écrit comme dans le deuxième exemple (dans le code que j’ai l’habitude de lire / écrire), mais pour le compilateur, c’est la même chose.

Le problème peut surgir si vous déclarez plus d’un pointeur. Par exemple, il ne s’agit pas de déclarer deux pointeurs, mais plutôt un pointeur et une variable de type.

 type* var1, var2; 

Vous devez faire à la place:

 type* var1, *var2; 

Je préfère utiliser le * par le var toujours.

Le pointeur est le type, et je pense qu’il est plus logique de regrouper les informations de type:

 int* foo; 

Cela peut prêter à confusion si plusieurs variables sont définies sur la même ligne:

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

La solution à cela est de ne jamais déclarer plusieurs variables sur la même ligne. Quelque chose que préconise Code Complete , en tout cas.

Les deux fonctionnent. Je dirais que le n ° 1 est plus clair en général , mais trompeur en C et peut conduire à des erreurs, par exemple:

 type* var1, var2; // This actually means: type *var1; type var2; 

Donc, je dirais que # 2 est plus idiomatique en C et donc recommandé, surtout si vous n’êtes pas le seul programmeur à travailler sur le code (à moins bien sûr que vous soyez tous d’accord sur un style).

Comme d’autres l’ont souligné, les deux fonctionnent bien et le mauvais a l’avantage de l’économie syntaxique.

À mon sens, une déclaration consiste en un type suivi de la variable .

  ; int ii; int* pii; 

Donc, si vous enlevez la variable , il ne rest que le type . Qui est int et int * ci-dessus. Le compilateur traite int * comme un type interne (qui est un pointeur sur un int ).

C, malheureusement, ne supporte pas cette syntaxe de manière transparente. Lorsque vous déclarez plusieurs variables du même type, vous devriez pouvoir le faire:

  , , ; 

que vous ne pouvez pas avec un type de pointeur:

 int* ii1, ii2, ii3; 

déclare ii1 de type int * et le rest de type int . Pour éviter cela, je prends l’habitude de déclarer une seule variable par ligne.

J’ai entendu dire que, techniquement, * est un modificateur de la variable, ce qui est démontré par la nécessité d’utiliser * plusieurs fois dans des déclarations à plusieurs variables, par exemple. int * p, * q, * r;

Cependant, j’aime bien y voir un modificateur du type de base, car c’est ce qui apparaît dans les prototypes. par exemple. void func (int *);

.PMCD.

PS Je sais que je n’ai pas aidé votre problème 🙂

Le deuxième mode est correct. Les autres modes ne sont pas aussi clairs pour un programmeur novice. La forme int * variable est généralement découragée

Ce serait plutôt la préférence d’un codeur.

Pour moi, je déclare les pointeurs par:

 int * var1, var2; 

var1 est un pointeur et var2 ne l’est pas. Si vous souhaitez déclarer plusieurs pointeurs dans une ligne:

 int * var1, * var2; 

Et bien sûr, utiliser les autres moyens est valide.

Il n’y a pas un seul “endroit le plus approprié”.

C’est généralement l’endroit où le rest du code utilise.

Si vous écrivez votre propre code dès le début et pouvez choisir votre propre convention: choisissez votre propre convention et respectez-la.

Si vous choisissez autre chose que le type * var vous rencontrerez des situations «délicates»:

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

PS Cela ne devrait pas avoir d’importance, mais j’utilise habituellement le type *var;

La sémantique des déclarations suit la sémantique des expressions (en particulier la priorité des opérateurs) et je trouve les déclarations plus complexes plus faciles à lire à l’aide du second style.

Vous pouvez penser à

 int *foo; 

déclarer le type de l’expression *foo (c’est-à-dire que l’opérateur d’indirection appliqué à foo ) est int au lieu de foo étant déclaré de type int * .

Quelle que soit la convention que vous choisissez, essayez simplement d’être cohérent.