J'ai perdu des heures à chasser un bug stupide du style
std::string bad='x'+"yz"; // donne tout sauf "xyz"
("yz" était en fait le résultat d'une conversion genre class::operator
char*() ...)
Existe-t-il une combine pour empêcher C++ de compiler des bêtises à la C ?
J'ai essayé de définir un operator+(const char lhs, const char* rhs) qui
râlerait, mais VC 7.1 dit qu'une des deux opérandes doit être une classe...
--
Philippe Guglielmetti - www.dynabits.com
J'ai perdu des heures à chasser un bug stupide du style std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le mettre dans une std::string. C'est un char, soit une valeur comprise entre 0 et 255. Au mieux il sera peut être interprété par le compilo comme étant la string à l'adresse 0x120.
Il faut écrire std::string bad="x"+"yz";
Pour obtenir "xyz"
Bonjour,
J'ai perdu des heures à chasser un bug stupide du style
std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le
mettre dans une std::string. C'est un char, soit une valeur comprise
entre 0 et 255. Au mieux il sera peut être interprété par le compilo
comme étant la string à l'adresse 0x120.
J'ai perdu des heures à chasser un bug stupide du style std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le mettre dans une std::string. C'est un char, soit une valeur comprise entre 0 et 255. Au mieux il sera peut être interprété par le compilo comme étant la string à l'adresse 0x120.
Il faut écrire std::string bad="x"+"yz";
Pour obtenir "xyz"
Christophe de VIENNE
Bonjour,
J'ai perdu des heures à chasser un bug stupide du style std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le
"x" non plus, c'est un char[2]
mettre dans une std::string. C'est un char, soit une valeur comprise entre 0 et 255. Au mieux il sera peut être interprété par le compilo comme étant la string à l'adresse 0x120.
Il faut écrire std::string bad="x"+"yz";
Pour obtenir "xyz"
Non, là tu additionnes des pointeurs. Si tu veux que l'opérateur + de std::string soit utilisé et obtenir une concaténation, il faut écrire :
std::string bad = std::string("x") + "yz";
A+
Christophe
-- Christophe de Vienne
Bonjour,
J'ai perdu des heures à chasser un bug stupide du style
std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le
"x" non plus, c'est un char[2]
mettre dans une std::string. C'est un char, soit une valeur comprise
entre 0 et 255. Au mieux il sera peut être interprété par le compilo
comme étant la string à l'adresse 0x120.
Il faut écrire
std::string bad="x"+"yz";
Pour obtenir "xyz"
Non, là tu additionnes des pointeurs. Si tu veux que l'opérateur + de
std::string soit utilisé et obtenir une concaténation, il faut écrire :
J'ai perdu des heures à chasser un bug stupide du style std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le
"x" non plus, c'est un char[2]
mettre dans une std::string. C'est un char, soit une valeur comprise entre 0 et 255. Au mieux il sera peut être interprété par le compilo comme étant la string à l'adresse 0x120.
Il faut écrire std::string bad="x"+"yz";
Pour obtenir "xyz"
Non, là tu additionnes des pointeurs. Si tu veux que l'opérateur + de std::string soit utilisé et obtenir une concaténation, il faut écrire :
std::string bad = std::string("x") + "yz";
A+
Christophe
-- Christophe de Vienne
Fabien LE LEZ
On Thu, 19 Aug 2004 18:06:23 +0200, "Alni" :
'x' n'est pas une string.
Il s'en doute. Mais justement, le problème est de forcer le compilo à râler dans de tels cas.
Tu ne peux pas l'additionner avec "yz" pour le mettre dans une std::string. C'est un char, soit une valeur comprise entre 0 et 255. Au mieux il sera peut être interprété par le compilo comme étant la string à l'adresse 0x120.
Non. 'x'+"yz" est ici égal à "xy"+'x', soit "xy"+0x78 -- 120 caractères après le début de la chaîne. Ce qui n'est bien sûr pas valide, en plus de ne pas donner le résultat escompté ;-)
Il faut écrire std::string bad="x"+"yz";
Ça marche, ça, tu crois ? ;-)
-- ;-)
On Thu, 19 Aug 2004 18:06:23 +0200, "Alni" <nospam@nowhere.com>:
'x' n'est pas une string.
Il s'en doute. Mais justement, le problème est de forcer le compilo à
râler dans de tels cas.
Tu ne peux pas l'additionner avec "yz" pour le
mettre dans une std::string. C'est un char, soit une valeur comprise
entre 0 et 255. Au mieux il sera peut être interprété par le compilo
comme étant la string à l'adresse 0x120.
Non. 'x'+"yz" est ici égal à "xy"+'x', soit "xy"+0x78 -- 120
caractères après le début de la chaîne. Ce qui n'est bien sûr pas
valide, en plus de ne pas donner le résultat escompté ;-)
Il s'en doute. Mais justement, le problème est de forcer le compilo à râler dans de tels cas.
Tu ne peux pas l'additionner avec "yz" pour le mettre dans une std::string. C'est un char, soit une valeur comprise entre 0 et 255. Au mieux il sera peut être interprété par le compilo comme étant la string à l'adresse 0x120.
Non. 'x'+"yz" est ici égal à "xy"+'x', soit "xy"+0x78 -- 120 caractères après le début de la chaîne. Ce qui n'est bien sûr pas valide, en plus de ne pas donner le résultat escompté ;-)
Il faut écrire std::string bad="x"+"yz";
Ça marche, ça, tu crois ? ;-)
-- ;-)
Fabien LE LEZ
On Thu, 19 Aug 2004 18:17:25 +0200, "Jean-Noël Mégoz" :
Ça m'étonne, d'ailleurs, qu'une telle instruction ne provoque pas au moins un warning...
Ben oui, pointeur+entier, c'est la même chose que pointeur[entier], ou entier[pointeur], ou entier+pointeur.
-- ;-)
On Thu, 19 Aug 2004 18:17:25 +0200, "Jean-Noël Mégoz"
<nospam_jnmegoz@infonie.fr>:
Ça m'étonne, d'ailleurs, qu'une telle
instruction ne provoque pas au moins un warning...
Ben oui, pointeur+entier, c'est la même chose que pointeur[entier], ou
entier[pointeur], ou entier+pointeur.
On Thu, 19 Aug 2004 18:17:25 +0200, "Jean-Noël Mégoz" :
Ça m'étonne, d'ailleurs, qu'une telle instruction ne provoque pas au moins un warning...
Ben oui, pointeur+entier, c'est la même chose que pointeur[entier], ou entier[pointeur], ou entier+pointeur.
-- ;-)
Jean-Noël Mégoz
"Alni" a écrit dans le message de news:cg2j5u$ukj$
Bonjour,
J'ai perdu des heures à chasser un bug stupide du style std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le mettre dans une std::string. C'est un char, soit une valeur comprise entre 0 et 255. Au mieux il sera peut être interprété par le compilo comme étant la string à l'adresse 0x120.
Il faut écrire std::string bad="x"+"yz";
Pour obtenir "xyz"
L'auteur du post initial le sait bien ! Ce qu'il demande, c'est s'il y a
moyen que le compilo détecte ce genre de bug. Pour ma part, je n'en sais rien ! Ça m'étonne, d'ailleurs, qu'une telle instruction ne provoque pas au moins un warning...
"Alni" <nospam@nowhere.com> a écrit dans le message de
news:cg2j5u$ukj$1@news-reader2.wanadoo.fr...
Bonjour,
J'ai perdu des heures à chasser un bug stupide du style
std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le
mettre dans une std::string. C'est un char, soit une valeur comprise
entre 0 et 255. Au mieux il sera peut être interprété par le compilo
comme étant la string à l'adresse 0x120.
Il faut écrire
std::string bad="x"+"yz";
Pour obtenir "xyz"
L'auteur du post initial le sait bien ! Ce qu'il demande, c'est s'il y a
moyen que le compilo détecte ce genre de bug.
Pour ma part, je n'en sais rien ! Ça m'étonne, d'ailleurs, qu'une telle
instruction ne provoque pas au moins un warning...
"Alni" a écrit dans le message de news:cg2j5u$ukj$
Bonjour,
J'ai perdu des heures à chasser un bug stupide du style std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le mettre dans une std::string. C'est un char, soit une valeur comprise entre 0 et 255. Au mieux il sera peut être interprété par le compilo comme étant la string à l'adresse 0x120.
Il faut écrire std::string bad="x"+"yz";
Pour obtenir "xyz"
L'auteur du post initial le sait bien ! Ce qu'il demande, c'est s'il y a
moyen que le compilo détecte ce genre de bug. Pour ma part, je n'en sais rien ! Ça m'étonne, d'ailleurs, qu'une telle instruction ne provoque pas au moins un warning...
Fabien LE LEZ
On Thu, 19 Aug 2004 18:14:49 +0200, Christophe de VIENNE :
std::string bad = std::string("x") + "yz";
En fait, non : il faut écrire
std::string good= std::string("x") + "yz";
puisque cette fois, ça marche.
-- ;-)
On Thu, 19 Aug 2004 18:14:49 +0200, Christophe de VIENNE
<cdevienne@alphacent.com>:
L'auteur du post initial le sait bien ! Ce qu'il demande, c'est s'il y a moyen que le compilo détecte ce genre de bug. OK...pas compris...
Pour ma part, je n'en sais rien ! Ça m'étonne, d'ailleurs, qu'une telle instruction ne provoque pas au moins un warning...
Mouais, effectivement, je viens de tester en VC++ 6, pas de warning. Même pas un assert à l'execution.
drkm
"Alni" writes:
J'ai perdu des heures à chasser un bug stupide du style std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le mettre dans une std::string. C'est un char, soit une valeur comprise entre 0 et 255. Au mieux il sera peut être interprété par le compilo comme étant la string à l'adresse 0x120.
Si je ne me trompe pas, le résultat est un char const *, pointant à l'adresse de "yz" augmentée de la valeur entière 'x'.
Il faut écrire std::string bad="x"+"yz";
Non.
Pour obtenir "xyz"
Non, ni pour obtenir "xyz", ni pour rien, d'ailleurs.
--drkm, en recherche d'un stage : http://www.fgeorges.org/ipl/stage.html
"Alni" <nospam@nowhere.com> writes:
J'ai perdu des heures à chasser un bug stupide du style
std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour
le mettre dans une std::string. C'est un char, soit une valeur
comprise entre 0 et 255. Au mieux il sera peut être interprété par le
compilo comme étant la string à l'adresse 0x120.
Si je ne me trompe pas, le résultat est un char const *, pointant à
l'adresse de "yz" augmentée de la valeur entière 'x'.
Il faut écrire
std::string bad="x"+"yz";
Non.
Pour obtenir "xyz"
Non, ni pour obtenir "xyz", ni pour rien, d'ailleurs.
J'ai perdu des heures à chasser un bug stupide du style std::string bad='x'+"yz"; // donne tout sauf "xyz"
'x' n'est pas une string. Tu ne peux pas l'additionner avec "yz" pour le mettre dans une std::string. C'est un char, soit une valeur comprise entre 0 et 255. Au mieux il sera peut être interprété par le compilo comme étant la string à l'adresse 0x120.
Si je ne me trompe pas, le résultat est un char const *, pointant à l'adresse de "yz" augmentée de la valeur entière 'x'.
Il faut écrire std::string bad="x"+"yz";
Non.
Pour obtenir "xyz"
Non, ni pour obtenir "xyz", ni pour rien, d'ailleurs.
--drkm, en recherche d'un stage : http://www.fgeorges.org/ipl/stage.html
Falk Tannhäuser
Fabien LE LEZ wrote:
Existe-t-il une combine pour empêcher C++ de compiler des bêtises à la C ?
A priori, non. Mais il n'est pas impossible que certains compilos génèrent un warning (modulo l'option qui va bien).
Avec 'gcc -Wall', j'ai bien un warning "array subscript has type `char'" quand je fais std::string bad = &'x'["yz"]; (qui est fonctionellement équivalent à std::string bad = 'x' + "yz"; mais il me ne semble pas avoir de moyen pour faire générer un warning dans ce cas)
Ce sont les joies de l'arithmétique des pointeurs combiné aux règles loufoques de conversion tableau => pointeur, qui font que le code en question *doit* être accepté par le compilateur, bien qu'il produise un comportement indéfini.
Falk
Fabien LE LEZ wrote:
Existe-t-il une combine pour empêcher C++ de compiler des bêtises à la C ?
A priori, non. Mais il n'est pas impossible que certains compilos
génèrent un warning (modulo l'option qui va bien).
Avec 'gcc -Wall', j'ai bien un warning "array subscript has type `char'"
quand je fais
std::string bad = &'x'["yz"];
(qui est fonctionellement équivalent à
std::string bad = 'x' + "yz";
mais il me ne semble pas avoir de moyen pour faire générer un
warning dans ce cas)
Ce sont les joies de l'arithmétique des pointeurs combiné aux
règles loufoques de conversion tableau => pointeur, qui font
que le code en question *doit* être accepté par le compilateur,
bien qu'il produise un comportement indéfini.
Existe-t-il une combine pour empêcher C++ de compiler des bêtises à la C ?
A priori, non. Mais il n'est pas impossible que certains compilos génèrent un warning (modulo l'option qui va bien).
Avec 'gcc -Wall', j'ai bien un warning "array subscript has type `char'" quand je fais std::string bad = &'x'["yz"]; (qui est fonctionellement équivalent à std::string bad = 'x' + "yz"; mais il me ne semble pas avoir de moyen pour faire générer un warning dans ce cas)
Ce sont les joies de l'arithmétique des pointeurs combiné aux règles loufoques de conversion tableau => pointeur, qui font que le code en question *doit* être accepté par le compilateur, bien qu'il produise un comportement indéfini.
