it-swarm.dev

int * i; ou int * i; ou int * i;

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

30
lesmana

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.

76
Randall Schulz

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 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.

62
Tamás Szelei

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

int *i;

Parce qu'il a une emphase sur le int, pas sur le pointeur. Qu'est-ce que le int? *i est l'int.

23
alternative

J'ai préféré int* i pendant des années. Cependant, il existe un argument solide pour int *i car 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 n'achète pas dans celui-là souligne le type de pointeur (pour i) tandis que l'autre met l'accent sur le type int (pour *i), mais il se peut qu'après 15 ans d'utilisation de C et C++, ce soit juste quand je le regarde, sans avoir à penser à it⁠ —quelque 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 mentionner int * i.

7
Roger Pate

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
6
Guffa

Je préfère int* i (Style C++).
J'évite de déclarer plusieurs variables dans une instruction en raison de l'ambiguï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.

5
Archimedix

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);
4
fredoverflow

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

2
Allon Guralnek

Dans les déclarations, 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;

2
Tamara Wijsman

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* intptr on 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 *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 j'utilise c-v qualificatifs.
  • int * foo; sur les déclarations locales.

Je suppose que je suis quelque peu orienté visuellement.

1
greyfade

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 (R.I.P.!) L'a écrit: "int * i". Il n'est pas nécessaire de remettre cela en question.

1
Lexi Pim