double f( double a, PtrAMaFnc fnc ) { return (*fnc)( a ) ; }
Mais peut-être tu voulais dire qu'en général, les priorités des nombreux opérateurs C++ n'est pas facile à tenir en tête. Là, j'avoue être d'accord. Alors, dans la doute, je mets des parenthèses. (En l'occurance, ils sont nécessaires ci-dessus. Mais j'en mets parfois sans savoir s'ils sont nécessaires ou non.)
En l'occurence, elles ne sont pas nécessaires
return fnc(a);
Sans les parenthèses, ce que j'ai écris devient :
return *fnc( a ) ;
Les parenthèses sont bien nécessaires.
Il y a évidemment d'autres façons d'écrire l'expression. Qui pourrait avoir besoin de plus ou de moins de parenthèses. Je préfère la forme qui dit ce qui se passe -- c'est une question de respect pour le lecteur. (Mais il y a d'autres cas, surtout avec des templates, où l'écriture sans * se justifie.)
Donc tu ne respectes pas le lecteur dans les templates ?
C'est déjà mieux de le respecter ailleurs que dans les templates que pas du tout... Mais le problème est que dans les templates, on peut ne pas savoir le type, et c'est pourquoi James dit que c'est parfois impossible (ou moins clair) de mettre le '*' (enfin, je l'ai compris comme ça). -- <=- Michaël "Cortex" Monerau -=>
Gabriel Dos Reis wrote:
kanze@gabi-soft.fr writes:
Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> wrote in message
news:<flr827r9qu.fsf@sel.cmla.ens-cachan.fr>...
kanze@gabi-soft.fr writes:
typedef double (*PtrAMaFnc)( double ) ;
double
f( double a, PtrAMaFnc fnc )
{
return (*fnc)( a ) ;
}
Mais peut-être tu voulais dire qu'en général, les priorités des
nombreux opérateurs C++ n'est pas facile à tenir en tête. Là,
j'avoue être d'accord. Alors, dans la doute, je mets des
parenthèses. (En l'occurance, ils sont nécessaires ci-dessus. Mais
j'en mets parfois sans savoir s'ils sont nécessaires ou non.)
En l'occurence, elles ne sont pas nécessaires
return fnc(a);
Sans les parenthèses, ce que j'ai écris devient :
return *fnc( a ) ;
Les parenthèses sont bien nécessaires.
Il y a évidemment d'autres façons d'écrire l'expression. Qui pourrait
avoir besoin de plus ou de moins de parenthèses. Je préfère la forme
qui dit ce qui se passe -- c'est une question de respect pour le
lecteur. (Mais il y a d'autres cas, surtout avec des templates, où
l'écriture sans * se justifie.)
Donc tu ne respectes pas le lecteur dans les templates ?
C'est déjà mieux de le respecter ailleurs que dans les templates que pas du
tout...
Mais le problème est que dans les templates, on peut ne pas savoir le type,
et c'est pourquoi James dit que c'est parfois impossible (ou moins clair) de
mettre le '*' (enfin, je l'ai compris comme ça).
--
<=- Michaël "Cortex" Monerau -=>
double f( double a, PtrAMaFnc fnc ) { return (*fnc)( a ) ; }
Mais peut-être tu voulais dire qu'en général, les priorités des nombreux opérateurs C++ n'est pas facile à tenir en tête. Là, j'avoue être d'accord. Alors, dans la doute, je mets des parenthèses. (En l'occurance, ils sont nécessaires ci-dessus. Mais j'en mets parfois sans savoir s'ils sont nécessaires ou non.)
En l'occurence, elles ne sont pas nécessaires
return fnc(a);
Sans les parenthèses, ce que j'ai écris devient :
return *fnc( a ) ;
Les parenthèses sont bien nécessaires.
Il y a évidemment d'autres façons d'écrire l'expression. Qui pourrait avoir besoin de plus ou de moins de parenthèses. Je préfère la forme qui dit ce qui se passe -- c'est une question de respect pour le lecteur. (Mais il y a d'autres cas, surtout avec des templates, où l'écriture sans * se justifie.)
Donc tu ne respectes pas le lecteur dans les templates ?
C'est déjà mieux de le respecter ailleurs que dans les templates que pas du tout... Mais le problème est que dans les templates, on peut ne pas savoir le type, et c'est pourquoi James dit que c'est parfois impossible (ou moins clair) de mettre le '*' (enfin, je l'ai compris comme ça). -- <=- Michaël "Cortex" Monerau -=>
Gabriel Dos Reis
"Michel Michaud" writes:
| >> int A(int); | >> int (*B)(int)= A; | >> | >> int C= B(0); | > | > ceci est l'invention de ANSI C89 comme je l'ai indiqué ci-haut. | > C'est invalide en C classique. | | Tu es sûr ?
OUI.
| Je suis sûr l'avoir fait en C pré-89. Mais ça pouvait | être une extension du compilateur... | | >> int D(int E(int)) { return E(0); } | >> int F(int (*G)(int)) { return (*G)(0); } | >> D(A); D(B); | >> F(A); F(B); | >> | >> Ça me semble assez cohérent :-) | > | > lequel ? | | Tout. La ressemblance entre pointeur sur vecteur/vecteur | et pointeur sur fonction/fonction.
Ah non ! Il n'y a de ressemblance. Si p est un pointeur sur tableau/vecteur, alors il faut explicitement le déréfeence
(*p)[i]
ANSI C89 a cassé cette symétrie.
| Entre mes cas en minuscules | (a à g) et ceux en majuscules (A à G).
essaie encore :-)
-- Gaby
"Michel Michaud" <mm@gdzid.com> writes:
| >> int A(int);
| >> int (*B)(int)= A;
| >>
| >> int C= B(0);
| >
| > ceci est l'invention de ANSI C89 comme je l'ai indiqué ci-haut.
| > C'est invalide en C classique.
|
| Tu es sûr ?
OUI.
| Je suis sûr l'avoir fait en C pré-89. Mais ça pouvait
| être une extension du compilateur...
|
| >> int D(int E(int)) { return E(0); }
| >> int F(int (*G)(int)) { return (*G)(0); }
| >> D(A); D(B);
| >> F(A); F(B);
| >>
| >> Ça me semble assez cohérent :-)
| >
| > lequel ?
|
| Tout. La ressemblance entre pointeur sur vecteur/vecteur
| et pointeur sur fonction/fonction.
Ah non ! Il n'y a de ressemblance. Si p est un pointeur sur
tableau/vecteur, alors il faut explicitement le déréfeence
(*p)[i]
ANSI C89 a cassé cette symétrie.
| Entre mes cas en minuscules
| (a à g) et ceux en majuscules (A à G).
| >> int A(int); | >> int (*B)(int)= A; | >> | >> int C= B(0); | > | > ceci est l'invention de ANSI C89 comme je l'ai indiqué ci-haut. | > C'est invalide en C classique. | | Tu es sûr ?
OUI.
| Je suis sûr l'avoir fait en C pré-89. Mais ça pouvait | être une extension du compilateur... | | >> int D(int E(int)) { return E(0); } | >> int F(int (*G)(int)) { return (*G)(0); } | >> D(A); D(B); | >> F(A); F(B); | >> | >> Ça me semble assez cohérent :-) | > | > lequel ? | | Tout. La ressemblance entre pointeur sur vecteur/vecteur | et pointeur sur fonction/fonction.
Ah non ! Il n'y a de ressemblance. Si p est un pointeur sur tableau/vecteur, alors il faut explicitement le déréfeence
(*p)[i]
ANSI C89 a cassé cette symétrie.
| Entre mes cas en minuscules | (a à g) et ceux en majuscules (A à G).
essaie encore :-)
-- Gaby
kanze
Gabriel Dos Reis wrote in message news:...
writes:
| Gabriel Dos Reis wrote in message | news:... | > writes:
| > | Mais peut-être tu voulais dire qu'en général, les priorités des | > | nombreux opérateurs C++ n'est pas facile à tenir en tête. Là, | > | j'avoue être d'accord. Alors, dans la doute, je mets des | > | parenthèses. (En l'occurance, ils sont nécessaires ci-dessus. | > | Mais j'en mets parfois sans savoir s'ils sont nécessaires ou | > | non.)
| > En l'occurence, elles ne sont pas nécessaires
| > return fnc(a);
| Sans les parenthèses, ce que j'ai écris devient :
| return *fnc( a ) ;
| Les parenthèses sont bien nécessaires.
| Il y a évidemment d'autres façons d'écrire l'expression. Qui | pourrait avoir besoin de plus ou de moins de parenthèses. Je préfère | la forme qui dit ce qui se passe -- c'est une question de respect | pour le lecteur. (Mais il y a d'autres cas, surtout avec des | templates, où l'écriture sans * se justifie.)
Donc tu ne respectes pas le lecteur dans les templates ?
Quand il y a des exigeances contradictoire, il faut choisir. Et l'exigeance que le template peut être instantié n'est pas sans importance non plus.
Et puis, si je ne considèrerais que le lecteur, je n'écrirais pas de templates, de toute façon:-).
-- 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
Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> wrote in message
news:<flpthqfs32.fsf@sel.cmla.ens-cachan.fr>...
kanze@gabi-soft.fr writes:
| Gabriel Dos Reis <dosreis@cmla.ens-cachan.fr> wrote in message
| news:<flr827r9qu.fsf@sel.cmla.ens-cachan.fr>...
| > kanze@gabi-soft.fr writes:
| > | Mais peut-être tu voulais dire qu'en général, les priorités des
| > | nombreux opérateurs C++ n'est pas facile à tenir en tête. Là,
| > | j'avoue être d'accord. Alors, dans la doute, je mets des
| > | parenthèses. (En l'occurance, ils sont nécessaires ci-dessus.
| > | Mais j'en mets parfois sans savoir s'ils sont nécessaires ou
| > | non.)
| > En l'occurence, elles ne sont pas nécessaires
| > return fnc(a);
| Sans les parenthèses, ce que j'ai écris devient :
| return *fnc( a ) ;
| Les parenthèses sont bien nécessaires.
| Il y a évidemment d'autres façons d'écrire l'expression. Qui
| pourrait avoir besoin de plus ou de moins de parenthèses. Je préfère
| la forme qui dit ce qui se passe -- c'est une question de respect
| pour le lecteur. (Mais il y a d'autres cas, surtout avec des
| templates, où l'écriture sans * se justifie.)
Donc tu ne respectes pas le lecteur dans les templates ?
Quand il y a des exigeances contradictoire, il faut choisir. Et
l'exigeance que le template peut être instantié n'est pas sans
importance non plus.
Et puis, si je ne considèrerais que le lecteur, je n'écrirais pas de
templates, de toute façon:-).
--
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
| > | Mais peut-être tu voulais dire qu'en général, les priorités des | > | nombreux opérateurs C++ n'est pas facile à tenir en tête. Là, | > | j'avoue être d'accord. Alors, dans la doute, je mets des | > | parenthèses. (En l'occurance, ils sont nécessaires ci-dessus. | > | Mais j'en mets parfois sans savoir s'ils sont nécessaires ou | > | non.)
| > En l'occurence, elles ne sont pas nécessaires
| > return fnc(a);
| Sans les parenthèses, ce que j'ai écris devient :
| return *fnc( a ) ;
| Les parenthèses sont bien nécessaires.
| Il y a évidemment d'autres façons d'écrire l'expression. Qui | pourrait avoir besoin de plus ou de moins de parenthèses. Je préfère | la forme qui dit ce qui se passe -- c'est une question de respect | pour le lecteur. (Mais il y a d'autres cas, surtout avec des | templates, où l'écriture sans * se justifie.)
Donc tu ne respectes pas le lecteur dans les templates ?
Quand il y a des exigeances contradictoire, il faut choisir. Et l'exigeance que le template peut être instantié n'est pas sans importance non plus.
Et puis, si je ne considèrerais que le lecteur, je n'écrirais pas de templates, de toute façon:-).
-- 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
Gabriel Dos Reis
writes:
[...]
| Et puis, si je ne considèrerais que le lecteur, je n'écrirais pas de | templates, de toute façon:-).
Donc, tu lui infligerais 77 fois la lecture du même motif 77 fois ?
-- Gaby
kanze@gabi-soft.fr writes:
[...]
| Et puis, si je ne considèrerais que le lecteur, je n'écrirais pas de
| templates, de toute façon:-).
Donc, tu lui infligerais 77 fois la lecture du même motif 77 fois ?
| Et puis, si je ne considèrerais que le lecteur, je n'écrirais pas de | templates, de toute façon:-).
Donc, tu lui infligerais 77 fois la lecture du même motif 77 fois ?
-- Gaby
Loïc Joly
Alain Naigeon wrote:
Autrement dit, "convertible en void*" est une condition nécessaire pour être un pointeur - c'est bien ce qu'il dit, non ?
| > std::cout peut se convertir en void*, donc std::cout est un pointeur !
Autrement dit, "peut se convertir en void*" est une condition suffisante, c'est bien ce qu'il dit, non ?
Prendre une condition nécessaire pour suffisante, c'est un sophisme.
Montrer par l'absurde qu'une condition n'est que nécessaire est aussi une façon de mettre l'accent sur le fait que, bien que nécessaire, elle me semble plus anecdotique que fondamentale. Mais, là, on quitte la logique booléenne et mes rares cours de logique floue sont bien loin désormais.
(ceci dit, nous sommes tous trois mortels, humains, etc)
Mais sommes nous tous trois Socrate ?
-- Loïc
Alain Naigeon wrote:
Autrement dit, "convertible en void*" est une condition nécessaire pour
être un pointeur - c'est bien ce qu'il dit, non ?
| > std::cout peut se convertir en void*, donc std::cout est un pointeur !
Autrement dit, "peut se convertir en void*" est une condition suffisante,
c'est bien ce qu'il dit, non ?
Prendre une condition nécessaire pour suffisante, c'est un sophisme.
Montrer par l'absurde qu'une condition n'est que nécessaire est aussi
une façon de mettre l'accent sur le fait que, bien que nécessaire, elle
me semble plus anecdotique que fondamentale. Mais, là, on quitte la
logique booléenne et mes rares cours de logique floue sont bien loin
désormais.
(ceci dit, nous sommes tous trois mortels, humains, etc)
Autrement dit, "convertible en void*" est une condition nécessaire pour être un pointeur - c'est bien ce qu'il dit, non ?
| > std::cout peut se convertir en void*, donc std::cout est un pointeur !
Autrement dit, "peut se convertir en void*" est une condition suffisante, c'est bien ce qu'il dit, non ?
Prendre une condition nécessaire pour suffisante, c'est un sophisme.
Montrer par l'absurde qu'une condition n'est que nécessaire est aussi une façon de mettre l'accent sur le fait que, bien que nécessaire, elle me semble plus anecdotique que fondamentale. Mais, là, on quitte la logique booléenne et mes rares cours de logique floue sont bien loin désormais.
(ceci dit, nous sommes tous trois mortels, humains, etc)
