Discussion :

[cob59]

Bonjour,
Je recycle sûrement de vieux débats, mais ma question est la suivante : lequel de ces deux formats de déclaration de pointeurs est-il le plus raisonnable d'utiliser et - surtout - d'inculquer aux jeunes () générations :

Code :

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

int* a;

ou

Code :

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

int *a;

De mon point de vue, seul le premier format semble cohérent par rapport au reste du langage C/C++ : le type de la variable (int*) suivi du nom de la variable (a). Ce format de déclaration peut donc être compris comme celui de n'importe quel type primitif.
Ici int* a une taille qui lui est propre (selon l'architecture), est stocké et disposé en mémoire comme n'importe quelle valeur, bref c'est presque un type comme un autre si ce n'est qu'il contient une adresse mémoire.

Tout ça n'est peut-être qu'un détail, mais qu'est ce qui pousse autant (une majorité ?) de développeurs à utiliser le second format, si ce n'est le fait de pouvoir déclarer plusieurs pointeurs en une seule ligne ?

[ram-0000]

Disons que dans le 2eme cas, je voie plus vite que "a" est un pointeur car l'étoile est collée à la variable (mais c'est très subjectif et très personnel).

Il y a une 3ème solution pour l'écriture :

Code :

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

int * a;

[Arzar]

Je ne résiste pas au plaisir de citer Bjarne Stroustup, dans une conférence ou il évoque les difficultés que traverse parfois le comité dans l'élaboration du nouveau standart:

Most people prefer to fiddle with details.
"Most people don't want to argue about the big things. You come with something like [...] how to do a type system for templates... But you don't get a discussion about that. Now, if you discuss about how to write a for-loop, you get a really, splendid discussion. And if you start arguing whether you should have a space in-between the int and the * in a pointer you get a REALLY, furious discussion. People actually, LOVE discussing things that don't matter, because it's so easy to have an opinion about those things... "

Aie.
Bon, bien sur le problème est réglé depuis longtemps , int* a est clairement meilleur, car on voit plus vite que "a" est un pointeur car l'étoile est collée au type, donc a est de type (int*)

[cob59]

Et si ces questions étaient plus sérieusement tranchées en C++ ce cher Bjarne n'en entendrait plus parler pendant ses conventions

A mon sens le C++ est déjà suffisamment dégueulasse (vive les * et & multi-usages...) pour qu'on laisse en plus ce genre de libertés aux programmeurs. Prenez exemple sur Java, enfin.

(hein, quoi ? un troll ? où ça ?)

[Goten]

