J'ai un problème avec la fonction CString::Right(), qui me retourne des
valeurs fantaisistes. Je suppose que c'est dû à un état particulier de
la CString, peut-être un buffer agrandi, mais je ne sais pas comment
résoudre le problème de façon propre.
Voici un bout de code minimal expliquant le problème. Dans ce code,
titleList est un CStringList (créé ailleurs), title et right sont des
CString.
--------------------------------------------------------
POSITION pos = titleList.GetHeadPosition();
title = titleList.GetNext(pos);
right = title.Right(10);
char *szTitle = (char *)(LPCTSTR)title;
title = szTitle;
right = title.Right(10);
--------------------------------------------------------
À la deuxième ligne du code ci-dessus, title lit sa valeur depuis
titleList, et vaut (par exemple) "Login - SeaMonkey".
À la troisième ligne, right est constitué de 10 Í : "ÍÍÍÍÍÍÍÍÍÍ".
Après le cast sauvage de title en char * puis de nouveau en CString,
à la sixième ligne right vaut enfin " SeaMonkey" comme il se doit.
Comment puis-je fair pour obtenir la bonne valeur d'une façon plus
civilisée que ce double transtypage ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Olivier Miakinen
Le 22/07/2008 19:48, j'écrivais :
-------------------------------------------------------- POSITION pos = titleList.GetHeadPosition(); title = titleList.GetNext(pos); right = title.Right(10); char *szTitle = (char *)(LPCTSTR)title; title = szTitle; right = title.Right(10); --------------------------------------------------------
Dernière minute : j'obtiens le même résultat sans passer par une variable intermédiaire, en remplaçant : -------------------------------------------------------- char *szTitle = (char *)(LPCTSTR)title; title = szTitle; -------------------------------------------------------- par : -------------------------------------------------------- title = (CString)(LPCTSTR)title; --------------------------------------------------------
C'est un peu mieux, mais j'aimerais quand même me passer de transtypage si c'était possible.
Cordialement, -- Olivier Miakinen
Le 22/07/2008 19:48, j'écrivais :
--------------------------------------------------------
POSITION pos = titleList.GetHeadPosition();
title = titleList.GetNext(pos);
right = title.Right(10);
char *szTitle = (char *)(LPCTSTR)title;
title = szTitle;
right = title.Right(10);
--------------------------------------------------------
Dernière minute : j'obtiens le même résultat sans passer par une
variable intermédiaire, en remplaçant :
--------------------------------------------------------
char *szTitle = (char *)(LPCTSTR)title;
title = szTitle;
--------------------------------------------------------
par :
--------------------------------------------------------
title = (CString)(LPCTSTR)title;
--------------------------------------------------------
C'est un peu mieux, mais j'aimerais quand même me passer de
transtypage si c'était possible.
-------------------------------------------------------- POSITION pos = titleList.GetHeadPosition(); title = titleList.GetNext(pos); right = title.Right(10); char *szTitle = (char *)(LPCTSTR)title; title = szTitle; right = title.Right(10); --------------------------------------------------------
Dernière minute : j'obtiens le même résultat sans passer par une variable intermédiaire, en remplaçant : -------------------------------------------------------- char *szTitle = (char *)(LPCTSTR)title; title = szTitle; -------------------------------------------------------- par : -------------------------------------------------------- title = (CString)(LPCTSTR)title; --------------------------------------------------------
C'est un peu mieux, mais j'aimerais quand même me passer de transtypage si c'était possible.
Cordialement, -- Olivier Miakinen
greg
Olivier Miakinen wrote:
Bonjour,
J'ai un problème avec la fonction CString::Right(), qui me retourne des valeurs fantaisistes. Je suppose que c'est dû à un état particulier de la CString, peut-être un buffer agrandi, mais je ne sais pas comment résoudre le problème de façon propre.
Voici un bout de code minimal expliquant le problème. Dans ce code, titleList est un CStringList (créé ailleurs), title et right sont des CString. -------------------------------------------------------- POSITION pos = titleList.GetHeadPosition(); title = titleList.GetNext(pos); right = title.Right(10); char *szTitle = (char *)(LPCTSTR)title; title = szTitle; right = title.Right(10); --------------------------------------------------------
À la deuxième ligne du code ci-dessus, title lit sa valeur depuis titleList, et vaut (par exemple) "Login - SeaMonkey".
À la troisième ligne, right est constitué de 10 Í : "ÍÍÍÍÍÍÍÍÍÍ".
Après le cast sauvage de title en char * puis de nouveau en CString, à la sixième ligne right vaut enfin " SeaMonkey" comme il se doit.
J'ai un problème avec la fonction CString::Right(), qui me retourne des
valeurs fantaisistes. Je suppose que c'est dû à un état particulier de
la CString, peut-être un buffer agrandi, mais je ne sais pas comment
résoudre le problème de façon propre.
Voici un bout de code minimal expliquant le problème. Dans ce code,
titleList est un CStringList (créé ailleurs), title et right sont des
CString.
--------------------------------------------------------
POSITION pos = titleList.GetHeadPosition();
title = titleList.GetNext(pos);
right = title.Right(10);
char *szTitle = (char *)(LPCTSTR)title;
title = szTitle;
right = title.Right(10);
--------------------------------------------------------
À la deuxième ligne du code ci-dessus, title lit sa valeur depuis
titleList, et vaut (par exemple) "Login - SeaMonkey".
À la troisième ligne, right est constitué de 10 Í : "ÍÍÍÍÍÍÍÍÍÍ".
Après le cast sauvage de title en char * puis de nouveau en CString,
à la sixième ligne right vaut enfin " SeaMonkey" comme il se doit.
Ca n'a pas trop de sens.
Tu es sûr que tu ne mélanges pas Ansi-Unicode ?
Il n'y a pas ce probleme sur les exemples de Microsoft ou du Web, comme
http://functionx.com/visualc/collections/cstringlist.htm
http://comsci.liu.edu/~murali/mfc/CString.htm
J'ai un problème avec la fonction CString::Right(), qui me retourne des valeurs fantaisistes. Je suppose que c'est dû à un état particulier de la CString, peut-être un buffer agrandi, mais je ne sais pas comment résoudre le problème de façon propre.
Voici un bout de code minimal expliquant le problème. Dans ce code, titleList est un CStringList (créé ailleurs), title et right sont des CString. -------------------------------------------------------- POSITION pos = titleList.GetHeadPosition(); title = titleList.GetNext(pos); right = title.Right(10); char *szTitle = (char *)(LPCTSTR)title; title = szTitle; right = title.Right(10); --------------------------------------------------------
À la deuxième ligne du code ci-dessus, title lit sa valeur depuis titleList, et vaut (par exemple) "Login - SeaMonkey".
À la troisième ligne, right est constitué de 10 Í : "ÍÍÍÍÍÍÍÍÍÍ".
Après le cast sauvage de title en char * puis de nouveau en CString, à la sixième ligne right vaut enfin " SeaMonkey" comme il se doit.
Et pourtant c'est bien le cas. Cela dit, je ne sais pas comment sont implémentées les CString, mais l'existence même des fonctions GetBuffer et GetBufferSetLength, où l'on peut préciser une longueur strictement supérieure à la longueur de la chaîne, prouve que la longueur interne peut être plus grande : je suppose que cela peut être l'origine du problème.
Tu es sûr que tu ne mélanges pas Ansi-Unicode ?
Oui, j'en suis certain. J'ai même vérifié le contenu de chaque variable avec le débugueur en mode pas à pas, ligne après ligne, et j'obtiens les résultats suivants :
Oui, bien sûr. Je n'ai pas non plus le problème si j'initialise title avec _T("Login - SeaMonkey") mais je ne sais pas quel traitement a été fait à la chaîne avant son insertion dans une CStringList. Il est très possible par exemple que la taille du buffer interne ait été changée par un appel à GetBuffer() ou GetBufferSetLength(). Tiens, d'ailleurs, c'est un test que je pourrai faire.
Cordialement, -- Olivier Miakinen
Bonjour,
Le 23/07/2008 09:08, greg m'a répondu :
Ca n'a pas trop de sens.
Et pourtant c'est bien le cas. Cela dit, je ne sais pas comment sont
implémentées les CString, mais l'existence même des fonctions GetBuffer
et GetBufferSetLength, où l'on peut préciser une longueur strictement
supérieure à la longueur de la chaîne, prouve que la longueur interne
peut être plus grande : je suppose que cela peut être l'origine du problème.
Tu es sûr que tu ne mélanges pas Ansi-Unicode ?
Oui, j'en suis certain. J'ai même vérifié le contenu de chaque variable
avec le débugueur en mode pas à pas, ligne après ligne, et j'obtiens les
résultats suivants :
title = titleList.GetNext(pos);
// title = { "Login - SeaMonkey" }
right = title.Right(10);
// right = { "ÍÍÍÍÍÍÍÍÍÍ" }
char *szTitle = (char *)(LPCTSTR)title;
// szTitle = "Login - SeaMonkey"
title = szTitle;
// title = { "Login - SeaMonkey" }
right = title.Right(10);
// right = { " SeaMonkey" }
Il n'y a pas ce probleme sur les exemples de Microsoft ou du Web, comme
http://functionx.com/visualc/collections/cstringlist.htm
http://comsci.liu.edu/~murali/mfc/CString.htm
Oui, bien sûr. Je n'ai pas non plus le problème si j'initialise title
avec _T("Login - SeaMonkey") mais je ne sais pas quel traitement a été
fait à la chaîne avant son insertion dans une CStringList. Il est très
possible par exemple que la taille du buffer interne ait été changée par
un appel à GetBuffer() ou GetBufferSetLength(). Tiens, d'ailleurs, c'est
un test que je pourrai faire.
Et pourtant c'est bien le cas. Cela dit, je ne sais pas comment sont implémentées les CString, mais l'existence même des fonctions GetBuffer et GetBufferSetLength, où l'on peut préciser une longueur strictement supérieure à la longueur de la chaîne, prouve que la longueur interne peut être plus grande : je suppose que cela peut être l'origine du problème.
Tu es sûr que tu ne mélanges pas Ansi-Unicode ?
Oui, j'en suis certain. J'ai même vérifié le contenu de chaque variable avec le débugueur en mode pas à pas, ligne après ligne, et j'obtiens les résultats suivants :
Oui, bien sûr. Je n'ai pas non plus le problème si j'initialise title avec _T("Login - SeaMonkey") mais je ne sais pas quel traitement a été fait à la chaîne avant son insertion dans une CStringList. Il est très possible par exemple que la taille du buffer interne ait été changée par un appel à GetBuffer() ou GetBufferSetLength(). Tiens, d'ailleurs, c'est un test que je pourrai faire.
Cordialement, -- Olivier Miakinen
Olivier Miakinen
Le 23/07/2008 22:18, j'écrivais :
Et pourtant c'est bien le cas. Cela dit, je ne sais pas comment sont implémentées les CString, mais l'existence même des fonctions GetBuffer et GetBufferSetLength, où l'on peut préciser une longueur strictement supérieure à la longueur de la chaîne, prouve que la longueur interne peut être plus grande : je suppose que cela peut être l'origine du problème.
Apparemment personne n'a d'idée. Est-ce que quelqu'un saurait alors où je pourrais trouver le code source correspondant à la classe CString, afin d'essayer de comprendre par moi-même ?
Le 23/07/2008 22:18, j'écrivais :
Et pourtant c'est bien le cas. Cela dit, je ne sais pas comment sont
implémentées les CString, mais l'existence même des fonctions GetBuffer
et GetBufferSetLength, où l'on peut préciser une longueur strictement
supérieure à la longueur de la chaîne, prouve que la longueur interne
peut être plus grande : je suppose que cela peut être l'origine du problème.
Apparemment personne n'a d'idée. Est-ce que quelqu'un saurait alors où
je pourrais trouver le code source correspondant à la classe CString,
afin d'essayer de comprendre par moi-même ?
Et pourtant c'est bien le cas. Cela dit, je ne sais pas comment sont implémentées les CString, mais l'existence même des fonctions GetBuffer et GetBufferSetLength, où l'on peut préciser une longueur strictement supérieure à la longueur de la chaîne, prouve que la longueur interne peut être plus grande : je suppose que cela peut être l'origine du problème.
Apparemment personne n'a d'idée. Est-ce que quelqu'un saurait alors où je pourrais trouver le code source correspondant à la classe CString, afin d'essayer de comprendre par moi-même ?
Mickael
Olivier Miakinen wrote:
Le 23/07/2008 22:18, j'écrivais :
Et pourtant c'est bien le cas. Cela dit, je ne sais pas comment sont implémentées les CString, mais l'existence même des fonctions GetBuffer et GetBufferSetLength, où l'on peut préciser une longueur strictement supérieure à la longueur de la chaîne, prouve que la longueur interne peut être plus grande : je suppose que cela peut être l'origine du problème.
Apparemment personne n'a d'idée. Est-ce que quelqu'un saurait alors où je pourrais trouver le code source correspondant à la classe CString, afin d'essayer de comprendre par moi-même ?
Il est dans le fichier STREX.CPP
Olivier Miakinen wrote:
Le 23/07/2008 22:18, j'écrivais :
Et pourtant c'est bien le cas. Cela dit, je ne sais pas comment sont
implémentées les CString, mais l'existence même des fonctions GetBuffer
et GetBufferSetLength, où l'on peut préciser une longueur strictement
supérieure à la longueur de la chaîne, prouve que la longueur interne
peut être plus grande : je suppose que cela peut être l'origine du problème.
Apparemment personne n'a d'idée. Est-ce que quelqu'un saurait alors où
je pourrais trouver le code source correspondant à la classe CString,
afin d'essayer de comprendre par moi-même ?
Et pourtant c'est bien le cas. Cela dit, je ne sais pas comment sont implémentées les CString, mais l'existence même des fonctions GetBuffer et GetBufferSetLength, où l'on peut préciser une longueur strictement supérieure à la longueur de la chaîne, prouve que la longueur interne peut être plus grande : je suppose que cela peut être l'origine du problème.
Apparemment personne n'a d'idée. Est-ce que quelqu'un saurait alors où je pourrais trouver le code source correspondant à la classe CString, afin d'essayer de comprendre par moi-même ?
Il est dans le fichier STREX.CPP
Olivier Miakinen
Le 25/07/2008 23:23, Mickael a écrit :
[...] Est-ce que quelqu'un saurait alors où je pourrais trouver le code source correspondant à la classe CString, afin d'essayer de comprendre par moi-même ?
Il est dans le fichier STREX.CPP
Oh ! Je ne croyais même pas qu'il était possible de le trouver sur mon propre disque ! Malheureusement je n'ai trouvé que celui de VC98 alors que j'ai le problème dans Visual C++ 2003, mais ça me donne déjà quelque chose à regarder. Un grand merci pour cela !
Le 25/07/2008 23:23, Mickael a écrit :
[...] Est-ce que quelqu'un saurait alors où
je pourrais trouver le code source correspondant à la classe CString,
afin d'essayer de comprendre par moi-même ?
Il est dans le fichier STREX.CPP
Oh ! Je ne croyais même pas qu'il était possible de le trouver sur mon
propre disque ! Malheureusement je n'ai trouvé que celui de VC98 alors
que j'ai le problème dans Visual C++ 2003, mais ça me donne déjà quelque
chose à regarder. Un grand merci pour cela !
[...] Est-ce que quelqu'un saurait alors où je pourrais trouver le code source correspondant à la classe CString, afin d'essayer de comprendre par moi-même ?
Il est dans le fichier STREX.CPP
Oh ! Je ne croyais même pas qu'il était possible de le trouver sur mon propre disque ! Malheureusement je n'ai trouvé que celui de VC98 alors que j'ai le problème dans Visual C++ 2003, mais ça me donne déjà quelque chose à regarder. Un grand merci pour cela !
