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

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

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.

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.

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.

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.

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

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 la FAQ sur le style et la technique C ++ de Bjarne Stroustrup pour les justifications.

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

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.

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;

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.

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.

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.