Vos préférences de position des opérateurs * et &

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 ?

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.

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) :aie:.

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.

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

c'est visible dans des codes comme:

Code:

---

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:

---

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.

Citation:

---

Envoyé par leternel

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.

Citation:

---

Envoyé par leternel

c'est visible dans des codes comme:

Code:

---

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.

Citation:

---

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 ?

Citation:

---

Code:

---

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

---

---

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

Citation:

---

Envoyé par leternel

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:

---

1 2 3

T & T const & char const * const

---

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

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

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.

Citation:

---

Envoyé par Ehonn

Citation:

---

Code:

---

int const& a

---

---

J'aime pas cette notation [...]

Personnelement, j'utilise cette notation :

Code:

---

T const &

---

---

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

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.

Citation:

---

Envoyé par Ehonn

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.

Citation:

---

Envoyé par Ehonn

T const& est différent de T const & ;)

---

Et

Code:

---

T const &

---

(deux espaces) ça donne quoi ? :mrgreen:

Code:

---

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

Citation:

---

Envoyé par dragonjoker59

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

Citation:

---

Envoyé par Ehonn

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

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

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

Code:

---

T const&;

---

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

Citation:

---

Envoyé par jblecanard

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

Code:

---

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) :mrgreen:

PS: troll hein

Exact, mais vous avez compris :D 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.

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 :aie: ), ou pointeur sur entier(int*) membre(m) nommé toto(toto).

Code:

---

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

---

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:

---

int* &ptr;

---

ou

Code:

---

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:

---

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:

---

int const * tableau

---

qui indique que les int sont constant mais pas le pointeur

et

Code:

---

int * const tableau

---

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

Et enfin pour que tout soit constant:

Code:

---

int const * const tableau

---

Certes un peu trivial, mais bien explicite.

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