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 ?
Bonjour, Il me semble que l'expression suivante est autorisée (même si elle a un comportement indéfini) : int x= x+1;
Pour moi ça devrait donner le même résultat que:
int x; x = x + 1;
Par contre je ne vois pas trop l'intérêt de faire ça.
A la limite: int x = x * 2; pourrait garantir que x est pair.
Rien ne garanti que la valeur "non initialisee" ne trappe pas.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
JBB <merci@pasdespam.fr> writes:
Fabien LE LEZ wrote:
Bonjour,
Il me semble que l'expression suivante est autorisée (même si elle a
un comportement indéfini) :
int x= x+1;
Pour moi ça devrait donner le même résultat que:
int x;
x = x + 1;
Par contre je ne vois pas trop l'intérêt de faire ça.
A la limite: int x = x * 2;
pourrait garantir que x est pair.
Rien ne garanti que la valeur "non initialisee" ne trappe pas.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org
Bonjour, Il me semble que l'expression suivante est autorisée (même si elle a un comportement indéfini) : int x= x+1;
Pour moi ça devrait donner le même résultat que:
int x; x = x + 1;
Par contre je ne vois pas trop l'intérêt de faire ça.
A la limite: int x = x * 2; pourrait garantir que x est pair.
Rien ne garanti que la valeur "non initialisee" ne trappe pas.
A+
-- Jean-Marc FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html Site de usenet-fr: http://www.usenet-fr.news.eu.org
Gabriel Dos Reis
Matthieu Moy writes:
| 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...
Si, elle témoigne d'une ignorance du problème doublée d'un refus irraisooné d'écouter ceux qui essaient de te l'expliquer, triplé d'un naiveté désarmante.
| 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...
Si, elle témoigne d'une ignorance du problème doublée d'un refus
irraisooné d'écouter ceux qui essaient de te l'expliquer, triplé d'un
naiveté désarmante.
| 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...
Si, elle témoigne d'une ignorance du problème doublée d'un refus irraisooné d'écouter ceux qui essaient de te l'expliquer, triplé d'un naiveté désarmante.
Rien ne garanti que la valeur "non initialisee" ne trappe pas.
Qu'appelles-tu « trapper » ? lever une erreur quand on y accède ?
-- Matthieu
Marc Boyer
Le 03-10-2005, Matthieu Moy a écrit :
Marc Boyer writes:
Après, dans le cas général, peut-il etre utile d'utiliser une construction de la forme int x= f(x); ma réponse est 'je ne sais pas'.
Vu le nombre d'utilisations potentielles (je ne me souviens pas avoir jamais eu besoin de ça, même si ma carrière de programmeur n'est encore pas très longue), et la difficulté de contourner (ecrire « int x; x = f(x); »), si c'était moi qui devais choisir, je n'hésiterais pas longtemps.
Je crois que c'est Jean-Marc qui nous mets sur la piste de la solution: il s'agit peut-etre d'un constructeur (ce qui interdit la construction en deux temps), et il peut avoir besoin de l'adresse de la variable (pour modifier this). Bon, je n'ai jamais encore joué à modifier this, donc, je ne vais pas avoir beaucoup plus d'info à donner sur le pourquoi on l'utilise.
Tu peux très bien considérer que tu traites d'abord les déclarations de type et ensuite les initialisations, et que ton code est équivalent à
int x; int y; x = f(y);
Ça serait sans doute très bête, mais pas beaucoup plus que « int x > x + 1; ».
Mais je pense que ce serait un changement bien plus important dans le langage.
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangeureux que prendre un boulevard dans le sens légal. À qui la faute ?
Le 03-10-2005, Matthieu Moy <MatthieuNOSPAM.Moy@imag.fr.invalid> a écrit :
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
Après, dans le cas général, peut-il etre utile d'utiliser une
construction de la forme
int x= f(x);
ma réponse est 'je ne sais pas'.
Vu le nombre d'utilisations potentielles (je ne me souviens pas avoir
jamais eu besoin de ça, même si ma carrière de programmeur n'est
encore pas très longue), et la difficulté de contourner (ecrire « int
x; x = f(x); »), si c'était moi qui devais choisir, je n'hésiterais
pas longtemps.
Je crois que c'est Jean-Marc qui nous mets sur la piste
de la solution: il s'agit peut-etre d'un constructeur
(ce qui interdit la construction en deux temps), et
il peut avoir besoin de l'adresse de la variable
(pour modifier this).
Bon, je n'ai jamais encore joué à modifier this,
donc, je ne vais pas avoir beaucoup plus d'info à donner
sur le pourquoi on l'utilise.
Tu peux très bien considérer que tu traites d'abord les déclarations
de type et ensuite les initialisations, et que ton code est équivalent
à
int x;
int y;
x = f(y);
Ça serait sans doute très bête, mais pas beaucoup plus que « int x > x + 1; ».
Mais je pense que ce serait un changement bien plus important
dans le langage.
Marc Boyer
--
À vélo, prendre une rue à contre-sens est moins dangeureux
que prendre un boulevard dans le sens légal. À qui la faute ?
Après, dans le cas général, peut-il etre utile d'utiliser une construction de la forme int x= f(x); ma réponse est 'je ne sais pas'.
Vu le nombre d'utilisations potentielles (je ne me souviens pas avoir jamais eu besoin de ça, même si ma carrière de programmeur n'est encore pas très longue), et la difficulté de contourner (ecrire « int x; x = f(x); »), si c'était moi qui devais choisir, je n'hésiterais pas longtemps.
Je crois que c'est Jean-Marc qui nous mets sur la piste de la solution: il s'agit peut-etre d'un constructeur (ce qui interdit la construction en deux temps), et il peut avoir besoin de l'adresse de la variable (pour modifier this). Bon, je n'ai jamais encore joué à modifier this, donc, je ne vais pas avoir beaucoup plus d'info à donner sur le pourquoi on l'utilise.
Tu peux très bien considérer que tu traites d'abord les déclarations de type et ensuite les initialisations, et que ton code est équivalent à
int x; int y; x = f(y);
Ça serait sans doute très bête, mais pas beaucoup plus que « int x > x + 1; ».
Mais je pense que ce serait un changement bien plus important dans le langage.
Marc Boyer -- À vélo, prendre une rue à contre-sens est moins dangeureux que prendre un boulevard dans le sens légal. À qui la faute ?
Gabriel Dos Reis
Jean-Marc Bourguet writes:
| Matthieu Moy writes: | | > Marc Boyer writes: | > | > > Matthieu Moy a écrit : | > >> 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... | > > | > > Oui, mais est-ce une restriction utile ? | > | > Je te retourne la question : est-ce utile d'autoriser cette | > construction ? | | Je parie qu'on peut trouver une utilisation legitime, du moins si on | prend l'adresse de la variable plutot que sa valeur (qui non | initialisee pourrait trapper).
Ceci est classique
void* p = &p;
ansi que
circular_buffer buffer = buffer;
-- Gaby
Jean-Marc Bourguet <jm@bourguet.org> writes:
| Matthieu Moy <MatthieuNOSPAM.Moy@imag.fr.invalid> writes:
|
| > Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
| >
| > > Matthieu Moy <MatthieuNOSPAM.Moy@imag.fr.invalid> a écrit :
| > >> 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...
| > >
| > > Oui, mais est-ce une restriction utile ?
| >
| > Je te retourne la question : est-ce utile d'autoriser cette
| > construction ?
|
| Je parie qu'on peut trouver une utilisation legitime, du moins si on
| prend l'adresse de la variable plutot que sa valeur (qui non
| initialisee pourrait trapper).
| Matthieu Moy writes: | | > Marc Boyer writes: | > | > > Matthieu Moy a écrit : | > >> 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... | > > | > > Oui, mais est-ce une restriction utile ? | > | > Je te retourne la question : est-ce utile d'autoriser cette | > construction ? | | Je parie qu'on peut trouver une utilisation legitime, du moins si on | prend l'adresse de la variable plutot que sa valeur (qui non | initialisee pourrait trapper).
Ceci est classique
void* p = &p;
ansi que
circular_buffer buffer = buffer;
-- Gaby
Gabriel Dos Reis
Matthieu Moy writes:
| Jean-Marc Bourguet writes: | | > Rien ne garanti que la valeur "non initialisee" ne trappe pas. | | Qu'appelles-tu « trapper » ? lever une erreur quand on y accède ?
| Jean-Marc Bourguet <jm@bourguet.org> writes:
|
| > Rien ne garanti que la valeur "non initialisee" ne trappe pas.
|
| Qu'appelles-tu « trapper » ? lever une erreur quand on y accède ?
| Jean-Marc Bourguet writes: | | > Rien ne garanti que la valeur "non initialisee" ne trappe pas. | | Qu'appelles-tu « trapper » ? lever une erreur quand on y accède ?
Par exemple.
-- Gaby
Gabriel Dos Reis
Marc Boyer writes:
| Le 03-10-2005, Matthieu Moy a écrit : | > Marc Boyer writes: | >> Après, dans le cas général, peut-il etre utile d'utiliser une | >> construction de la forme | >> int x= f(x); | >> ma réponse est 'je ne sais pas'. | > | > Vu le nombre d'utilisations potentielles (je ne me souviens pas avoir | > jamais eu besoin de ça, même si ma carrière de programmeur n'est | > encore pas très longue), et la difficulté de contourner (ecrire « int | > x; x = f(x); »), si c'était moi qui devais choisir, je n'hésiterais | > pas longtemps. | | Je crois que c'est Jean-Marc qui nous mets sur la piste | de la solution: il s'agit peut-etre d'un constructeur | (ce qui interdit la construction en deux temps), et | il peut avoir besoin de l'adresse de la variable | (pour modifier this).
On ne peut pas modifier la valeur de this. Mais regarde l'exemple que j'ai posté.
-- Gaby
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
| Le 03-10-2005, Matthieu Moy <MatthieuNOSPAM.Moy@imag.fr.invalid> a écrit :
| > Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
| >> Après, dans le cas général, peut-il etre utile d'utiliser une
| >> construction de la forme
| >> int x= f(x);
| >> ma réponse est 'je ne sais pas'.
| >
| > Vu le nombre d'utilisations potentielles (je ne me souviens pas avoir
| > jamais eu besoin de ça, même si ma carrière de programmeur n'est
| > encore pas très longue), et la difficulté de contourner (ecrire « int
| > x; x = f(x); »), si c'était moi qui devais choisir, je n'hésiterais
| > pas longtemps.
|
| Je crois que c'est Jean-Marc qui nous mets sur la piste
| de la solution: il s'agit peut-etre d'un constructeur
| (ce qui interdit la construction en deux temps), et
| il peut avoir besoin de l'adresse de la variable
| (pour modifier this).
On ne peut pas modifier la valeur de this. Mais regarde l'exemple que
j'ai posté.
| Le 03-10-2005, Matthieu Moy a écrit : | > Marc Boyer writes: | >> Après, dans le cas général, peut-il etre utile d'utiliser une | >> construction de la forme | >> int x= f(x); | >> ma réponse est 'je ne sais pas'. | > | > Vu le nombre d'utilisations potentielles (je ne me souviens pas avoir | > jamais eu besoin de ça, même si ma carrière de programmeur n'est | > encore pas très longue), et la difficulté de contourner (ecrire « int | > x; x = f(x); »), si c'était moi qui devais choisir, je n'hésiterais | > pas longtemps. | | Je crois que c'est Jean-Marc qui nous mets sur la piste | de la solution: il s'agit peut-etre d'un constructeur | (ce qui interdit la construction en deux temps), et | il peut avoir besoin de l'adresse de la variable | (pour modifier this).
On ne peut pas modifier la valeur de this. Mais regarde l'exemple que j'ai posté.
-- Gaby
Matthieu Moy
Marc Boyer writes:
Je crois que c'est Jean-Marc qui nous mets sur la piste de la solution: il s'agit peut-etre d'un constructeur (ce qui interdit la construction en deux temps), et il peut avoir besoin de l'adresse de la variable (pour modifier this).
Ca peut être une utilisation trouvée a postériori, mais la décision d'accepter cette construction date de bien avant la notion de constructeur.
-- Matthieu
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
Je crois que c'est Jean-Marc qui nous mets sur la piste
de la solution: il s'agit peut-etre d'un constructeur
(ce qui interdit la construction en deux temps), et
il peut avoir besoin de l'adresse de la variable
(pour modifier this).
Ca peut être une utilisation trouvée a postériori, mais la décision
d'accepter cette construction date de bien avant la notion de
constructeur.
Je crois que c'est Jean-Marc qui nous mets sur la piste de la solution: il s'agit peut-etre d'un constructeur (ce qui interdit la construction en deux temps), et il peut avoir besoin de l'adresse de la variable (pour modifier this).
Ca peut être une utilisation trouvée a postériori, mais la décision d'accepter cette construction date de bien avant la notion de constructeur.
-- Matthieu
Gabriel Dos Reis
Matthieu Moy writes:
| Marc Boyer writes: | | > Je crois que c'est Jean-Marc qui nous mets sur la piste | > de la solution: il s'agit peut-etre d'un constructeur | > (ce qui interdit la construction en deux temps), et | > il peut avoir besoin de l'adresse de la variable | > (pour modifier this). | | Ca peut être une utilisation trouvée a postériori,
Pourquoi ?
| mais la décision | d'accepter cette construction date de bien avant la notion de | constructeur.
| Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
|
| > Je crois que c'est Jean-Marc qui nous mets sur la piste
| > de la solution: il s'agit peut-etre d'un constructeur
| > (ce qui interdit la construction en deux temps), et
| > il peut avoir besoin de l'adresse de la variable
| > (pour modifier this).
|
| Ca peut être une utilisation trouvée a postériori,
Pourquoi ?
| mais la décision
| d'accepter cette construction date de bien avant la notion de
| constructeur.
| Marc Boyer writes: | | > Je crois que c'est Jean-Marc qui nous mets sur la piste | > de la solution: il s'agit peut-etre d'un constructeur | > (ce qui interdit la construction en deux temps), et | > il peut avoir besoin de l'adresse de la variable | > (pour modifier this). | | Ca peut être une utilisation trouvée a postériori,
Pourquoi ?
| mais la décision | d'accepter cette construction date de bien avant la notion de | constructeur.
