int * i; ou int * i; ou int * i; [fermé]

Si vous écrivez:

int* i, j, k; 

vous suggérez à tort que tous les i, j et k sont des pointeurs vers int.

Donc je soutiens quil est préférable dannexer le * à la variable name.

Commentaires

• Et je ' d suggère int * i; est un non-candidat uniquement parce quil ressemble à une multiplication en un coup dœil.
• +1 parce que je nai ' pas envisagé ce scénario auparavant.
• " vous suggérez à tort que tous les i, j et k sont des pointeurs vers int. " Sauf si vous ' réécrire C #, où int* est considéré comme un type, et int* i, j déclare deux pointeurs. La question peut être considérée comme incomplète – cela dépend de la langue que vous ' utilisez quels styles sont raisonnables. En CI suivez int *x, en C # je fais autrement.
• @Joren: Désolé, nétant pas un programmeur C #, jai simplement supposé en regardant le fragment de code dans la question était C ou C ++.
• Je pense quil est parfaitement raisonnable de supposer que son C ou C ++ à moins que C # ne soit spécifiquement mentionné. On ne voit pas très souvent les pointeurs en C #.

Je préfère int* i parce que i a le type « pointeur vers un int », et je pense que cela le rend uniforme avec le système de types. Bien sûr, le comportement bien connu entre en jeu, lorsque vous essayez de définir plusieurs pointeurs sur une ligne (à savoir, lastérisque doit être placé avant chaque nom de variable pour déclarer un pointeur), mais je ne déclare simplement pas les pointeurs de cette façon. De plus, je pense que cest « un grave défaut dans les langages de style C.

Commentaires

• Je suis moi aussi cette convention. Pour la même raison.
• Personnellement, si je ' déclare plusieurs pointeurs dans mon code, je le traite comme une odeur de code. Je ne devrais pas ' avoir besoin dautant de pointeurs; et généralement, je ne ' t. Ainsi, le problème des déclarations multiples sur une seule ligne ne se pose jamais dans aucun code que jécris: Une déclaration par ligne.
• Le problème avec ceci est que le type nest pas un " pointeur vers un int ". C (et C ++) nont ' t ont un type pointeur. Cest un pointeur vers un bloc de mémoire, dont le type est int.
• Je dirais que *i a un type de int.
• @Billy: Si tel est le cas, je ' nai jamais vu cette confusion en 12 ans à essayer de comprendre, analyser et expliquer le standardese . " Pointeur vers un entier " est un type parfaitement valide en C et C ++.

Pour C, où nous ne nous concentrons pas fortement sur les types, je préfère:

int *i;

Parce quil a une emphèse sur int, pas sur le pointeur. Quest-ce que le int? *i est lint.

Commentaires

• Bon point. Avec des pointeurs, vous pouvez pensez au début comme faisant partie du nom. Par exemple, si vous avez int i = 5, pour obtenir la valeur de i, vous utilisez le nom i. De même, si vous avez int *i; *i = 5, alors pour obtenir la valeur, vous utilisez *i.
• Je lis int * i comme: * i est un int. Par conséquent, i est un pointeur vers int.Les déclarations de variables en C utilisent des expressions de type, int et * ne sont que des opérateurs. int * i analyse comme int (* (i)) et est interprété comme i a un type pointeur vers entier. char * p [] analyse comme char (* ([] (p))) (car [] a une priorité plus élevée que *) et signifie: p a le type tableau-de pointeur-vers char.
• Pour pour cette raison, je pense quils ont choisi décrire * à côté de la variable, car * est un opérateur qui lui est appliqué.
• Je semble préférer cela aussi – garde la définition de type plus propre. De plus, ce que Giorgio a écrit a du sens pour moi aussi et Dennis a écrit quelque chose dans ce sens dans son raisonnement.

Jai préféré int* i pendant des années. Cependant, il existe un argument fort pour int *i car lorsque vous utilisez lancien style, vous devez toujours vous souvenir de la règle de déclaration multiple:

int* a, *b; // not int* a, b; 

Parce que vous devez vous souvenir de cette règle, vous ne gagnez pas simplement – mais je ne dirais pas que cest plus complexe non plus. Éviter plusieurs déclarations sur une ligne est juste une autre façon de dire que vous vous souvenez de cette règle . La différence entre les deux styles est sans objet.

Même si je lutilise, cependant, il semble un peu idiot de prétendre que la syntaxe de déclaration C fonctionne autrement quen plaçant lastérisque à côté du type plutôt que la variable à laquelle il est lié syntaxiquement.

Je nachète pas dans celle-là accentue le type de pointeur (pour i) tandis que lautre met laccent sur le type int (pour *i), mais cela peut être quaprès 15 ans dutilisation de C et C ++, il suffit de est quand je le regarde, sans avoir à y penser⁠ — ⁠quelque chose La plupart des débutants qui posent cette question ne peuvent pas encore le faire.

De plus, même compte tenu de ma préférence, je ne trouve pas gênant de lire / écrire du code dans lautre style. Cohérence, bla bla bla.

