Probleme avec itoa()

Version imprimable

21/03/2006, 20h34
vdumont

Probleme avec itoa()
Bonjour, jai un probleme avec itoa(), quand jessaye dutiliser la fonction il me dit quelle nest pas declaree.
Code:

1 2 3 4 5 6 7 #include <stdlib.h> ... char mess[15],mess2[10]; strcpy(mess,"Champs_"); itoa(i,mess2,10);
Jai essayer std::itoa mais il dit quil nest pas membre de std.

Je suis sous g++
Merci!
21/03/2006, 20h39
Fiquet

itoa ce n'est pas du C++. Utilise std::string et ostringstream. Voir la FAQ pour des exemples : http://c.developpez.com/faq/cpp/?page=strings

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
for (int i=0;i<nb;i++)
        {
        char mess[15],mess2[10];
        strcpy(mess,"Champs_");
        	std::ostringstream oss;
        	oss << i;
        	mess2 = oss.str();
        //itoa(i,mess2,10);
        strcat(mess,mess2);
        legende[i]=mess ;
        }

EDIT: Ca compile pas du tout

21/03/2006, 20h59
Fiquet
Non, str() renvoie un std::string. Ensuite si tu as vraiment besoin de const char* il y a une fonction membre de std::string qui renvoie un const char* : c_str().

Si j'ai bien compris ce que tu voulais faire :
Code:

1 2 3 4 5 6 7 8 9 for (int i=0;i<nb;i++) { std::ostringstream oss; oss << "Champs_" << i; const char* mess = oss.str().c_str(); // Tu peux maintenant utiliser mess }
21/03/2006, 21h08
vdumont

Hum en fait mess2 est un char[10] et non un char* donc je ne peux pas affecter oss.str().c_str() a mon mess2

affecter un string a un char[10] ca se fait parcontre?
21/03/2006, 21h17
Fiquet

Code:

strcpy(mess2, oss.str().c_str());

Mais es-tu sûr d'avoir directement besoin de ce char[10] ? Tu peux rester dans le type std::string non ? Ca dépend de ce que tu fais après avec ça.

Code:

1
2
3
4
5
6
int nb = 15; // ou n'importe quoi d'autre
std::vector<std::string> legende(nb);
for(int i=0; i<nb; ++i)
{
	legende[i] = "Champs_" + boost::lexical_cast<std::string>(i);
}

21/03/2006, 21h25
vdumont
En ce moment jai dans mon for:
Code:

1 2 3 4 5 6 7 8 9 for (int i=0;i<nb;i++) { std::string mess; strcpy(mess,"Champs_"); std::ostringstream oss; oss << i; strcat(mess,oss.str().c_str()); legende[i]=mess ;
}
Ca plante un max.

mg_solution.cpp:51: error: no matching function for call to `strcpy(std::string&, const char[8])'
/usr/include/string.h:74: note: candidates are: char* strcpy(char*, const char*)

mg_solution.cpp:56: error: no matching function for call to `strcat(std::string&, const char*)'
/usr/include/string.h:70: note: candidates are: char* strcat(char*, const char*)
21/03/2006, 21h26
bigboomshakala

c'est normal. comme le dit le message d'erreur strcpy prend en paramètre un char* et un const char*

Citation:

Envoyé par loufoque

Code:

1
2
3
4
5
6
int nb = 15; // ou n'importe quoi d'autre
std::vector<std::string> legende(nb);
for(int i=0; i<nb; ++i)
{
	legende[i] = "Champs_" + boost::lexical_cast<std::string>(i);
}

encore faut-il avoir boost...

21/03/2006, 21h30
vdumont

Voila le hic et puisque ce nest pas mon logiciel jaimerais eviter les librairies externes.

Est-ce que cela fait du sens??

Pour donner le code complet:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
for (int i=0;i<nb;i++)
        {
        #ifdef GCC
           char *mess = "Champs_"; 
        	std::ostringstream oss;
        	oss << i;
           strcat(mess,oss.str().c_str());
        #else // Borland (reconnait itoa)
        	char mess[15],mess2[10];
        	strcpy(mess,"Champs_");
        	itoa(i,mess2,10);
        	strcat(mess,mess2);
        #endif
        legende[i]=mess ;
        }

Hum jai trouver mieux

Code:

1
2
3
4
5
6
7
 
for (int i=0;i<nb;i++)
        {
	      char mess[15];
        sprintf(mess,"Champs_%d",i);
        legende[i]=mess ;
        }

21/03/2006, 22h23
loufoque
vdumont, évite de faire du code trop pourri.
1) Déjà tu utilises des tableaux et des chaînes C, truc à ne surtout pas faire en C++.
Et en plus, bien qu'on t'ait parlé de std::string et compagnie, tu continues à utiliser des trucs de C (le plus drôle étant le strcat sur une std::string - tiens ça fait une erreur, comment ça se fait ?)
2) Les macros ça fait aussi partie des trucs à éviter si possible. Tu veux mettre le comportement normal pour GCC et un comportement non standard pour tous les autres compilateurs. Ça devrait être l'inverse, mais bon, de toutes façons tu n'as pas besoin de distinguer deux cas : il suffit de bien le faire une fois pour toutes.
3) Prenons ton code pour gcc. Déjà char *mess = "Champs_" et après tu veux faire un strcat dessus. Ça doit sûrement faire une magnifique erreur de segmentation ou un buffer overflow.
4) Regardons maintenant pour les autres compilateurs (enfin pour Borland). Tu utilises deux variables, dont une, mess2, est parfaitement inutile, si ce n'est pour ajouter des traitements supplémentaires.
Ton code aurait pu s'écrire plus simplement comme ceci
Code:

