Discussion :

[gregoire.stein]

Bonjour, bonsoir, j'aimerais avoir vos avis concernant la position des opérateurs * et & en C++.

J'utilise toujours : int& integer;

J'ai remarqué aussi que dans "The C++ Programming language Fourth Edition" de Bjarne Stroustrup, Stroustrup écrit aussi int& integer.

Est-ce une question de style ?

Qu'en pensez-vous ?

[Neckara]

Bonjour,

Ce n'est pas la même utilisation.

• un pointeur peut être nullptr, pas une référence ;
• un pointeur peut changer de valeur, pas une référence qui référencera toujours le même objet ;

On préférera souvent la référence au pointeur, il se comporte comme un "alias" et n'est pas toujours implémenté sous forme de pointeurs (optimisations du compilateur).
Il évite aussi de devoir tester si le pointeur est nullptr ou non.

Ensuite, pour les pointeurs, on préfère très souvent utiliser des containers (std::vector, std::map, etc.), des pointeurs intelligents (std::shared_ptr, std::unique_ptr, std::weak_ptr), voir même ne pas utiliser de pointeurs du tout.

[Neckara]

Arf, je me suis fais avoir en lisant trop vite, j'ai loupé deux petits mots "la position" (je n'ai pas vu le sondage) .

Donc moi j'utilise Type & variable.
Je trouve que c'est un plus lisible que Type& variable.

Par contre je déconseillerais Type &variable car cela n'a pas trop de sens à mes yeux de coller '&' au nom de la variable alors qu'il fait parti du type de la variable.

C'est donc surtout une question de style.

[ternel]

Justement, & et * sont des marqueurs de la variable.

c'est visible dans des codes comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
int source = 2;
int* a, b;
int& one=source, two =source;

Ici, a est un int*, b un int, one un int& (sur source), et two un int.

Par contre, effectivement, pour déclarer une seule variable, je place la référence sur le type.

Cela dit, la majorité des références sont des arguments de fonctions, et j'adopte le deux espaces:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
void swap( int & a, int & b);
void export(int const& a, int const& b);

Je préfère toujours l'étoile sur la variable à cause de cette grosse subtilité, qui veut que int* a, b; se lise "sont des int le pointé de la variable a, et la variable b"

Ca m'évite des erreurs.

[Neckara]

Justement, & et * sont des marqueurs de la variable.

Ce que je veux dire c'est qu'on dit que ptr est un int *, on ne dit pas que c'est un int. De plus, '*' ne fait pas parti du nom de la variable, on parle de 'ptr', pas de '*ptr'.
C'est pour cela que je sépare le nom de la variable du "type" par un espace.

c'est visible dans des codes comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
int source = 2;
int* a, b;
int& one=source, two =source;

Ici, a est un int*, b un int, one un int& (sur source), et two un int.

Donc en effet, il vaudrait mieux éviter de coller '&' et '*' au "type" pour éviter la confusion.
Même si on essaye généralement d'éviter de déclarer plusieurs variables sur la même ligne.

Par contre, effectivement, pour déclarer une seule variable, je place la référence sur le type.

Comme on ne change pas la méthode d'indentation au milieu d'un code, je ne pense pas qu'il soit judicieux d'utiliser les "trois méthodes" dans le code en fonction des circonstances.
Ne vaut-il mieux pas en choisir une et s'y tenir ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
void swap( int & a, int & b);
void export(int const& a, int const& b);

Par contre, vous collez le & au const. Pourquoi?

[Ehonn]

int const& a

J'aime pas cette notation car ce qui est const est int, pas la référence (une référence "est toujours constante").

Personnelement, j'utilise cette notation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
T &
T const &
char const * const

Et m'interdit les déclarations sur la même ligne.

[ternel]

Je vais observer un peu mes codes, pour voir ce que je fais effectivement.
Je mets toujours const& pour les arguments, probablement parce que dans ma 'tite tête, c'est une "référence-constante-en-un-seul-mot".

Pour les déclarations, je n'ai quasiment jamais deux variables locales qui soient des pointeurs, et je ne déclare jamais un pointeur avec un pointé.
(pas de int *a,b;)

[Médinoc]

Personnellement, j'utilise int * a, sauf pour:

