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


30

Quelle est votre méthode préférée pour déclarer un pointeur?

int* i;

ou

int *i;

ou

int * i;

ou

int*i;

Veuillez expliquer pourquoi.

voir aussi: http://www.stroustrup.com/bs_faq2.html#whitespace


19
Je préfère me concentrer sur les 3000 autres lignes ...

29
int*i;- les espaces blancs ne poussent pas sur les arbres, vous savez ...
Shog9

C'est essentiellement la même question; voici ma réponse .
Keith Thompson

Réponses:


75

Si vous écrivez:

int* i, j, k;

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

Je soutiens donc qu'il est préférable d'annexer le * au nom de la variable.


35
Et je dirais que int * i;c'est un non-concurrent uniquement parce qu'il ressemble à la multiplication en un coup d'œil.
John K

1
+1 parce que je n'avais pas envisagé ce scénario auparavant.
Pops

4
"vous indiquez à tort que tous les i, j et k sont des pointeurs vers int." Sauf si vous écrivez C #, où int*est considéré comme un type et int* i, jdéclare deux pointeurs. La question pourrait être considérée comme incomplète - cela dépend de la langue que vous utilisez, quels styles sont raisonnables. Dans CI suivre int *x, en C # je fais autrement.
Joren

1
@Joren: Désolé, n'étant pas un programmeur C #, j'ai simplement supposé en regardant le fragment de code dans la question était C ou C ++.
Randall Schulz

Je pense qu'il 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 des pointeurs en C #.
alternative

62

Je préfère int* iparce que ile type "pointeur vers un int", et je pense que cela le rend uniforme avec le système de type. Bien sûr, le comportement bien connu intervient lorsque vous essayez de définir plusieurs pointeurs sur une seule ligne (à savoir, l'asté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 c'est un grave défaut dans les langages de style C.


8
Moi aussi, je suis cette convention. Pour la même raison.
gablin

5
Personnellement, si je déclare plusieurs pointeurs dans mon code, je le traite comme une odeur de code. Je ne devrais pas avoir besoin d'autant de pointeurs; et généralement, je ne le fais pas. Ainsi, la question des déclarations multiples sur une seule ligne ne se pose jamais dans le code que j'écris: une déclaration par ligne.
greyfade

5
Le problème avec ceci est que le type n'est pas un "pointeur vers un int". C (et C ++) n'a pas de type pointeur. Il s'agit d'un pointeur sur un bloc de mémoire, dont le type est int.
Billy ONeal

10
Je dirais que cela *ia un type de int.
Tim Goodman

5
@Billy: Si c'est le cas, je n'ai jamais vu cette confusion en 12 ans d'essayer de comprendre, d'analyser et d'expliquer le standard. "Pointer to an int" est un type parfaitement valide en C et C ++.

23

Pour C, où nous ne mettons pas fortement l'accent sur les types, je préfère:

int *i;

Parce qu'il met l'accent sur le int, pas sur le pointeur. C'est quoi int? *iest l'int.


2
Bon point. Avec les pointeurs, vous pouvez considérer le début comme faisant partie du nom. Par exemple, si vous en avez int i = 5, pour obtenir la valeur de i, vous utilisez le nom i. De même, si vous en avez int *i; *i = 5, alors pour obtenir la valeur, vous utilisez *i.
mipadi

J'ai lu 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 pointeur de type entier. char * p [] analyse comme char (* ([] (p))) (parce que [] a une priorité plus élevée que *) et signifie: p a le type tableau-de pointeur vers char.
Giorgio

Pour cette raison, je pense qu'ils ont choisi d'écrire * à côté de la variable, car * est un opérateur qui lui est appliqué.
Giorgio

7

Je préfère int* idepuis des années. Cependant, il existe un argument solide int *icar, lorsque vous utilisez l'ancien 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 n'y gagnez pas simplement - mais je ne dirais pas que c'est 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 l'utilise, cependant, il semble un peu idiot de prétendre que la syntaxe de la déclaration C fonctionne autrement qu'elle, en plaçant l'astérisque à côté du type plutôt que la variable à laquelle il est lié syntaxiquement.

Je ne crois pas dans celui - là met l' accent sur le type de pointeur (pour i) tandis que l'autre met l' accent sur le type int (pour *i), mais peut - être que , après 15 ans de C et l'utilisation C de, juste est quand je regarde, sans avoir à y penser⁠ —ometquelque chose que la plupart des débutants qui posent cette question ne peut pas encore faire.

De plus, même étant donné ma préférence, je ne trouve pas gênant de lire / écrire du code dans l'autre style. Cohérence, bla bla bla.

Pas même besoin de le mentionner int * i.


6

Je préfère le premier. Cela vient naturellement car être un pointeur fait partie du type.

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

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


4

Si vous souhaitez déclarer plusieurs variables mais ne voulez pas répéter l'astérisque:

template <typename T>
struct pointer_to
{
    typedef T* type;
};

pointer_to<int>::type p1, p2, p3;

(Comme vous pouvez le voir à l'intérieur du modèle struct, je préfère le int* i style.)

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 n'importe quel "type problématique", par exemple des tableaux et des références:

identity<int[10]>::type a1, a2, a3;

identity<int&>::type r1(*p1), r2(*p2), r3(*p3);

omg, c ++ montre toujours quelque chose de nouveau pour moi :). Merci!
Tamás Szelei

1
OMG, C ++ est horrible! typedef int* int_ptraurait fait l'affaire. Bien sûr, je dois déclarer un nouveau typedef pour différents types de pointeurs, mais en pratique, combien seront-ils? Huit au maximum?
benzado

1
@benzado En pratique, vous n'avez pas besoin du typedef ou de l'une des astuces que j'ai démontrées, car aucune personne sensée ne déclare plusieurs variables sur une seule ligne. Toujours intéressant, cependant.
fredoverflow

2
Je sais, je parlais davantage de la tendance des programmes C ++ à utiliser les fonctionnalités du langage simplement parce qu'ils le peuvent.
benzado

@benzado: !!! Je l'ai vu si souvent!
Giorgio

2

J'irais pour int* i;puisque la première partie dénote le type de variable (pointeur vers int), tandis que la deuxième partie dénote le nom ( i). Cela n'aurait aucun sens pour moi que le type soit intet le nom *i. Cela int * i;ressemble aussi un peu à la multiplication.


La syntaxe de déclaration C n'est pas cohérente à cet égard, car les informations de type peuvent facilement venir après l'identifiant: les tableaux étant l'exemple le plus clair.

@Roger: Je sais, mais cette question concernait spécifiquement une seule déclaration de variable, et rien d'autre.
Allon Guralnek

Je pense que cela en lit un peu plus. :) La façon dont je comprends la question, c'est de demander quel style vous utilisez partout.

