Bonjour, excusez ma pollution mais j'ai récemment décidé d'écrire maClasse* monPtr au lieu du contraire à savoir maClasse *monPtr.
J'ai cru lire quelque part que c'était la deuxième forme qui était la bonne, quelqu'un peut confirmer ? Bonjour,
Les deux sont valables Je pense que l'important, comme souvent, c'est de choisir une forme et de s'y tenir. Voici MON approche, qui n'est pas meilleure que les autres mais qui me convient : En C comme en C++, un pointeur est un type dérivé (C) ou composé (compound, en C++) d'un autre type. Donc Type* est un type. De plus, * dans *pVar est l'opérateur de déréférencement. Je déclare donc : Type* pVar; Bien entendu, comme le signale Anthony, le danger est grand de taper : Type* pVar1, pVar2; Personellement, je m'interdis : Type * pVar1, * pVar2; Soit je déclare un pointeur par ligne, soit je passe par un typedef : typedef char* pchar; pchar p1, p2; Voila, à vous de voir ... Pierre
"Zouplaz" <pouet@pouet.com> a écrit dans le message de news:
Xns942357954F451Zoupla@213.228.0.32...
Bonjour, excusez ma pollution mais j'ai récemment décidé d'écrire
maClasse* monPtr au lieu du contraire à savoir maClasse *monPtr.
J'ai cru lire quelque part que c'était la deuxième forme qui était la
bonne, quelqu'un peut confirmer ?
Bonjour,
Les deux sont valables
Je pense que l'important, comme souvent, c'est de choisir une forme et de
s'y tenir.
Voici MON approche, qui n'est pas meilleure que les autres mais qui me
convient :
En C comme en C++, un pointeur est un type dérivé (C) ou composé (compound,
en C++) d'un autre type. Donc Type* est un type. De plus, * dans *pVar est
l'opérateur de déréférencement. Je déclare donc :
Type* pVar;
Bien entendu, comme le signale Anthony, le danger est grand de taper :
Type* pVar1, pVar2;
Personellement, je m'interdis :
Type * pVar1, * pVar2;
Soit je déclare un pointeur par ligne, soit je passe par un typedef :
typedef char* pchar;
pchar p1, p2;
Voila, à vous de voir ...
Pierre
Bonjour, excusez ma pollution mais j'ai récemment décidé d'écrire maClasse* monPtr au lieu du contraire à savoir maClasse *monPtr.
J'ai cru lire quelque part que c'était la deuxième forme qui était la bonne, quelqu'un peut confirmer ? Bonjour,
Les deux sont valables Je pense que l'important, comme souvent, c'est de choisir une forme et de s'y tenir. Voici MON approche, qui n'est pas meilleure que les autres mais qui me convient : En C comme en C++, un pointeur est un type dérivé (C) ou composé (compound, en C++) d'un autre type. Donc Type* est un type. De plus, * dans *pVar est l'opérateur de déréférencement. Je déclare donc : Type* pVar; Bien entendu, comme le signale Anthony, le danger est grand de taper : Type* pVar1, pVar2; Personellement, je m'interdis : Type * pVar1, * pVar2; Soit je déclare un pointeur par ligne, soit je passe par un typedef : typedef char* pchar; pchar p1, p2; Voila, à vous de voir ... Pierre
Fabien LE LEZ
On 29 Oct 2003 09:21:13 GMT, Zouplaz wrote:
Oui mais moi je ne sais programmer qu'AVEC des pointeurs ;-)
Dans ce cas tu fais du C. En C++ les pointeurs ne s'utilisent que s'il n'y a pas d'autre méthode.
-- ;-)
On 29 Oct 2003 09:21:13 GMT, Zouplaz <pouet@pouet.com> wrote:
Oui mais moi je ne sais programmer qu'AVEC des pointeurs ;-)
Dans ce cas tu fais du C. En C++ les pointeurs ne s'utilisent que s'il
n'y a pas d'autre méthode.
Oui mais moi je ne sais programmer qu'AVEC des pointeurs ;-)
Dans ce cas tu fais du C. En C++ les pointeurs ne s'utilisent que s'il n'y a pas d'autre méthode.
-- ;-)
Michel Michaud
Dans news:bno470$v1c$, Anthony
Par contre (en fait, surtout en C) pour ma part j'écris plutôt le deuxième. En effet si tu fais ca :
maClasse* ptr1, ptr2;
en mettant l'étoile acollée à maClasse, tu pourrais croire que les deux sont des pointeurs, alors que le deuxième n'en sera pas. Je mets donc maClasse *ptr1, *ptr2; pour bien montrer que * ne fait pas partie du type dans la déclaration.
En C++, on devrait autant que possible déclarer les variables seulement lorsqu'on peut les initialiser. Dans ce cas, il est rare d'avoir à déclarer deux variables. Une règle simple est donc de ne déclarer qu'un variable à la fois. Dans ce cas, il n'y a aucun danger à mettre C* v=...;
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Dans news:bno470$v1c$1@tem.asynchrone.net, Anthony
Par contre (en fait, surtout en C) pour ma part j'écris plutôt le
deuxième. En effet si tu fais ca :
maClasse* ptr1, ptr2;
en mettant l'étoile acollée à maClasse, tu pourrais croire que les
deux sont des pointeurs, alors que le deuxième n'en sera pas.
Je mets donc maClasse *ptr1, *ptr2; pour bien montrer que * ne fait
pas partie du type dans la déclaration.
En C++, on devrait autant que possible déclarer les variables
seulement lorsqu'on peut les initialiser. Dans ce cas, il est
rare d'avoir à déclarer deux variables. Une règle simple est
donc de ne déclarer qu'un variable à la fois. Dans ce cas, il
n'y a aucun danger à mettre C* v=...;
--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Par contre (en fait, surtout en C) pour ma part j'écris plutôt le deuxième. En effet si tu fais ca :
maClasse* ptr1, ptr2;
en mettant l'étoile acollée à maClasse, tu pourrais croire que les deux sont des pointeurs, alors que le deuxième n'en sera pas. Je mets donc maClasse *ptr1, *ptr2; pour bien montrer que * ne fait pas partie du type dans la déclaration.
En C++, on devrait autant que possible déclarer les variables seulement lorsqu'on peut les initialiser. Dans ce cas, il est rare d'avoir à déclarer deux variables. Une règle simple est donc de ne déclarer qu'un variable à la fois. Dans ce cas, il n'y a aucun danger à mettre C* v=...;
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Michel Michaud
Dans news:1mpe28z4wytq7$, Serge
Le mercredi 29 octobre 2003 à 08:33, Zouplaz a écrit dans fr.comp.lang.c++ :
Bonjour, excusez ma pollution mais j'ai récemment décidé d'écrire maClasse* monPtr au lieu du contraire à savoir maClasse *monPtr.
J'ai cru lire quelque part que c'était la deuxième forme qui était la bonne, quelqu'un peut confirmer ?
Merci
La deuxième est plus répandue à cause du « piège » suivant :
type_t* a, b;
On a l'impression, à première vue, que a et b sont tous les deux de type type_t*, ce qui n'est pas vrai.
Mais ce n'est pas un gros piège. L'utilisation de b ne compilera pas si ce n'est pas ce que tu voulais et vice-versa.
Par ailleurs, donnez des exemples de confusion avec des noms aussi peu significatifs, c'est un peu un piège aussi :-)
Avec : type_t *a, b;
c'est légèrement moins trompeur.
Avec type_client *ptrClient, client;
c'est encore bien mieux ! (même si on reste dans le vague...)
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Dans news:1mpe28z4wytq7$.dlg@canttouchthis-127.0.0.1, Serge
Le mercredi 29 octobre 2003 à 08:33, Zouplaz a écrit dans
fr.comp.lang.c++ :
Bonjour, excusez ma pollution mais j'ai récemment décidé d'écrire
maClasse* monPtr au lieu du contraire à savoir maClasse *monPtr.
J'ai cru lire quelque part que c'était la deuxième forme qui était
la bonne, quelqu'un peut confirmer ?
Merci
La deuxième est plus répandue à cause du « piège » suivant :
type_t* a, b;
On a l'impression, à première vue, que a et b sont tous les deux de
type type_t*, ce qui n'est pas vrai.
Mais ce n'est pas un gros piège. L'utilisation de b ne compilera pas
si ce n'est pas ce que tu voulais et vice-versa.
Par ailleurs, donnez des exemples de confusion avec des noms aussi peu
significatifs, c'est un peu un piège aussi :-)
Avec :
type_t *a, b;
c'est légèrement moins trompeur.
Avec
type_client *ptrClient, client;
c'est encore bien mieux ! (même si on reste dans le vague...)
--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Le mercredi 29 octobre 2003 à 08:33, Zouplaz a écrit dans fr.comp.lang.c++ :
Bonjour, excusez ma pollution mais j'ai récemment décidé d'écrire maClasse* monPtr au lieu du contraire à savoir maClasse *monPtr.
J'ai cru lire quelque part que c'était la deuxième forme qui était la bonne, quelqu'un peut confirmer ?
Merci
La deuxième est plus répandue à cause du « piège » suivant :
type_t* a, b;
On a l'impression, à première vue, que a et b sont tous les deux de type type_t*, ce qui n'est pas vrai.
Mais ce n'est pas un gros piège. L'utilisation de b ne compilera pas si ce n'est pas ce que tu voulais et vice-versa.
Par ailleurs, donnez des exemples de confusion avec des noms aussi peu significatifs, c'est un peu un piège aussi :-)
Avec : type_t *a, b;
c'est légèrement moins trompeur.
Avec type_client *ptrClient, client;
c'est encore bien mieux ! (même si on reste dans le vague...)
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Pierre Maurette
"Michel Michaud" a écrit [...]
En C++, on devrait autant que possible déclarer les variables seulement lorsqu'on peut les initialiser. Dans ce cas, il est rare d'avoir à déclarer deux variables. Une règle simple est donc de ne déclarer qu'un variable à la fois. Dans ce cas, il n'y a aucun danger à mettre C* v=...; 100% OK
Peut-être : C* pv = ....; Pïerre
"Michel Michaud" <mm@gdzid.com> a écrit
[...]
En C++, on devrait autant que possible déclarer les variables
seulement lorsqu'on peut les initialiser. Dans ce cas, il est
rare d'avoir à déclarer deux variables. Une règle simple est
donc de ne déclarer qu'un variable à la fois. Dans ce cas, il
n'y a aucun danger à mettre C* v=...;
100% OK
En C++, on devrait autant que possible déclarer les variables seulement lorsqu'on peut les initialiser. Dans ce cas, il est rare d'avoir à déclarer deux variables. Une règle simple est donc de ne déclarer qu'un variable à la fois. Dans ce cas, il n'y a aucun danger à mettre C* v=...; 100% OK
Peut-être : C* pv = ....; Pïerre
Anthony Fleury
En C++, on devrait autant que possible déclarer les variables seulement lorsqu'on peut les initialiser. Dans ce cas, il est rare d'avoir à déclarer deux variables. Une règle simple est donc de ne déclarer qu'un variable à la fois. Dans ce cas, il n'y a aucun danger à mettre C* v=...;
Je suis bien d'accord sur ce point. En fait, je tirais ma justification sur la position de l' * dans une déclaration/définition de mon experience en C. Il est cependant vrai que je n'utilise jamais cette construction en C++.
Anthony -- "On est bien sûr de soi quand on est grand, avec notre savoir, notre moral, tous ces principes auxquels on tient tant. Mais c'est souvent trop tard que l'on comprend, que le bonheur était simple comme un jeu d'enfant." -- Sinsemilia
En C++, on devrait autant que possible déclarer les variables
seulement lorsqu'on peut les initialiser. Dans ce cas, il est
rare d'avoir à déclarer deux variables. Une règle simple est
donc de ne déclarer qu'un variable à la fois. Dans ce cas, il
n'y a aucun danger à mettre C* v=...;
Je suis bien d'accord sur ce point. En fait, je tirais ma justification sur
la position de l' * dans une déclaration/définition de mon experience en C.
Il est cependant vrai que je n'utilise jamais cette construction en C++.
Anthony
--
"On est bien sûr de soi quand on est grand, avec notre savoir, notre
moral, tous ces principes auxquels on tient tant.
Mais c'est souvent trop tard que l'on comprend, que le bonheur
était simple comme un jeu d'enfant." -- Sinsemilia
En C++, on devrait autant que possible déclarer les variables seulement lorsqu'on peut les initialiser. Dans ce cas, il est rare d'avoir à déclarer deux variables. Une règle simple est donc de ne déclarer qu'un variable à la fois. Dans ce cas, il n'y a aucun danger à mettre C* v=...;
Je suis bien d'accord sur ce point. En fait, je tirais ma justification sur la position de l' * dans une déclaration/définition de mon experience en C. Il est cependant vrai que je n'utilise jamais cette construction en C++.
Anthony -- "On est bien sûr de soi quand on est grand, avec notre savoir, notre moral, tous ces principes auxquels on tient tant. Mais c'est souvent trop tard que l'on comprend, que le bonheur était simple comme un jeu d'enfant." -- Sinsemilia
Michel Michaud
Dans news:bnp0po$s0l$, Anthony
En C++, on devrait autant que possible déclarer les variables seulement lorsqu'on peut les initialiser. Dans ce cas, il est rare d'avoir à déclarer deux variables. Une règle simple est donc de ne déclarer qu'un variable à la fois. Dans ce cas, il n'y a aucun danger à mettre C* v=...;
Je suis bien d'accord sur ce point. En fait, je tirais ma justification sur la position de l' * dans une déclaration/définition de mon experience en C. Il est cependant vrai que je n'utilise jamais cette construction en C++.
En C, j'utilise type *p. En C++, j'utilise type* p.
Deux langages différents...
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Dans news:bnp0po$s0l$1@tem.asynchrone.net, Anthony
En C++, on devrait autant que possible déclarer les variables
seulement lorsqu'on peut les initialiser. Dans ce cas, il est
rare d'avoir à déclarer deux variables. Une règle simple est
donc de ne déclarer qu'un variable à la fois. Dans ce cas, il
n'y a aucun danger à mettre C* v=...;
Je suis bien d'accord sur ce point. En fait, je tirais ma
justification sur la position de l' * dans une
déclaration/définition de mon experience en C. Il est cependant
vrai que je n'utilise jamais cette construction en C++.
En C, j'utilise type *p. En C++, j'utilise type* p.
Deux langages différents...
--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
En C++, on devrait autant que possible déclarer les variables seulement lorsqu'on peut les initialiser. Dans ce cas, il est rare d'avoir à déclarer deux variables. Une règle simple est donc de ne déclarer qu'un variable à la fois. Dans ce cas, il n'y a aucun danger à mettre C* v=...;
Je suis bien d'accord sur ce point. En fait, je tirais ma justification sur la position de l' * dans une déclaration/définition de mon experience en C. Il est cependant vrai que je n'utilise jamais cette construction en C++.
En C, j'utilise type *p. En C++, j'utilise type* p.
Deux langages différents...
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Anthony Fleury
Dans news:bnp0po$s0l$, Anthony
Je suis bien d'accord sur ce point. En fait, je tirais ma justification sur la position de l' * dans une déclaration/définition de mon experience en C. Il est cependant vrai que je n'utilise jamais cette construction en C++.
En C, j'utilise type *p. En C++, j'utilise type* p.
Deux langages différents...
Je voulais plutôt dire qu'en C++ je n'avais encore jamais écrit type *a, *b, *c; alors que je l'ai fait assez souvent en C. En clair, en C++ j'essaye de toujours définir mes variables, donc de leur donner directement une valeur et donc en effet je n'enchaîne pas les déclarations.
Anthony -- "On est bien sûr de soi quand on est grand, avec notre savoir, notre moral, tous ces principes auxquels on tient tant. Mais c'est souvent trop tard que l'on comprend, que le bonheur était simple comme un jeu d'enfant." -- Sinsemilia
Dans news:bnp0po$s0l$1@tem.asynchrone.net, Anthony
Je suis bien d'accord sur ce point. En fait, je tirais ma
justification sur la position de l' * dans une
déclaration/définition de mon experience en C. Il est cependant
vrai que je n'utilise jamais cette construction en C++.
En C, j'utilise type *p. En C++, j'utilise type* p.
Deux langages différents...
Je voulais plutôt dire qu'en C++ je n'avais encore jamais écrit type *a, *b,
*c; alors que je l'ai fait assez souvent en C.
En clair, en C++ j'essaye de toujours définir mes variables, donc de leur
donner directement une valeur et donc en effet je n'enchaîne pas les
déclarations.
Anthony
--
"On est bien sûr de soi quand on est grand, avec notre savoir, notre
moral, tous ces principes auxquels on tient tant.
Mais c'est souvent trop tard que l'on comprend, que le bonheur
était simple comme un jeu d'enfant." -- Sinsemilia
Je suis bien d'accord sur ce point. En fait, je tirais ma justification sur la position de l' * dans une déclaration/définition de mon experience en C. Il est cependant vrai que je n'utilise jamais cette construction en C++.
En C, j'utilise type *p. En C++, j'utilise type* p.
Deux langages différents...
Je voulais plutôt dire qu'en C++ je n'avais encore jamais écrit type *a, *b, *c; alors que je l'ai fait assez souvent en C. En clair, en C++ j'essaye de toujours définir mes variables, donc de leur donner directement une valeur et donc en effet je n'enchaîne pas les déclarations.
Anthony -- "On est bien sûr de soi quand on est grand, avec notre savoir, notre moral, tous ces principes auxquels on tient tant. Mais c'est souvent trop tard que l'on comprend, que le bonheur était simple comme un jeu d'enfant." -- Sinsemilia
Jean-Marc Molina
Ne pas oublier non plus d'initialiser un pointeur quand on a pas recours aux smart_ptr de boost : type * mon_pointeur = NULL; Après on peut contrôler avec des ASSERTs dans tous les coins. Ça évite les mauvaises surprises et surtout d'avoir des pointeurs fous et des memory leaks dans tous les coins :)
JM
-- Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
Ne pas oublier non plus d'initialiser un pointeur quand on a pas recours aux
smart_ptr de boost :
type * mon_pointeur = NULL;
Après on peut contrôler avec des ASSERTs dans tous les coins. Ça évite les
mauvaises surprises et surtout d'avoir des pointeurs fous et des memory
leaks dans tous les coins :)
JM
--
Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
Ne pas oublier non plus d'initialiser un pointeur quand on a pas recours aux smart_ptr de boost : type * mon_pointeur = NULL; Après on peut contrôler avec des ASSERTs dans tous les coins. Ça évite les mauvaises surprises et surtout d'avoir des pointeurs fous et des memory leaks dans tous les coins :)
JM
-- Clé AntiPourriel : PASUNPOURRIEL (ne pas retirer)
kanze
Fabien LE LEZ wrote in message news:...
On 29 Oct 2003 09:21:13 GMT, Zouplaz wrote:
Oui mais moi je ne sais programmer qu'AVEC des pointeurs ;-)
Dans ce cas tu fais du C. En C++ les pointeurs ne s'utilisent que s'il n'y a pas d'autre méthode.
En C++, les pointeurs servent quand on a besoin de pointeurs.
La différence de C++, par rapport à C, c'est qu'on a, ou qu'on peut avoir, au moins, différents types de pointeurs : les pointeurs bruts, les pointeurs à référence comptées, les pointeurs faibles, les pointeurs avec gestion de cache, les pointeurs...
Dans certains cas, après analyse du problème, j'adopte des pointeurs à référence comptées. Pas celui de Boost, parce que Boost ne marche pas avec certains des compilateurs qu'il faut que je supporte. Et même aujourd'hui, pour mes applications, je trouve que l'idiome invasif convient mieux.
Mais aucune solution (à part peut-être une vraie ramasse-miettes) n'est parfait, et aucune solution peut s'appliquer partout.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
Fabien LE LEZ <gramster@gramster.com> wrote in message
news:<tiqvpvc0pg24g46vp00m7dcikov1rb672i@4ax.com>...
On 29 Oct 2003 09:21:13 GMT, Zouplaz <pouet@pouet.com> wrote:
Oui mais moi je ne sais programmer qu'AVEC des pointeurs ;-)
Dans ce cas tu fais du C. En C++ les pointeurs ne s'utilisent que s'il
n'y a pas d'autre méthode.
En C++, les pointeurs servent quand on a besoin de pointeurs.
La différence de C++, par rapport à C, c'est qu'on a, ou qu'on peut
avoir, au moins, différents types de pointeurs : les pointeurs bruts,
les pointeurs à référence comptées, les pointeurs faibles, les pointeurs
avec gestion de cache, les pointeurs...
Dans certains cas, après analyse du problème, j'adopte des pointeurs à
référence comptées. Pas celui de Boost, parce que Boost ne marche pas
avec certains des compilateurs qu'il faut que je supporte. Et même
aujourd'hui, pour mes applications, je trouve que l'idiome invasif
convient mieux.
Mais aucune solution (à part peut-être une vraie ramasse-miettes) n'est
parfait, et aucune solution peut s'appliquer partout.
--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
Oui mais moi je ne sais programmer qu'AVEC des pointeurs ;-)
Dans ce cas tu fais du C. En C++ les pointeurs ne s'utilisent que s'il n'y a pas d'autre méthode.
En C++, les pointeurs servent quand on a besoin de pointeurs.
La différence de C++, par rapport à C, c'est qu'on a, ou qu'on peut avoir, au moins, différents types de pointeurs : les pointeurs bruts, les pointeurs à référence comptées, les pointeurs faibles, les pointeurs avec gestion de cache, les pointeurs...
Dans certains cas, après analyse du problème, j'adopte des pointeurs à référence comptées. Pas celui de Boost, parce que Boost ne marche pas avec certains des compilateurs qu'il faut que je supporte. Et même aujourd'hui, pour mes applications, je trouve que l'idiome invasif convient mieux.
Mais aucune solution (à part peut-être une vraie ramasse-miettes) n'est parfait, et aucune solution peut s'appliquer partout.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
