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

Citation:

---

Envoyé par skeud

"&" correspond à une manière de traiter une variable

---

Je ne comprend pas trop ce que tu veux dire.

Citation:

---

Mais en appliquant ma méthodologie, ça devient plus simple.

---

Il y a plus simple : on sait qu'il faut lire de "droite à gauche".
Au pire, on test et le compilateur nous criera dessus (un "pointeur sur une référence" n'existe pas).

HS. Par contre là où j'hésite toujours le temps c'est pour les pointeurs sur un tableau et tableau de pointeurs :aie:.

Code:

---

1 2 3

int * tab[] ; // tableau de pointeurs sur int int (* tab)[8] ; // pointeur sur un tableau de int int * (tab[]); // tableau de pointeurs sur int

---

Citation:

---

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

---

Je ne suis pas du tout d'accord.

Dans le premier cas const int *, const est proche de "int", je n'ai jamais vu un débutant avoir une confusion là-dessus.
De même pour int * const, le const est proche de "*".

Par contre, pour int const *, le const porte sur quoi? à droite ou à gauche ?
Je ne suis pas sûr que si on pose la question, tout le monde répondra correctement, moi le premier :aie:.

Citation:

---

Envoyé par Neckara

Par contre, pour int const *, le const porte sur quoi? à droite ou à gauche ?

---

Le const porte sur int.
Le standard indique que const s'applique sur ce qui est à gauche. La forme "const T" est un "abus de langage" qui est accepté par le standard.

Citation:

---

Envoyé par skeud

Contrairement aux notations:

Code:

---

int const * tableau

---

qui indique que les int sont constant mais pas le pointeur

---

Citation:

---

Envoyé par the Hound

Citation:

---

Par contre, pour int const *, le const porte sur quoi? à droite ou à gauche ?

---

Le const porte sur int.
Le standard indique que const s'applique sur ce qui est à gauche. La forme "const T" est un "abus de langage" qui est accepté par le standard.

---

C'était une question rhétorique, skeud ayant déjà donné la réponse avant que je ne poste.
Le standard indique que le const s'applique sur ce qui est à gauche et à défaut sur ce qui est à droite.

On ne peut pas vraiment dire que c'est un "abus de langage" car cela fait partie intégrante de la norme 89/90 et il me semble que les bibliothèques standards préfère la notation const int à int const.
Pour être franc, je n'ai jamais vu quelqu'un écrire [codeinline]int const variable = 10;[codeinline].


Pour en revenir au sujet originel, on trouve un peu de tout :

• '*' collé au type dans le code source de la SFML ;
• '*' entouré d'espaces sur cppreference ;
• '*' collé au nom de variable pour la bibliothèque standard linux, pour Doxygen (regardé sur celui de la SFML), et un tutoriel d'un site concurrent.

Mais je suis assez surpris par les résultats du sondage, il me semblait qu'on apprenait plutôt la seconde "forme" en IUT/école d'ingénieur.

Citation:

---

Envoyé par Neckara

Je ne comprend pas trop ce que tu veux dire.

---

Quand je dis que & est une manière de traiter la variable c'est de ce point de vue:

Code:

---

int* ptr

---

ou

Code:

---

int* &ptr

---

Dans les deux cas on utilise une variable de type int* (jusque la on est d'accord).

Par contre la manière d’utilisé cette variable change grâce au "&".

Dans le premier cas: le compilo effectue une copie de la variable source.
Dans le deuxième cas: le compilo nous envois la variable source.

C'est pourquoi je fais une différence entre le "&" et les autre en disant que le "&" définis la manière d'utiliser une variable et ne définis pas le type d'une variable (même si ce point est discutable, tout dépend ce que l'on appelle "type" d'une variable) :).

De même pour le "const", pour moi c'est une manière d'utilisé la variable et non pas une définition de son type.

[EDIT]La plupart des gens utilise const int car le compilo l'autorise, mais pourquoi?
(je ne retrouve plus l'article)
à la base, la notation était "int const" car le const portait principalement sur le type de gauche (surement des raisons pratique, mais je ne les connais pas). Sauf qu'en anglais, on dit: "constant integer", d'où un nombre de confusion énorme et nombre d'erreur de compilation. La fonctionnalité de pouvoir placé le const à gauche a été rajouté dans cette optique là :).
D'ailleurs si on traduit en français:
nombre entier constant
on retrouve bien la notation "int const" ;)

Mais si on part des choses qu'autorise le compilo, je pense qu'on a pas finis (accolade placé bizarrement, goto, etc ....).

Pour finir, comme je le dis toujours, ce n'est pas parce que le compilo l'autorise qu'il faut forcément l'utiliser :).[/EDIT].

Citation:

---

Envoyé par Neckara

Pour être franc, je n'ai jamais vu quelqu'un écrire int const variable = 10;.

---

Moi je le fais :aie:

Sinon pour la définition du const, j'aime bien celle de la FAQ :

Citation:

---

La règle est que le const s'applique toujours sur ce qui le précède. S'il n'y a rien avant, alors on inverse sa position avec ce qui est juste après.

---

Car elle explique clairement que par défaut const s'applique à ce qu'il y a devant (et le reste semble être un peu comme une exception).

Neckara: ah d'accord c'était une façon de souligner le manque de cohésion/clarté dans le standard ... :aie:

Citation:

---

Envoyé par skeud

Quand je dis que & est une manière de traiter la variable c'est de ce point de vue:

Code:

---

int* ptr

---

ou

Code:

---

int* &ptr

---

Dans les deux cas on utilise une variable de type int* (jusque la on est d'accord).

Par contre la manière d’utilisé cette variable change grâce au "&".

Dans le premier cas: le compilo effectue une copie de la variable source.
Dans le deuxième cas: le compilo nous envois la variable source.

C'est pourquoi je fais une différence entre le "&" et les autre en disant que le "&" définis la manière d'utiliser une variable et ne définis pas le type d'une variable (même si ce point est discutable, tout dépend ce que l'on appelle "type" d'une variable) :).

De même pour le "const", pour moi c'est une manière d'utilisé la variable et non pas une définition de son type.

---

C'est une manière de voir les choses ... pour moi ça ne fait que les compliquer.
En effet, si tu déclares int& x; le compilo va gueuler parce qu'une référence non-initialisée c'est pas valide. x n'est donc pas un int mais bien un type référence sur int en tant que tel.
Mais si on reste dans ta logique, alors il faut nécessairement différencier la référence passée en paramètre d'une fonction de la "variable référence". Puisque dans le premier cas, le "&" ne dénote qu'une "manière de faire", alors que dans le deuxième, c'est un attribut de type à part entière.

Citation:

---

Envoyé par skeud

Par contre la manière d’utilisé cette variable change grâce au "&".

Dans le premier cas: le compilo effectue une copie de la variable source.
Dans le deuxième cas: le compilo nous envois la variable source.

---

C'est un peu capillotracté :aie:
Je préfère me dire que la référence est un "alias" sur une variable existante.

Citation:

---

De même pour le "const", pour moi c'est une manière d'utilisé la variable

---

Citation:

---

La fonctionnalité de pouvoir placé le const à gauche a été rajouté dans cette optique là :).
[...]
Mais si on part des choses qu'autorise le compilo, je pense qu'on a pas finis (accolade placé bizarrement, goto, etc ....).

---

Donc ils ont rajouté cela pour qu'on ne l'utilise pas ? :aie:.
Du moment que tout le monde l'utilise de cette manière et qu'il n'y a pas d'ambiguïté, je ne vois pas l'intérêt de faire différemment à part pour embrouiller celui qui relit.

le const à gauche est très utile pour une variable locale, je trouve.
Par contre, dans les arguments de fonctions, je le préfère à droite.

Par exemple, j'écrirai ceci:

Code:

---

1 2 3 4

template <typename T> T antinorme(T const& a, T const& b) { const T temp = a*b; return sqrt (temp) * temp; }

---

ps: pardonne moi, ami physicien, je sais que ça n'a aucune validité.

Je trouve que la notation avec espaces des deux cotés est plus lisible, cepandant je trouve que l'autre notation a plus de sens.

Quant à savoir vraiment laquelle est mieux... pour ma part, j'utilise les deux notations en fonctions de mon humeur :) généralement, en été j'utilise les deux espaces pour aérer le code parce que dans le sud ça chauffe, et en hiver je met cote à cote pour tenir chaud.

Code:

---

1 2 3

int * pi; int* pi;

---

ou encore pour les réference (que je n'utilise uniquement pour les fonctions valeur de retour + arguments)

Code:

---

1 2 3

int & fct(const int &); int& fct(const int&);

---