• Les pointeurs managés du C++/CLI, où j'utilise systématiquement String^ a
• Les déclarations d'opérateurs retournant une référence, où j'utilise systématiquement MaClasse& operator=(.

J'ignore si les déclarations de pointeur managé ont le même problème que les pointeurs ordinaires, mais je suppose que oui; j'évite d'en déclarer deux sur la même instruction dans tous les cas.

[Bousk]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int const& a

J'aime pas cette notation [...]

Personnelement, j'utilise cette notation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

T const &

Faudrait te mettre d'accord avec toi-même

[Ehonn]

T const& est différent de T const &

Edit : Je parle de coding style (présence ou pas d'un espace). Les deux sont des références sur membre constant.

[dragonjoker59]

T const& est différent de T const &

J'espère que tu ne parles que de la coloration syntaxique ?
Sinon, il n'y a aucune différence.

En tout cas pour répondre à la question, je mets un espace avant et un espace après int & integer parce que j'aime bien quand mon code respire.

[the Hound]

T const& est différent de T const &

Et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

T const   &

(deux espaces) ça donne quoi ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
const T* == T const* == T const *
T * const == T* const == T *const
T const * != T * const

C'est en CSS que les espaces ont une valeur autre que du simple bruit

[Ehonn]

J'espère que tu ne parles que de la coloration syntaxique ?
Sinon, il n'y a aucune différence.

Je parle de l'espace entre le const et la référence...
et de coding style (les deux sont des références sur membre constant).

[the Hound]

Je parle de l'espace entre le const et la référence...

Espace ou pas, c'est strictement la même chose.

Edit: ok j'ai relu ton message après ton edit, j'ai pas vu que c'était une question de coding style.
Mea culpa

[Ehonn]

Toute la discussion est autour du coding style : « Vos préférences de position des opérateurs * et & »
J'ai quand même édité mon message pour lever toute ambiguïté.

[jblecanard]

Salut ! Pas grand chose à ajouter, pour ma part, je me tiens à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

T const&;

et de même pour les pointeurs, car je considère que ça fait partie du type.

[the Hound]

Salut ! Pas grand chose à ajouter, pour ma part, je me tiens à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

T const&;

et de même pour les pointeurs, car je considère que ça fait partie du type.

En même temps vu le code d'exemple que tu as posté tu n'as pas d'autre choix que de le mettre sur le type (il n'y a pas de nom de variable)

PS: troll hein

[jblecanard]

Exact, mais vous avez compris Ce n'est pas sympa de t'avoir poucé rouge pour un message humoristique, j'ai l'impression qu'il y a des rageux en ce moment sur ce forum.

[Astraya]

Salut,

Pour ma part je le met coté type. Pour une raison que je trouve logique, on pointe/réfère un type donné (exception sur void*) via un nom de variable (adresse).
Et puis après je dis toujours pointeur sur entier(int*) nommé toto (toto) donc j'écris comme je dis ( c'est profond ça ), ou pointeur sur entier(int*) membre(m) nommé toto(toto).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int* toto; //Pointeur sur entier toto
long* mToto//Pointeur sur long membre toto

[skeud]

Bonjour je viens donné mon avis sur la question aussi .

Pour moi, "*" et "&" n'ont rien en commun (simple avis):
_ "*" correspond au type d'une variable
_ "&" correspond à une manière de traiter une variable

ensuite concernant la typologie de déclaration des variable, j'utilise la suivante:
"type" "utilisation" "nom";

Et ceux afin d'éviter les casse-tête avec les * et les &. Par exemple, une référence sur un pointeur, ça devient vite le casse-tête pour savoir où placer correctement l'étoile et le "&". Pire encore si il s'agit d'une référence sur un tableau de pointeur etc .......
Mais en appliquant ma méthodologie, ça devient plus simple.

Référence sur pointeur d'entier nommé ptr.
référence correspond à la manière d'utiliser la variable
pointeur d'entier correspond au type de variable
ptr correspond au nom de la variable
Ce qui donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int* &ptr;

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int* & ptr;

(Personnellement, je préfère la première, car plus jolie à lire).
De plus, en lecture rapide, on voit rapidement que l'on utilise une variable de type int*. La vue n'est pas parasité par le "&".

Ensuite concernant le const, je suis d'avis de le placer à droite de ce que l'on veut const. ça évite les confusion et donne des erreurs plus explicite:
L'habitude:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const int * tableau;

ne nous informe pas vraiment sur quoi est const, le pointeur ou les variable contenu dans le pointeur?

Contrairement aux notations:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int const * tableau

qui indique que les int sont constant mais pas le pointeur

et

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int * const tableau

Qui indique que le pointeur est constant mais pas les valeurs.

Et enfin pour que tout soit constant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int const * const tableau

Certes un peu trivial, mais bien explicite.

M'enfin, tout ceci n'est que mon humble avis .