Format de déclaration d'un pointeur

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 (:mouarf:) générations :

Code:

---

int* a;

---

ou

Code:

---

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 ?

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:

---

int * a;

---

:P

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:

Citation:

---

Envoyé par BS

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

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

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

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

Wahou, du coup comment part le sujet ...

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

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

Un jour, j'ai essayé ceci :

Code:

---

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

Laquelle correspond le mieux à la réalité ?

Citation:

---

Envoyé par Obsidian

Un jour, j'ai essayé ceci :

Code:

---

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

Laquelle correspond le mieux à la réalité ?

---

Aucune...

La meilleure solution dans ce cas là est :

Code:

---

1 2 3

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

---

:D:mouarf::lol:

Citation:

---

Envoyé par Obsidian

Laquelle correspond le mieux à la réalité ?

---

Celle-ci ?

Code:

---

1 2 3

typedef int* intptr; intptr a, b, c;

---

Citation:

---

Envoyé par Arzar

Celle-ci ?

Code:

---

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 :D

Citation:

---

Envoyé par koala01

Aucune...

La meilleure solution dans ce cas là est :

Code:

---

1 2 3

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

---

:D:mouarf::lol:

---

Citation:

---

Envoyé par Arzar

Celle-ci ?

Code:

---

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.

Citation:

---

Envoyé par koala01

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

---

Et si !

Code:

---

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é ! :lol:

Citation:

---

Envoyé par Obsidian

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 à » ?

Citation:

---

Envoyé par Arzar

Et si !

Code:

---

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:

---

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:

---

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:

---

int mavar1, mavar2, matroisiemevariable, maquatriemevariable, mavariabledifferente;

---

Citation:

---

Envoyé par Arzar

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*) :P

---

Non car ça voudrait dire que

Code:

---

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:

---

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 http://forum-images.hardware.fr/icones/wink.gif). Moi ça ne me pose aucun problème...

Citation:

---

Envoyé par Silverstone

Non car ça voudrait dire que

Code:

---

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:

---

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 http://forum-images.hardware.fr/icones/wink.gif). 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)

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

Code:

---

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:

---

void maFonction(const type & param)

---

:mrgreen:

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

Citation:

---

Envoyé par cob59

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

Code:

---

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:

---

void maFonction(const type & param)

---

:mrgreen:

---

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 http://forum-images.hardware.fr/icones/wink.gif .

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