1 2 char mess[15] = "Champs_"; itoa(i, mess+7, 10);
Ce qui provoquera de gros problèmes dès que i dépassera 10 millions. Mais bon, ça n'arrivera probablement pas, étant donné que 10 millions de champs, c'est un peu lourd à manipuler.

Si tu ne souhaites pas utiliser boost (qui est pourtant une bibliothèque très utilisée dans le C++ moderne) il faut alors utiliser directement les flux, et dans ton cas std::ostringstream correspond bien, surtout si tu utilises des std::string à la place des char* comme tu devrais.

Edit : je viens de voir ton nouveau post, tu as tout simplement abandonné le C++ et utilisé la manière C89/90 de résoudre ce problème (en C99 on aurait peut-être préféré snprintf).
Si tu souhaites progammer ainsi, il serait peut-être plus avisé de poser tes questions sur le forum C à l'avenir.
21/03/2006, 22h37
vdumont

Loufque:

1- Peux tu preciser quels sont les chaines C? Jai de la misere a differencier
2- Je sais mais jattendais de retourner sous Windows pour tester davantage
3- Peux tu expliquer pourquoi ca ferait une erreur overflow??
4- Je sais quelle est inutile et je lavais supprimer. Je ne suis pas lauteur du code original je fais seulement modifier

Dans ton extrait de code, tu utilise itoa, hors itoa nexiste pas en C++ donc que faire??

Je ne peux pas utiliser boost car ce nest pas moi qui decide.

Jignorais que sprintf etait du C.

Pour rester en C++ il aurait donc fallu la solution de Fiquet:
Code:

1 2 3 4 std::ostringstream oss; oss << "Champs_" << i; const char* mess = oss.str().c_str();

21/03/2006, 23h06
loufoque
Citation:

Code:

const char* mess = oss.str().c_str();