@ Roger: Vous avez probablement raison, mais mon objectif était de répondre à la question du PO: "Quelle est votre méthode préférée pour déclarer un pointeur?". De toute évidence, tout le monde est libre de jeter un œil sur la question présentée dans la question, et c'est même encouragé ici. En tant que personne qui ne développe pas en C / C ++, je pensais que le faire s'écarterait trop de mon domaine d'expertise.
Allon Guralnek

2

Dans les déclarations que j'utilise 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.

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


1

J'utilise en fait les trois conventions dans des circonstances spécifiques. À première vue, je semble incohérent, mais ...

  • int * lorsque l'identifiant n'est pas présent, pour renforcer visuellement que le nom n'est pas présent.
  • int* intptrsur typedefs et des déclarations similaires pour renforcer visuellement qu'il fait partie du type. De même avec les déclarations de pointeur de fonction:(int* (*foo)(int))
  • int *identifieret class &identifiersur les paramètres de fonction pour renforcer visuellement que le paramètre est potentiellement un paramètre dit "out".
  • const int * const * constchaque fois que j'utilise des qualificatifs cv .
  • int * foo; sur les déclarations locales.

Je suppose que je suis quelque peu orienté visuellement.


1

Il n'y a aucun type de pointeur dans C! Donc, "int *" ne veut rien dire. L'astérisque est toujours lié à l'élément écrit à droite de celui-ci, il lui appartient directement. "* i" est un int. Et à cause de * i est un int, il s'ensuit que i est un pointeur vers int. C'est la logique derrière cela et c'est 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 #, c'est quelque chose de différent. Mais pour C, il n'y a qu'une seule bible: "Dennis M. Ritchie: Le langage de programmation C". Dennis (RIP!) L'a écrit: "int * i". Il n'est pas nécessaire de remettre cela en question.


6
"Il n'y a pas de types de pointeurs en C" - D'où vous est venue cette idée? int*est un type de pointeur.
Keith Thompson

-2

J'utilise int *iparce qu'il est plus facile de voir qu'il s'agit d'un pointeur, même si je ne pense pas que ce soit vraiment important.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.