C - initialisation des pointeurs, la position astérisque

Question

Possible en double:
Pointer declarations in C++: placement of the asterisk

Quelle est la manière la plus appropriée de mettre astérisque? Pourquoi?

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

Answer 1

Peu importe pour autant que vous ne déclariez qu'un seul pointeur. Il est généralement écrit comme dans le second exemple (dans le code que je lis et écris habituellement) mais pour le compilateur c'est pareil.

Le problème peut survenir si vous déclarez plus d'un pointeur. Par exemple, ceci ne déclare pas deux pointeurs, à la place il déclare un pointeur et un var de type type.

type* var1, var2; 

Vous devez faire à la place:

type* var1, *var2; 

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

Answer 2

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

Answer 3

Les deux fonctionnent. Je dirais que # 1 est plus claire dans générale, mais trompeur en C et peut entraîner des erreurs, par exemple:

type* var1, var2; 

// This actually means: 

type *var1; 
type var2; 

Je dirais que # 2 est plus idiomatiques en C et a 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).

Answer 4

Je l'ai entendu ont fait valoir que, techniquement, le * est un modificateur à la variable, et cela se traduit par la nécessité d'utiliser * plusieurs fois dans plusieurs variables déclarations par exemple. int * p, * q, * r;

Cependant j'aime bien le considérer comme un modificateur du type de base parce que est ce qui apparaît dans les prototypes. par ex. void func (int *);

.PMCD.

PS. Je sais que je n'ai pas aidé votre problème :)

Answer 5

Il n'y a pas de "lieu le plus approprié".

Habituellement c'est l'endroit que le reste du code utilise.

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

Si vous choisissez autre chose que type * var vous rencontrerez des situations 'difficiles':

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

_{PS.Cela ne devrait pas importer, mais j'utilise habituellement type *var;}

Answer 6

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

Pour moi, je déclare pointeurs par:

int * var1, var2; 

est un var1 dans laquelle le pointeur et var2 n'est pas. Si vous souhaitez déclarer plusieurs pointeurs dans une ligne:

int * var1, * var2; 

Et bien sûr, l'utilisation des autres moyens est valide.

Answer 7

La sémantique de déclaration suit la sémantique de l'expression (en particulier la précédence de l'opérateur) et je trouve les déclarations plus complexes plus faciles à lire en utilisant le second style.

Vous pouvez penser à

int *foo; 

déclarant le type de l'expression *foo (c.-à-opérateur indirection appliqué à foo) être int au lieu de foo être déclarés être de type int *. Quelle que soit la convention que vous choisissez, essayez d'être cohérent.

Answer 8

pointeur est le type, et je pense qu'il est plus judicieux de regrouper les informations de type:

int* foo; 

Cela peut conduire à la 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 est de ne jamais déclarer plusieurs variables sur la même ligne. Quelque chose que Code Complete préconise, de toute façon.

Answer 9

Comme d'autres l'ont souligné, les deux fonctionnent très bien, et le mauvais a en fait l'avantage de l'économie syntaxique.

La façon dont je regarde, une déclaration se compose de de type suivi par la variable .

<type> <variable>; 

int ii; 
int* pii; 

Donc, si vous enlevez la variable, ce qui reste est le type . Qui est int et int * ci-dessus. Le compilateur traite int * en tant que type en interne (qui est pointeur vers un int). C, malheureusement, ne supporte pas cette syntaxe de façon transparente.Lorsque vous déclarez plusieurs variables du même type, vous devriez être en mesure de le faire:

<type> <variable>, <variable>, <variable>; 

que vous ne pouvez pas avec un type de pointeur:

int* ii1, ii2, ii3; 

déclare II1 de type int * et le reste de type int. Pour éviter cela, je prends l'habitude de ne déclarer qu'une seule variable par ligne.