Alors est-ce que tu es conscient que là tu as un pointeur vers une variable qui va cesser d'exister dès qu'on passera à l'itération suivante de la boucle ?
(C'était d'ailleurs aussi le cas dans tous les codes précédents que tu as fournis a priori, t'arrives à faire marcher ça ?)

1) Des séquences de char terminées par un caractère nul.
Le type séquence n'existant pas en C (les tableaux ont une taille fixe et on ne peut pas les passer par valeur) on utilise donc un pointeur vers le premier char de cette séquence pour les manipuler, le caractère nul à la fin permettant de savoir quand est-ce que cette séquence se termine.

Les chaînes C++ (std::string) sont quant à elles des objets qui sont des séquences qui se redimensionnent automatiquement si besoin est, qui surchargent divers opérateurs pour facilitier la concaténation, l'affectation, la copie, la conversion etc. Il y a aussi des fonctions membres pour faire des opérations usuelles, et ces chaînes peuvent contenir des caractères nuls au milieu sans problème.

3) mess est dans ce cas un pointeur vers le premier caractère d'une chaîne littérale, qui est sûrement dans ton cas un char[8];
Avec ton strcat tu vas donc essayer d'écrire au delà de la mémoire disponible.

Citation:

Dans ton extrait de code, tu utilise itoa, hors itoa nexiste pas en C++ donc que faire??

Il s'agissait juste d'une simplification de ton code.
itoa est une fonction C non standard fournie par Borland.

Une meilleure solution serait que legende soit un std::vector<std::string>.
Bref comme j'ai donné en premier
Code:

1 2 3 4 5 6 7 8 int nb = 15; // par exemple std::vector<std::string> legende(nb); for(int i=0; i<nb; ++i) { std::ostringstream oss; oss << "Champs_" << i; legende[i] = oss.str(); }
22/03/2006, 00h34
Luc Hermitte

Citation:

Envoyé par bigboomshakala

encore faut-il avoir boost...

De toutes les libs boost, c'est une des plus simples à subsituer -- en particulier sur les projets qui ne peuvent plus dépendre de "nouvelles" bibliothèques externes.

Sinon, itoa ne fait ni parti du C++, ni du C. C'est une extension propriétaire pour je ne sais plus quel compilo pouvant se lier à du C.

Hum en faisant:
Code:

1 2 3 4 5 6 7 8 9 10 for (int i=0;i<575000;i++) { std::ostringstream oss; oss << "Champs_" << i; const char* mess = oss.str().c_str(); legende[i] = mess; std::cout << legende[i]; }
Ca s'execute #1 sans aucun leak de mémoire... je comprend pas trop le truc du pointeur que tu dis..

A la fin on utilise mess, ensuite on change l'itération, on redéclare tout et on ré-utilise et ainsi de suite. Je n'utilise jamais mess alors qu'il point nul part?? Je suis pas sur de comprendre, merci de m'éclairer.

La seule utilisation possible la fonction membre c_str(), c'est pour une copie immédiate. Tu ne peux pas stocker ce pointeur comme tu le fais, puisque dès la fin de l'appel à c_str(), la chaîne retournée pourra potentiellement ne plus exister.

Il faut donc quelque chose de ce style :
Code:

1 2 3 4 5 6 7 8 9 for (int i=0;i<575000;i++) { std::ostringstream oss; oss << "Champs_" << i; strcpy(legende[i], oss.str().c_str()); std::cout << legende[i]; }
Mais c'est vrai que c'est un peu idiot de repasser par un tableau de char alors que tu as un std::string...

Citation:

je comprend pas trop le truc du pointeur que tu dis..

Et là, tu comprends ? (la variable mess est inutile mais j'ai repris ton code)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <sstream>
 
int main()
{
    const char *legende[15];
    int i;
    for(i=0; i<15; i++)
    {
        std::ostringstream oss;
        oss << "Champs_" << i;
        const char *mess = oss.str().c_str();
        legende[i] = mess;
    }
 
    for(i=0; i<15; i++)
    {
        std::cout << legende[i] << std::endl;
    }
}

Normalement tu devrais avoir 15 fois Champs_14.

22/03/2006, 15h00
vdumont

Ok merci.