Inutile de mentionner int * i.

Je préfère le premier. Cest naturel car être un pointeur fait partie du type.

Comme jutilise C #, il gère les types de manière plus intuitive que C, donc il ny a aucun problème à déclarer plusieurs pointeurs dans la même instruction:

int* a, b, c; // three pointers 

Je préfère int* i (style C ++).
Jévite de déclarer plusieurs variables dans une instruction en raison de lambiguïté visuelle qui en résulte (int* i, j).

Voir aussi FAQ sur le style et la technique C ++ de Bjarne Stroustrup pour les justifications.

Si vous voulez déclarer plusieurs variables mais que vous ne voulez pas répéter lastérisque:

template <typename T> struct pointer_to { typedef T* type; }; pointer_to<int>::type p1, p2, p3; 

(Comme vous pouvez le voir dans le modèle de structure, Je préfère le style int* i.)

Et voici une solution plus générale:

template <typename T> struct identity { typedef T type; }; identity<int*>::type p1, p2, p3; 

Celui-ci fonctionne avec tout « type problématique », par exemple des tableaux et des références:

Commentaires

• omg, c ++ me montre toujours quelque chose de nouveau :). Merci!
• OMG, C ++ est horrible! typedef int* int_ptr aurait fait laffaire. Bien sûr, je dois déclarer un nouveau typedef pour différents types de pointeurs, mais en pratique, combien en sera-t-il? Huit au plus?
• @benzado En pratique, vous navez ' pas besoin du typedef ou de lun des trucs sophistiqués que jai montrés, car aucune personne sensée ne déclare plusieurs variables en une seule ligne. Encore intéressant, cependant.
• Je sais, je parlais davantage de la tendance des programmes C ++ à utiliser les fonctionnalités du langage simplement parce quils le peuvent.
• @benzado: !!! Jai vu ça si souvent!

Je « irais pour int* i; puisque la première partie désigne le type de variable (pointeur sur int), tandis que la deuxième partie désigne le nom (i). Cela naurait pas de sens pour moi que le type est int et le nom est *i. De plus, int * i; me ressemble un peu à une multiplication.

Commentaires

• La syntaxe de la déclaration C isn ' t cohérent à cet égard, car les informations de type peuvent facilement venir après lidentifiant: les tableaux étant lexemple le plus clair.
• @Roger: Je sais, mais cette question était spécifiquement à propos dune déclaration de variable unique, et rien dautre.
• Je pense que ' en lit un peu plus. 🙂 La façon dont je comprends la question, ' demande quel style vous utilisez partout.
• @Roger: You ' vous avez probablement raison, mais mon objectif était de répondre à la question de lOP ': " Quelle est votre méthode préférée pour déclarer un pointeur? ".Évidemment, chacun est libre de jeter un regard pensionnaire sur lenjeu présenté dans la question, et cest même encouragé ici. En tant que personne qui ' t se développer en C / C ++, j’ai eu l’impression que cela s’éloignerait trop de mon domaine d’expertise.

Dans les déclarations que jutilise int * i;, vous le lisez comme i is a pointer to an integer.

Le pointeur contribue à la fois au type et à la variable, il doit donc être au milieu.

Cest une bonne chose déviter de déclarer plusieurs choses sur la même ligne: int * i, j;

Il ny a pas de type de pointeur en C! Donc, « int * « ne signifie rien. Lastérisque est toujours lié à lélément écrit à droite de celui-ci, il appartient à lélément à droite. » * i « est un int. Et parce que * i est un int, il sensuit que i est un pointeur vers int. Cest la logique derrière cela et cest pourquoi « int * i » est la seule solution possible. Tout le reste est une illusion (qui est automatiquement corrigée par le compilateur dans la plupart des cas). En C ++ et C #, cest quelque chose de différent. Mais pour C il ny a quune seule bible: « Dennis M. Ritchie: Le langage de programmation C ». Dennis (RIP!) La écrit: « int * i ». Il nest pas nécessaire de remettre en question.

Commentaires

• " Il ny a pas de types de pointeurs en C " – Doù avez-vous eu cette idée? int* est un type de pointeur.

En fait, jutilise les trois conventions dans des circonstances spécifiques. À première vue, je semble incohérent, mais …

• int * lorsque lidentifiant nest pas présent, pour renforcer visuellement que le nom nest pas présent.
• int* intptr sur typedef et déclarations similaires pour renforcer visuellement le fait que cela fait partie du type. De même avec les déclarations de pointeur de fonction: (int* (*foo)(int))
• int *identifier et class &identifier sur les paramètres de fonction pour renforcer visuellement que le paramètre est potentiellement un paramètre dit « out ».
• const int * const * const chaque fois que jutilise cv qualificatifs.
• int * foo; sur les déclarations locales.

Je suppose que je suis quelque peu orienté visuellement.

Jutilise int *i car il « est plus facile de voir que cest un pointeur, bien que Je ne pense pas que ce soit vraiment important.