Ouai enfin, comme il le dit c'est loin d'être vital. Je vois pas pourquoi c'est le langage qui déciderai. Certains préfère avant d'autre après (on a eu l'exemple sur ce topic).

Le C++ dégueulasse? u_U

[LittleWhite]

Wahou, du coup comment part le sujet ...

En plus j'étais pas du même avis que ram-0000 :p

[JolyLoic]

De toute façon, dans un programme en C++, la notation * pour désigner un pointeur est tellement rare, que c'est inutile de préciser sous quelle forme l'écrire.

La vraie question, c'est faut il écrire :
vector<int>, shared_ptr<int>, unique_ptr<int>
Ou bien :
vector< int >, shared_ptr< int >, unique_ptr< int >
Ou encore
vector <int> , shared_ptr <int> , unique_ptr <int>

Mais globalement, on s'en moque...

[Obsidian]

Un jour, j'ai essayé ceci :

Code C++ :

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

1
2
3
 
int *     a,b,c;
int      *a,b,c;

Quelles sont, à vue de nez, les variables déclarées par chacune de ces expressions, sachant que ces expressions sont les mêmes ?

Laquelle correspond le mieux à la réalité ?

[koala01]

Un jour, j'ai essayé ceci :

Code C++ :

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

1
2
3
 
int *     a,b,c;
int      *a,b,c;

Quelles sont, à vue de nez, les variables déclarées par chacune de ces expressions, sachant que ces expressions sont les mêmes ?

Laquelle correspond le mieux à la réalité ?

Aucune...

La meilleure solution dans ce cas là est :

Code :

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

1
2
3
int *a; // ou int* a; ou encore int * a; pour ne vexer personne :D
int b;
int c;

[Arzar]

Laquelle correspond le mieux à la réalité ?

Celle-ci ?

Code :

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

1
2
3
 
typedef int* intptr;
intptr a, b, c;

[koala01]

Celle-ci ?

Code :

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

1
2
3
 
typedef int* intptr;
intptr a, b, c;

Mais, là, tu ne déclares plus le même genre de variable pour b et c

[Obsidian]

Aucune...

La meilleure solution dans ce cas là est :

Code :

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

1
2
3
int *a; // ou int* a; ou encore int * a; pour ne vexer personne :D
int b;
int c;

Celle-ci ?

Code :

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

1
2
3
 
typedef int* intptr;
intptr a, b, c;

Je rappelle que mon post faisait référence à celui-c !

Je voulais mettre en évidence le fait que dans le premier cas, l'expression semble déclarer trois pointeurs sur int et que dans le second, elle semble déclarer un pointeur sur int et deux int véritables, chose qu'elle fait réellement.

Donc, pour répondre à cob59, il vaut mieux écrire « int *a » plutôt que « int* a » pour bien mettre en évidence le fait que l'étoile s'applique au nom de la variable et pas à celui du type.

[Arzar]

Mais, là, tu ne déclares plus le même genre de variable pour b et c

Et si !

Code :

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

1
2
3
4
5
 
typdef int* intptr;
intptr a, b, c;
b = new int; // aucun problème, b est bien un int*
*b = 5;

int* est un type. La preuve c'est qu'on peut en faire un alias avec typedef.
Le fait que la déclaration [int* a, b, c;] ne déclare pas trois pointeurs, contrairement à ce que l'on s'attend intuitivement, n'est qu'un héritage d'une bizarrerie du C.

Edit : Fascinant, même les différentes versions de wikipedia ne s'accordent pas sur ce qu'est un pointeur.
française : Un pointeur est en programmation une variable contenant une adresse mémoire.
anglaise : In computer science, a pointer is a programming language data type whose value refers directly to (or "points to") another value stored elsewhere in the computer memory using its address.
allemande : Mit Zeiger oder Pointer wird in der Informatik eine spezielle Variable bezeichnet, die auf eine andere Variable oder Funktion verweist.

Un pointeur est donc une variable, un type de donnée et une "variable spéciale". On n'est pas couché !

[cob59]

il vaut mieux écrire « int *a » plutôt que « int* a » pour bien mettre en évidence le fait que l'étoile s'applique au nom de la variable et pas à celui du type.

Et qu'est ce que tu entends exactement par « l'étoile s'applique à » ?

[koala01]

Et si !

Code :

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

1
2
3
4
5
 
typdef int* intptr;
intptr a, b, c;
b = new int; // aucun problème, b est bien un int*
*b = 5;

int* est un type. La preuve c'est qu'on peut en faire un alias avec typedef.
Le fait que la déclaration [int* a, b, c;] ne déclare pas trois pointeurs, contrairement à ce que l'on s'attend intuitivement, n'est qu'un héritage d'une bizarrerie du C.

Sauf que, jutement avec le typedef tu déclares trois pointeurs, alors que, sans le typedef, quelle que soit la position de l'étoile, tu déclares un pointeur et... deux int...

parce que:

Code :

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

1
2
3
4
int* a, b, c;
int d = 10;
a = &d; // OK: a est bien un pointeur
b = &d; // NOK : impossible de convertir un int en int* ;)

Et donc, partant du fait, que je répète à longueur d'années, qu'un code est plus souvent lu que compilé, et que la première qualité d'un code - avant même de faire ce qu'on attend de lui -doit être d'être facilement compréhensible et non ambigu pour le lecteur, la meilleure solution reste donc bel et bien

Code :

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

1
2
3
int * a;
int b;
int c;

Parce qu'il n'y a ici aucune différence au point de vue des performances, mais que, par contre, nous évitons
que le lecteur ne croie avoir affaire à trois pointeurs
que le lecteur ne "zappe" la déclaration de l'une des variables (ici, le risque est faible, mais il est beaucoup plus présent dans un code proche de

Code :

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

int mavar1, mavar2, matroisiemevariable, maquatriemevariable, mavariabledifferente;

[Silverstone]

Bon, bien sur le problème est réglé depuis longtemps , int* a est clairement meilleur, car on voit plus vite que "a" est un pointeur car l'étoile est collée au type, donc a est de type (int*)

Non car ça voudrait dire que

Code :

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

int* a,b,c;

permettrait de déclarer 3 pointeurs or en fait seul a serait un pointeur dans cette situation...

Il faut donc mettre

Code :

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

int *a,*b,*c;

et là on est obligé de coller les étoiles aux noms des variables.

Donc cette façon de faire s'impose d'elle-même ^^ (en quelque sorte ). Moi ça ne me pose aucun problème...

[koala01]

Non car ça voudrait dire que

Code :

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

int* a,b,c;

permettrait de déclarer 3 pointeurs or en fait seul a serait un pointeur dans cette situation...

Il faut donc mettre

Code :

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

int *a,*b,*c;

et là on est obligé de coller les étoiles aux noms des variables.

Donc cette façon de faire s'impose d'elle-même ^^ (en quelque sorte ). Moi ça ne me pose aucun problème...

C'est une des raisons pour lesquelles il est largement préférable de respecter la règle d'une déclaration ou un instruction par ligne...

Cette règle, pourtant simplissime, permet de s'éviter bien des déconvenues dues à une mauvaise interprétation du code lorsque le lecteur est, au choix (plusieurs possibles)

• distrait
• pressé
• peu habitué
• d'autres possible

J'ai personnellement la conviction que si les gens acceptaient de perdre, au total, quelques minutes à peine à écrire directement un code "dans les règles du lard" (AKA: en le commentant, en l'indentant correctement, en veillant à éviter les effets de bord et en veillant à n'écrire qu'une déclaration/définition/instruction par ligne), les délais nécessaires au débuggage et à la recherche d'erreur seraient très largement moins importants que ce que l'on rencontre (trop) régulièrement à de nombreux niveaux...

