Il me semble que l'expression suivante est autorisée (même si elle a
un comportement indéfini) :
int x= x+1;
Y a-t-il une raison pour laquelle les auteurs de la norme n'ont pas
purement et simplement interdit cette écriture ? Accessoirement, y
a-t-il des cas (pas trop tordus) où elle peut être utile ?
Il me semble que l'expression suivante est autorisée (même si elle a un comportement indéfini) :
int x= x+1;
Y a-t-il une raison pour laquelle les auteurs de la norme n'ont pas purement et simplement interdit cette écriture ?
Je comprends le comportement indéfini comme quelque chose dont l'écriture par le codeur est interdite mais que le compilateur n'a pas obligation de détecter. La raison est sans doute de ne pas trop compliquer l'écriture des compilateurs.
Accessoirement, y a-t-il des cas (pas trop tordus) où elle peut être utile ?
Tester un compilateur face à ce comportement indéfini ? Par exemple, si le compilateur émet un avertissement sur cette expression (ce que fait g++ par exemple), il n'est peut-être pas trop mauvais.
-- Richard
Bonjour,
Il me semble que l'expression suivante est autorisée (même si elle a
un comportement indéfini) :
int x= x+1;
Y a-t-il une raison pour laquelle les auteurs de la norme n'ont pas
purement et simplement interdit cette écriture ?
Je comprends le comportement indéfini comme quelque chose dont
l'écriture par le codeur est interdite mais que le compilateur n'a pas
obligation de détecter. La raison est sans doute de ne pas trop
compliquer l'écriture des compilateurs.
Accessoirement, y
a-t-il des cas (pas trop tordus) où elle peut être utile ?
Tester un compilateur face à ce comportement indéfini ? Par exemple, si
le compilateur émet un avertissement sur cette expression (ce que fait
g++ par exemple), il n'est peut-être pas trop mauvais.
Il me semble que l'expression suivante est autorisée (même si elle a un comportement indéfini) :
int x= x+1;
Y a-t-il une raison pour laquelle les auteurs de la norme n'ont pas purement et simplement interdit cette écriture ?
Je comprends le comportement indéfini comme quelque chose dont l'écriture par le codeur est interdite mais que le compilateur n'a pas obligation de détecter. La raison est sans doute de ne pas trop compliquer l'écriture des compilateurs.
Accessoirement, y a-t-il des cas (pas trop tordus) où elle peut être utile ?
Tester un compilateur face à ce comportement indéfini ? Par exemple, si le compilateur émet un avertissement sur cette expression (ce que fait g++ par exemple), il n'est peut-être pas trop mauvais.
-- Richard
Marc Boyer
Fabien LE LEZ a écrit :
Il me semble que l'expression suivante est autorisée (même si elle a un comportement indéfini) :
int x= x+1;
Y a-t-il une raison pour laquelle les auteurs de la norme n'ont pas purement et simplement interdit cette écriture ?
Peut être parce que le cas général est trop compliqué (voir indécidable): si on remplace l'expression par int x= f(); avec x une variable externe, et f qui fait appel à x.
Accessoirement, y a-t-il des cas (pas trop tordus) où elle peut être utile ?
Une étrangetée du genre: extern int x; int x=f();
int f(){ static first= true; if (first) { first= false; return 0; } else { x++; return x; } }
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangeureux que prendre un boulevard dans le sens légal. À qui la faute ?
Fabien LE LEZ <gramster@gramster.com> a écrit :
Il me semble que l'expression suivante est autorisée (même si elle a
un comportement indéfini) :
int x= x+1;
Y a-t-il une raison pour laquelle les auteurs de la norme n'ont pas
purement et simplement interdit cette écriture ?
Peut être parce que le cas général est trop compliqué
(voir indécidable):
si on remplace l'expression par
int x= f();
avec x une variable externe, et f qui fait appel à x.
Accessoirement, y
a-t-il des cas (pas trop tordus) où elle peut être utile ?
Une étrangetée du genre:
extern int x;
int x=f();
int f(){
static first= true;
if (first) {
first= false;
return 0;
} else {
x++;
return x;
}
}
Marc Boyer
--
À vélo, prendre une rue à contre-sens est moins dangeureux
que prendre un boulevard dans le sens légal. À qui la faute ?
Il me semble que l'expression suivante est autorisée (même si elle a un comportement indéfini) :
int x= x+1;
Y a-t-il une raison pour laquelle les auteurs de la norme n'ont pas purement et simplement interdit cette écriture ?
Peut être parce que le cas général est trop compliqué (voir indécidable): si on remplace l'expression par int x= f(); avec x une variable externe, et f qui fait appel à x.
Accessoirement, y a-t-il des cas (pas trop tordus) où elle peut être utile ?
Une étrangetée du genre: extern int x; int x=f();
int f(){ static first= true; if (first) { first= false; return 0; } else { x++; return x; } }
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangeureux que prendre un boulevard dans le sens légal. À qui la faute ?
Matthieu Moy
Marc Boyer writes:
Fabien LE LEZ a écrit :
Il me semble que l'expression suivante est autorisée (même si elle a un comportement indéfini) :
int x= x+1;
Y a-t-il une raison pour laquelle les auteurs de la norme n'ont pas purement et simplement interdit cette écriture ?
Peut être parce que le cas général est trop compliqué (voir indécidable):
Oui, enfin, il y a pas mal de langages (y compris si mes souvenirs sont bons celui pour lequel j'ai écrit un compilateur en un mois en deuxième année d'école d'ingé, donc, un pas trop compliqué) ou la déclaration prends effet au « ; » suivant. C'est une règle hyper simple, et très efficace.
-- Matthieu
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
Fabien LE LEZ <gramster@gramster.com> a écrit :
Il me semble que l'expression suivante est autorisée (même si elle a
un comportement indéfini) :
int x= x+1;
Y a-t-il une raison pour laquelle les auteurs de la norme n'ont pas
purement et simplement interdit cette écriture ?
Peut être parce que le cas général est trop compliqué
(voir indécidable):
Oui, enfin, il y a pas mal de langages (y compris si mes souvenirs
sont bons celui pour lequel j'ai écrit un compilateur en un mois en
deuxième année d'école d'ingé, donc, un pas trop compliqué) ou la
déclaration prends effet au « ; » suivant. C'est une règle hyper
simple, et très efficace.
Il me semble que l'expression suivante est autorisée (même si elle a un comportement indéfini) :
int x= x+1;
Y a-t-il une raison pour laquelle les auteurs de la norme n'ont pas purement et simplement interdit cette écriture ?
Peut être parce que le cas général est trop compliqué (voir indécidable):
Oui, enfin, il y a pas mal de langages (y compris si mes souvenirs sont bons celui pour lequel j'ai écrit un compilateur en un mois en deuxième année d'école d'ingé, donc, un pas trop compliqué) ou la déclaration prends effet au « ; » suivant. C'est une règle hyper simple, et très efficace.
-- Matthieu
Stan
"Matthieu Moy" a écrit dans le message de news:
Marc Boyer writes:
Oui, enfin, il y a pas mal de langages (y compris si mes souvenirs sont bons celui pour lequel j'ai écrit un compilateur en un mois en deuxième année d'école d'ingé, donc, un pas trop compliqué) ou la déclaration prends effet au « ; » suivant. C'est une règle hyper simple, et très efficace.
Oui, et alors, dans le cas mentionné, ça se traduit comment ?
-- -Stan
"Matthieu Moy" <MatthieuNOSPAM.Moy@imag.fr.invalid> a écrit dans le message
de news: vpqoe67j7pn.fsf@ecrins.imag.fr...
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
Oui, enfin, il y a pas mal de langages (y compris si mes souvenirs
sont bons celui pour lequel j'ai écrit un compilateur en un mois en
deuxième année d'école d'ingé, donc, un pas trop compliqué) ou la
déclaration prends effet au « ; » suivant. C'est une règle hyper
simple, et très efficace.
Oui, et alors, dans le cas mentionné, ça se traduit comment ?
Oui, enfin, il y a pas mal de langages (y compris si mes souvenirs sont bons celui pour lequel j'ai écrit un compilateur en un mois en deuxième année d'école d'ingé, donc, un pas trop compliqué) ou la déclaration prends effet au « ; » suivant. C'est une règle hyper simple, et très efficace.
Oui, et alors, dans le cas mentionné, ça se traduit comment ?
-- -Stan
Matthieu Moy
"Stan" writes:
Oui, et alors, dans le cas mentionné, ça se traduit comment ?
Pour « int x = x + 1; », le « x » n'est pas encore déclaré quand tu parses « x + 1 », donc, tu as la même erreur que dans
int main () { int y = x + 1; }
pour la variable x.
-- Matthieu
"Stan" <none@none.fr> writes:
Oui, et alors, dans le cas mentionné, ça se traduit comment ?
Pour « int x = x + 1; », le « x » n'est pas encore déclaré quand tu
parses « x + 1 », donc, tu as la même erreur que dans
Oui, et alors, dans le cas mentionné, ça se traduit comment ?
Pour « int x = x + 1; », le « x » n'est pas encore déclaré quand tu parses « x + 1 », donc, tu as la même erreur que dans
int main () { int y = x + 1; }
pour la variable x.
-- Matthieu
Marc Boyer
Matthieu Moy a écrit :
"Stan" writes:
Oui, et alors, dans le cas mentionné, ça se traduit comment ?
Pour « int x = x + 1; », le « x » n'est pas encore déclaré quand tu parses « x + 1 », donc, tu as la même erreur que dans
int main () { int y = x + 1; }
pour la variable x.
Tu n'as pas compris ma remarque: en effet, pour l'expression int x= x+1; il n'est pas difficile d'émettre un diagnostic. Mais est-ce une erreur si fréquente ?
Mais quand je parle de cas général, c'est le cas int x=f(); avec f dépendant de x.
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangeureux que prendre un boulevard dans le sens légal. À qui la faute ?
Matthieu Moy <MatthieuNOSPAM.Moy@imag.fr.invalid> a écrit :
"Stan" <none@none.fr> writes:
Oui, et alors, dans le cas mentionné, ça se traduit comment ?
Pour « int x = x + 1; », le « x » n'est pas encore déclaré quand tu
parses « x + 1 », donc, tu as la même erreur que dans
int main () {
int y = x + 1;
}
pour la variable x.
Tu n'as pas compris ma remarque: en effet, pour l'expression
int x= x+1;
il n'est pas difficile d'émettre un diagnostic. Mais est-ce
une erreur si fréquente ?
Mais quand je parle de cas général, c'est le cas
int x=f();
avec f dépendant de x.
Marc Boyer
--
À vélo, prendre une rue à contre-sens est moins dangeureux
que prendre un boulevard dans le sens légal. À qui la faute ?
Oui, et alors, dans le cas mentionné, ça se traduit comment ?
Pour « int x = x + 1; », le « x » n'est pas encore déclaré quand tu parses « x + 1 », donc, tu as la même erreur que dans
int main () { int y = x + 1; }
pour la variable x.
Tu n'as pas compris ma remarque: en effet, pour l'expression int x= x+1; il n'est pas difficile d'émettre un diagnostic. Mais est-ce une erreur si fréquente ?
Mais quand je parle de cas général, c'est le cas int x=f(); avec f dépendant de x.
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangeureux que prendre un boulevard dans le sens légal. À qui la faute ?
Matthieu Moy
Marc Boyer writes:
Tu n'as pas compris ma remarque: en effet, pour l'expression int x= x+1;
Si, j'ai bien compris ta remarque. Mais le fait qu'il existe un cas vraiment tordu justifie-t-il qu'on autorise à écrire des conneries alors qu'il y a une règle simple à comprendre et à implementer qui évite les bétises les plus grosses, et les plus courrantes (j'ai infiniment plus de variables locales que de variables globales dans mes programmes) ?
-- Matthieu
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
Tu n'as pas compris ma remarque: en effet, pour l'expression
int x= x+1;
Si, j'ai bien compris ta remarque. Mais le fait qu'il existe un cas
vraiment tordu justifie-t-il qu'on autorise à écrire des conneries
alors qu'il y a une règle simple à comprendre et à implementer qui
évite les bétises les plus grosses, et les plus courrantes (j'ai
infiniment plus de variables locales que de variables globales dans
mes programmes) ?
Tu n'as pas compris ma remarque: en effet, pour l'expression int x= x+1;
Si, j'ai bien compris ta remarque. Mais le fait qu'il existe un cas vraiment tordu justifie-t-il qu'on autorise à écrire des conneries alors qu'il y a une règle simple à comprendre et à implementer qui évite les bétises les plus grosses, et les plus courrantes (j'ai infiniment plus de variables locales que de variables globales dans mes programmes) ?
-- Matthieu
Fabien LE LEZ
On Mon, 03 Oct 2005 12:39:45 +0200, Matthieu Moy :
Mais le fait qu'il existe un cas vraiment tordu justifie-t-il qu'on autorise à écrire des conneries
Dans l'ensemble, le C++ est très permissif.
Si x et f() sont définis dans des modules différents, il est effectivement impossible d'avoir une erreur de compilation.
Donc, après lecture du présent thread, je comprends que ce soit seulement un warning (sur les bons compilos) et pas une erreur définie par le standard.
On Mon, 03 Oct 2005 12:39:45 +0200, Matthieu Moy
<MatthieuNOSPAM.Moy@imag.fr.invalid>:
Mais le fait qu'il existe un cas
vraiment tordu justifie-t-il qu'on autorise à écrire des conneries
Dans l'ensemble, le C++ est très permissif.
Si x et f() sont définis dans des modules différents, il est
effectivement impossible d'avoir une erreur de compilation.
Donc, après lecture du présent thread, je comprends que ce soit
seulement un warning (sur les bons compilos) et pas une erreur définie
par le standard.
On Mon, 03 Oct 2005 12:39:45 +0200, Matthieu Moy :
Mais le fait qu'il existe un cas vraiment tordu justifie-t-il qu'on autorise à écrire des conneries
Dans l'ensemble, le C++ est très permissif.
Si x et f() sont définis dans des modules différents, il est effectivement impossible d'avoir une erreur de compilation.
Donc, après lecture du présent thread, je comprends que ce soit seulement un warning (sur les bons compilos) et pas une erreur définie par le standard.
Marc Boyer
Matthieu Moy a écrit :
Marc Boyer writes:
Tu n'as pas compris ma remarque: en effet, pour l'expression int x= x+1;
Si, j'ai bien compris ta remarque. Mais le fait qu'il existe un cas vraiment tordu justifie-t-il qu'on autorise à écrire des conneries alors qu'il y a une règle simple à comprendre et à implementer qui évite les bétises les plus grosses, et les plus courrantes (j'ai infiniment plus de variables locales que de variables globales dans mes programmes) ?
Ben, propose un ammendement à la norme si tu trouves ça simple à exprimer, à comprendre et à implémenter.
Mais bon, je te refais l'exemple en variable locale: int x=f(x); est-ce une contruction à prohiber ? Je n'en sais rien.
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangeureux que prendre un boulevard dans le sens légal. À qui la faute ?
Matthieu Moy <MatthieuNOSPAM.Moy@imag.fr.invalid> a écrit :
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
Tu n'as pas compris ma remarque: en effet, pour l'expression
int x= x+1;
Si, j'ai bien compris ta remarque. Mais le fait qu'il existe un cas
vraiment tordu justifie-t-il qu'on autorise à écrire des conneries
alors qu'il y a une règle simple à comprendre et à implementer qui
évite les bétises les plus grosses, et les plus courrantes (j'ai
infiniment plus de variables locales que de variables globales dans
mes programmes) ?
Ben, propose un ammendement à la norme si tu trouves ça
simple à exprimer, à comprendre et à implémenter.
Mais bon, je te refais l'exemple en variable locale:
int x=f(x);
est-ce une contruction à prohiber ? Je n'en sais rien.
Marc Boyer
--
À vélo, prendre une rue à contre-sens est moins dangeureux
que prendre un boulevard dans le sens légal. À qui la faute ?
Tu n'as pas compris ma remarque: en effet, pour l'expression int x= x+1;
Si, j'ai bien compris ta remarque. Mais le fait qu'il existe un cas vraiment tordu justifie-t-il qu'on autorise à écrire des conneries alors qu'il y a une règle simple à comprendre et à implementer qui évite les bétises les plus grosses, et les plus courrantes (j'ai infiniment plus de variables locales que de variables globales dans mes programmes) ?
Ben, propose un ammendement à la norme si tu trouves ça simple à exprimer, à comprendre et à implémenter.
Mais bon, je te refais l'exemple en variable locale: int x=f(x); est-ce une contruction à prohiber ? Je n'en sais rien.
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangeureux que prendre un boulevard dans le sens légal. À qui la faute ?
Matthieu Moy
Marc Boyer writes:
Ben, propose un ammendement à la norme si tu trouves ça simple à exprimer, à comprendre et à implémenter.
Encore une fois, c'est comme ça que c'est fait dans de nombreux langages. Ma proposition n'a rien d'un scoop, hein...
Mais bon, je te refais l'exemple en variable locale: int x=f(x); est-ce une contruction à prohiber ? Je n'en sais rien.
Si tu considère que la déclaration n'est effective qu'à la fin de l'instruction, le f(x) est refusé, car x n'est pas encore déclaré à ce moment là. Je ne vois d'ailleurs pas en quoi la fonction « f » est si différente que la fonction « + », hormis la syntaxe.
-- Matthieu
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
Ben, propose un ammendement à la norme si tu trouves ça
simple à exprimer, à comprendre et à implémenter.
Encore une fois, c'est comme ça que c'est fait dans de nombreux
langages. Ma proposition n'a rien d'un scoop, hein...
Mais bon, je te refais l'exemple en variable locale:
int x=f(x);
est-ce une contruction à prohiber ? Je n'en sais rien.
Si tu considère que la déclaration n'est effective qu'à la fin de
l'instruction, le f(x) est refusé, car x n'est pas encore déclaré à ce
moment là. Je ne vois d'ailleurs pas en quoi la fonction « f » est si
différente que la fonction « + », hormis la syntaxe.
Ben, propose un ammendement à la norme si tu trouves ça simple à exprimer, à comprendre et à implémenter.
Encore une fois, c'est comme ça que c'est fait dans de nombreux langages. Ma proposition n'a rien d'un scoop, hein...
Mais bon, je te refais l'exemple en variable locale: int x=f(x); est-ce une contruction à prohiber ? Je n'en sais rien.
Si tu considère que la déclaration n'est effective qu'à la fin de l'instruction, le f(x) est refusé, car x n'est pas encore déclaré à ce moment là. Je ne vois d'ailleurs pas en quoi la fonction « f » est si différente que la fonction « + », hormis la syntaxe.
