Bonjour,
Je voudrais savoir si la norme du C spécifie l'ordre d'interprétation des différentes conditions dans un if.
Je m'explique, si je fais : if (!empty && is_valid() ), est-ce que la fontion is_valid() va être executé, puis la variable empty examinée, ou le contraire ? D'après moi, c'est de gauche à droite, comme dans l'évaluation de toute expression, mais j'aimerais avoir la confirmation ;)
Bonjour, Je voudrais savoir si la norme du C spécifie l'ordre d'interprétation des différentes conditions dans un if. Je m'explique, si je fais : if (!empty && is_valid() ), est-ce que la fontion is_valid() va être executé, puis la variable empty examinée, ou le contraire ? D'après moi, c'est de gauche à droite, comme dans l'évaluation de toute expression, mais j'aimerais avoir la confirmation ;)
Dans une expression comme if(!empty && is_valid()), l'ordre se fait de gauche à droite et s'arrête à la première expression si elle est fausse (vaut 0). Donc si empty n'est pas nul, !empty vaut 0 et is_valid() n'est pas appelé.
-- Richard
Bonjour,
Je voudrais savoir si la norme du C spécifie l'ordre d'interprétation des
différentes conditions dans un if. Je m'explique, si je fais : if (!empty
&& is_valid() ), est-ce que la fontion is_valid() va être executé, puis la
variable empty examinée, ou le contraire ? D'après moi, c'est de gauche à
droite, comme dans l'évaluation de toute expression, mais j'aimerais avoir
la confirmation ;)
Dans une expression comme if(!empty && is_valid()), l'ordre se fait de
gauche à droite et s'arrête à la première expression si elle est fausse
(vaut 0). Donc si empty n'est pas nul, !empty vaut 0 et is_valid() n'est
pas appelé.
Bonjour, Je voudrais savoir si la norme du C spécifie l'ordre d'interprétation des différentes conditions dans un if. Je m'explique, si je fais : if (!empty && is_valid() ), est-ce que la fontion is_valid() va être executé, puis la variable empty examinée, ou le contraire ? D'après moi, c'est de gauche à droite, comme dans l'évaluation de toute expression, mais j'aimerais avoir la confirmation ;)
Dans une expression comme if(!empty && is_valid()), l'ordre se fait de gauche à droite et s'arrête à la première expression si elle est fausse (vaut 0). Donc si empty n'est pas nul, !empty vaut 0 et is_valid() n'est pas appelé.
-- Richard
Vincent Lefevre
Dans l'article <3f391f81$0$26809$, Raphael Marinier écrit:
Je voudrais savoir si la norme du C spécifie l'ordre d'interprétation des différentes conditions dans un if.
Je m'explique, si je fais : if (!empty && is_valid() ), est-ce que la fontion is_valid() va être executé, puis la variable empty examinée, ou le contraire ? D'après moi, c'est de gauche à droite, comme dans l'évaluation de toute expression, mais j'aimerais avoir la confirmation ;)
Indépendamment du if, si a est faux, alors b n'est pas évaluée dans "a && b". Règles similaires pour || et ?:. C'est d'ailleurs dans la FAQ, non?
-- Vincent Lefèvre - Web: <http://www.vinc17.org/> - 100% validated (X)HTML - Acorn Risc PC, Yellow Pig 17, Championnat International des Jeux Mathématiques et Logiques, TETRHEX, etc. Work: CR INRIA - computer arithmetic / SPACES project at LORIA
Dans l'article <3f391f81$0$26809$626a54ce@news.free.fr>,
Raphael Marinier <marinier.raphael@free.fr> écrit:
Je voudrais savoir si la norme du C spécifie l'ordre
d'interprétation des différentes conditions dans un if.
Je m'explique, si je fais : if (!empty && is_valid() ), est-ce que
la fontion is_valid() va être executé, puis la variable empty
examinée, ou le contraire ? D'après moi, c'est de gauche à droite,
comme dans l'évaluation de toute expression, mais j'aimerais avoir
la confirmation ;)
Indépendamment du if, si a est faux, alors b n'est pas évaluée dans
"a && b". Règles similaires pour || et ?:. C'est d'ailleurs dans la
FAQ, non?
--
Vincent Lefèvre <vincent@vinc17.org> - Web: <http://www.vinc17.org/> - 100%
validated (X)HTML - Acorn Risc PC, Yellow Pig 17, Championnat International
des Jeux Mathématiques et Logiques, TETRHEX, etc.
Work: CR INRIA - computer arithmetic / SPACES project at LORIA
Dans l'article <3f391f81$0$26809$, Raphael Marinier écrit:
Je voudrais savoir si la norme du C spécifie l'ordre d'interprétation des différentes conditions dans un if.
Je m'explique, si je fais : if (!empty && is_valid() ), est-ce que la fontion is_valid() va être executé, puis la variable empty examinée, ou le contraire ? D'après moi, c'est de gauche à droite, comme dans l'évaluation de toute expression, mais j'aimerais avoir la confirmation ;)
Indépendamment du if, si a est faux, alors b n'est pas évaluée dans "a && b". Règles similaires pour || et ?:. C'est d'ailleurs dans la FAQ, non?
-- Vincent Lefèvre - Web: <http://www.vinc17.org/> - 100% validated (X)HTML - Acorn Risc PC, Yellow Pig 17, Championnat International des Jeux Mathématiques et Logiques, TETRHEX, etc. Work: CR INRIA - computer arithmetic / SPACES project at LORIA
Horst Kraemer
On Tue, 12 Aug 2003 19:11:28 +0200, Raphael Marinier wrote:
Bonjour, Je voudrais savoir si la norme du C spécifie l'ordre d'interprétation des différentes conditions dans un if. Je m'explique, si je fais : if (!empty && is_valid() ), est-ce que la fontion is_valid() va être executé, puis la variable empty examinée, ou le contraire ? D'après moi, c'est de gauche à droite, comme dans l'évaluation de toute expression, mais j'aimerais avoir la confirmation ;)
Apparament il y a une confusion entre l'évaluation des operateurs et l'évaluation des opérandes des opérateurs.
Dans une séquence d'opérations de priorité identique comme
a * b / c
Le '*' est évalué avant le '/', c.a.d. l'expressions est interprétée comme si on avait écrit
(a*b)/c
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant 'b'. Les seuls opérateurs binaires dont les *opérandes* seront évalués de gauche à droite sont '||' et '&&' - et l'opérande droite est évaluée si et seulement si le résultat de a&&b ou a||b n'est pas déjà déterminée par le résulat de l'évaluation de 'a'. Donc dans
if (!empty && is_valid() )
l'appel 'is_valid()' n'aura *pas* lieu si le résultat de !empty est 0.
-- Horst
On Tue, 12 Aug 2003 19:11:28 +0200, Raphael Marinier
<marinier.raphael@free.fr> wrote:
Bonjour,
Je voudrais savoir si la norme du C spécifie l'ordre d'interprétation
des différentes conditions dans un if.
Je m'explique, si je fais : if (!empty && is_valid() ), est-ce que la fontion
is_valid() va être executé, puis la variable empty examinée, ou le
contraire ? D'après moi, c'est de gauche à droite, comme dans
l'évaluation de toute expression, mais j'aimerais avoir la confirmation ;)
Apparament il y a une confusion entre l'évaluation des operateurs et
l'évaluation des opérandes des opérateurs.
Dans une séquence d'opérations de priorité identique comme
a * b / c
Le '*' est évalué avant le '/', c.a.d. l'expressions est interprétée
comme si on avait écrit
(a*b)/c
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant
'b'. Les seuls opérateurs binaires dont les *opérandes* seront évalués
de gauche à droite sont '||' et '&&' - et l'opérande droite est
évaluée si et seulement si le résultat de a&&b ou a||b n'est pas déjà
déterminée par le résulat de l'évaluation de 'a'. Donc dans
if (!empty && is_valid() )
l'appel 'is_valid()' n'aura *pas* lieu si le résultat de !empty est 0.
On Tue, 12 Aug 2003 19:11:28 +0200, Raphael Marinier wrote:
Bonjour, Je voudrais savoir si la norme du C spécifie l'ordre d'interprétation des différentes conditions dans un if. Je m'explique, si je fais : if (!empty && is_valid() ), est-ce que la fontion is_valid() va être executé, puis la variable empty examinée, ou le contraire ? D'après moi, c'est de gauche à droite, comme dans l'évaluation de toute expression, mais j'aimerais avoir la confirmation ;)
Apparament il y a une confusion entre l'évaluation des operateurs et l'évaluation des opérandes des opérateurs.
Dans une séquence d'opérations de priorité identique comme
a * b / c
Le '*' est évalué avant le '/', c.a.d. l'expressions est interprétée comme si on avait écrit
(a*b)/c
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant 'b'. Les seuls opérateurs binaires dont les *opérandes* seront évalués de gauche à droite sont '||' et '&&' - et l'opérande droite est évaluée si et seulement si le résultat de a&&b ou a||b n'est pas déjà déterminée par le résulat de l'évaluation de 'a'. Donc dans
if (!empty && is_valid() )
l'appel 'is_valid()' n'aura *pas* lieu si le résultat de !empty est 0.
-- Horst
Raphael Marinier
if (!empty && is_valid() )
l'appel 'is_valid()' n'aura *pas* lieu si le résultat de !empty est 0.
Merci aux personnes qui m'ont répondu pour leurs réponses très claires. Au temps pour moi si c'est dans la FAQ, je la relirai la prochaine fois que je veux poser une question ;)
-- Raphael Marinier
if (!empty && is_valid() )
l'appel 'is_valid()' n'aura *pas* lieu si le résultat de !empty est 0.
Merci aux personnes qui m'ont répondu pour leurs réponses très claires.
Au temps pour moi si c'est dans la FAQ, je la relirai la prochaine fois que je veux poser une question ;)
l'appel 'is_valid()' n'aura *pas* lieu si le résultat de !empty est 0.
Merci aux personnes qui m'ont répondu pour leurs réponses très claires. Au temps pour moi si c'est dans la FAQ, je la relirai la prochaine fois que je veux poser une question ;)
-- Raphael Marinier
Vincent Lefevre
Dans l'article , Horst Kraemer écrit:
Le '*' est évalué avant le '/', c.a.d. l'expressions est interprétée comme si on avait écrit
(a*b)/c
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant 'b'. [...]
On pourrait aussi noter que le langage exige que a *et* b soient évalués, même si la connaissance d'un des opérandes permet de déduire le résultat (e.g. si a = 0)... sauf si cela ne change rien au niveau de la sémantique (5.1.2.3#3).
-- Vincent Lefèvre - Web: <http://www.vinc17.org/> - 100% validated (X)HTML - Acorn Risc PC, Yellow Pig 17, Championnat International des Jeux Mathématiques et Logiques, TETRHEX, etc. Work: CR INRIA - computer arithmetic / SPACES project at LORIA
Dans l'article <rsfijvggasvkkcr4umosg4t0k19oia3dfr@4ax.com>,
Horst Kraemer <horst.kraemer@epost.de> écrit:
Le '*' est évalué avant le '/', c.a.d. l'expressions est interprétée
comme si on avait écrit
(a*b)/c
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant
'b'. [...]
On pourrait aussi noter que le langage exige que a *et* b soient
évalués, même si la connaissance d'un des opérandes permet de
déduire le résultat (e.g. si a = 0)... sauf si cela ne change
rien au niveau de la sémantique (5.1.2.3#3).
--
Vincent Lefèvre <vincent@vinc17.org> - Web: <http://www.vinc17.org/> - 100%
validated (X)HTML - Acorn Risc PC, Yellow Pig 17, Championnat International
des Jeux Mathématiques et Logiques, TETRHEX, etc.
Work: CR INRIA - computer arithmetic / SPACES project at LORIA
Le '*' est évalué avant le '/', c.a.d. l'expressions est interprétée comme si on avait écrit
(a*b)/c
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant 'b'. [...]
On pourrait aussi noter que le langage exige que a *et* b soient évalués, même si la connaissance d'un des opérandes permet de déduire le résultat (e.g. si a = 0)... sauf si cela ne change rien au niveau de la sémantique (5.1.2.3#3).
-- Vincent Lefèvre - Web: <http://www.vinc17.org/> - 100% validated (X)HTML - Acorn Risc PC, Yellow Pig 17, Championnat International des Jeux Mathématiques et Logiques, TETRHEX, etc. Work: CR INRIA - computer arithmetic / SPACES project at LORIA
Vincent Lefevre
Dans l'article , Horst Kraemer écrit:
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant 'b'. Les seuls opérateurs binaires dont les *opérandes* seront évalués de gauche à droite sont '||' et '&&' - et l'opérande droite est évaluée si et seulement si le résultat de a&&b ou a||b n'est pas déjà déterminée par le résulat de l'évaluation de 'a'.
Euh... il y a l'opérateur virgule aussi, non?
-- Vincent Lefèvre - Web: <http://www.vinc17.org/> - 100% validated (X)HTML - Acorn Risc PC, Yellow Pig 17, Championnat International des Jeux Mathématiques et Logiques, TETRHEX, etc. Work: CR INRIA - computer arithmetic / SPACES project at LORIA
Dans l'article <rsfijvggasvkkcr4umosg4t0k19oia3dfr@4ax.com>,
Horst Kraemer <horst.kraemer@epost.de> écrit:
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant
'b'. Les seuls opérateurs binaires dont les *opérandes* seront évalués
de gauche à droite sont '||' et '&&' - et l'opérande droite est
évaluée si et seulement si le résultat de a&&b ou a||b n'est pas déjà
déterminée par le résulat de l'évaluation de 'a'.
Euh... il y a l'opérateur virgule aussi, non?
--
Vincent Lefèvre <vincent@vinc17.org> - Web: <http://www.vinc17.org/> - 100%
validated (X)HTML - Acorn Risc PC, Yellow Pig 17, Championnat International
des Jeux Mathématiques et Logiques, TETRHEX, etc.
Work: CR INRIA - computer arithmetic / SPACES project at LORIA
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant 'b'. Les seuls opérateurs binaires dont les *opérandes* seront évalués de gauche à droite sont '||' et '&&' - et l'opérande droite est évaluée si et seulement si le résultat de a&&b ou a||b n'est pas déjà déterminée par le résulat de l'évaluation de 'a'.
Euh... il y a l'opérateur virgule aussi, non?
-- Vincent Lefèvre - Web: <http://www.vinc17.org/> - 100% validated (X)HTML - Acorn Risc PC, Yellow Pig 17, Championnat International des Jeux Mathématiques et Logiques, TETRHEX, etc. Work: CR INRIA - computer arithmetic / SPACES project at LORIA
Horst Kraemer
On Wed, 13 Aug 2003 08:04:51 +0000 (UTC), Vincent Lefevre <vincent+ wrote:
Dans l'article , Horst Kraemer écrit:
Le '*' est évalué avant le '/', c.a.d. l'expressions est interprétée comme si on avait écrit
(a*b)/c
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant 'b'. [...]
On pourrait aussi noter que le langage exige que a *et* b soient évalués, même si la connaissance d'un des opérandes permet de déduire le résultat (e.g. si a = 0)... sauf si cela ne change rien au niveau de la sémantique (5.1.2.3#3).
Merci pour la remarque. Dans l'expression
f(a) + f(b)
le programme doit se comporter comme si f(b) et f(a) étaient évalués.
Quand le compilatuer "voit" que f est défini ainsi
int f(int) { return 0; }
il a le droit de déduire le résultat 0+0=0 sans appeler f. Mais quand f est défini ainsi
int f(int) { i++; return 0; }
il doit produire des appels f(a) et f(b) à cause des effets de bords i++. Par contre dans
f(a) && f(b)
il doit appeler f(a) (ou déduire le résutat dans la première version de f) et il n'a pas le droit d'appeler f(b) parce que f(a) revoie 0 et le résultat de l'expression totale est déjà déterminé.
-- Horst
On Wed, 13 Aug 2003 08:04:51 +0000 (UTC), Vincent Lefevre
<vincent+news@vinc17.org> wrote:
Dans l'article <rsfijvggasvkkcr4umosg4t0k19oia3dfr@4ax.com>,
Horst Kraemer <horst.kraemer@epost.de> écrit:
Le '*' est évalué avant le '/', c.a.d. l'expressions est interprétée
comme si on avait écrit
(a*b)/c
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant
'b'. [...]
On pourrait aussi noter que le langage exige que a *et* b soient
évalués, même si la connaissance d'un des opérandes permet de
déduire le résultat (e.g. si a = 0)... sauf si cela ne change
rien au niveau de la sémantique (5.1.2.3#3).
Merci pour la remarque. Dans l'expression
f(a) + f(b)
le programme doit se comporter comme si f(b) et f(a) étaient évalués.
Quand le compilatuer "voit" que f est défini ainsi
int f(int) { return 0; }
il a le droit de déduire le résultat 0+0=0 sans appeler f. Mais quand
f est défini ainsi
int f(int) { i++; return 0; }
il doit produire des appels f(a) et f(b) à cause des effets de bords
i++. Par contre dans
f(a) && f(b)
il doit appeler f(a) (ou déduire le résutat dans la première version
de f) et il n'a pas le droit d'appeler f(b) parce que f(a) revoie 0 et
le résultat de l'expression totale est déjà déterminé.
On Wed, 13 Aug 2003 08:04:51 +0000 (UTC), Vincent Lefevre <vincent+ wrote:
Dans l'article , Horst Kraemer écrit:
Le '*' est évalué avant le '/', c.a.d. l'expressions est interprétée comme si on avait écrit
(a*b)/c
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant 'b'. [...]
On pourrait aussi noter que le langage exige que a *et* b soient évalués, même si la connaissance d'un des opérandes permet de déduire le résultat (e.g. si a = 0)... sauf si cela ne change rien au niveau de la sémantique (5.1.2.3#3).
Merci pour la remarque. Dans l'expression
f(a) + f(b)
le programme doit se comporter comme si f(b) et f(a) étaient évalués.
Quand le compilatuer "voit" que f est défini ainsi
int f(int) { return 0; }
il a le droit de déduire le résultat 0+0=0 sans appeler f. Mais quand f est défini ainsi
int f(int) { i++; return 0; }
il doit produire des appels f(a) et f(b) à cause des effets de bords i++. Par contre dans
f(a) && f(b)
il doit appeler f(a) (ou déduire le résutat dans la première version de f) et il n'a pas le droit d'appeler f(b) parce que f(a) revoie 0 et le résultat de l'expression totale est déjà déterminé.
-- Horst
Horst Kraemer
On Wed, 13 Aug 2003 08:06:18 +0000 (UTC), Vincent Lefevre <vincent+ wrote:
Dans l'article , Horst Kraemer écrit:
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant 'b'. Les seuls opérateurs binaires dont les *opérandes* seront évalués de gauche à droite sont '||' et '&&' - et l'opérande droite est évaluée si et seulement si le résultat de a&&b ou a||b n'est pas déjà déterminée par le résulat de l'évaluation de 'a'.
Euh... il y a l'opérateur virgule aussi, non?
Sic
-- Horst
On Wed, 13 Aug 2003 08:06:18 +0000 (UTC), Vincent Lefevre
<vincent+news@vinc17.org> wrote:
Dans l'article <rsfijvggasvkkcr4umosg4t0k19oia3dfr@4ax.com>,
Horst Kraemer <horst.kraemer@epost.de> écrit:
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant
'b'. Les seuls opérateurs binaires dont les *opérandes* seront évalués
de gauche à droite sont '||' et '&&' - et l'opérande droite est
évaluée si et seulement si le résultat de a&&b ou a||b n'est pas déjà
déterminée par le résulat de l'évaluation de 'a'.
On Wed, 13 Aug 2003 08:06:18 +0000 (UTC), Vincent Lefevre <vincent+ wrote:
Dans l'article , Horst Kraemer écrit:
Mais le language n'exige pas que l'opérande 'a' soit 'evaluée avant 'b'. Les seuls opérateurs binaires dont les *opérandes* seront évalués de gauche à droite sont '||' et '&&' - et l'opérande droite est évaluée si et seulement si le résultat de a&&b ou a||b n'est pas déjà déterminée par le résulat de l'évaluation de 'a'.
Euh... il y a l'opérateur virgule aussi, non?
Sic
-- Horst
Frédéri MIAILLE
L'ordre d'évaluation ne dépends ici que de l'opérateur "&&" qui observe les expressions de gauche à droite. Voir règles d'associativité.