Bien sur, cela nécessite un minimum de rigueur, mais c'est réellement le genre de rigueur qui permet d'éviter de trop dépasser les délais, et qui représente dés lors un investissement qui vaut la peine

[EDIT]Et je rajouterais d'ailleurs que, si les gens prenaient l'habitude et la peine de réfléchir à leur algorithme et à le mettre sur papier en utilisant une méthode adaptée aux langages de troisième génération (ce qui exclu le flowchart, bien que le "pseudo code" ne soit pas forcément plus adapté), ils auraient, pour autant que leur logique soit correcte, la quasi certitude que leur code fasse exactement ce qu'ils en attendent à la première compilation réussie (AKA après correction des inévitables erreurs de syntaxe telles que faute de frappe, qu'un ; ou une fermeture d'accolade oubliée)

[cob59]

Le plus amusant dans tout ça, c'est que ceux qui déclarent suivant ce format :

Code :

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

void maFonction(const type *param)

sont bien embêtés quand il s'agit de faire l'équivalent avec une référence mais s'obstinent quand même :

Code :

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

void maFonction(const type & param)

Enfin je reste convaincu que ce genre de libertés n'apportent pas grand chose au langage et compliquent même sont apprentissage.

[Silverstone]

Le plus amusant dans tout ça, c'est que ceux qui déclarent suivant ce format :

Code :

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

void maFonction(const type *param)

sont bien embêtés quand il s'agit de faire l'équivalent avec une référence mais s'obstinent quand même :

Code :

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

void maFonction(const type & param)

La 1ère déclaration est bien (même si le mot const n'est pas vraiment nécessaire dans l'exemple) et la 2ème moi j'aurai pas mis d'espace entre le & et le nom de la variable...

Donc je ne vois pas où est le problème .

[Goten]

D'ailleurs j'aurais même plus tendance à mettre : (T const &param)