De int et long vers char*

Version imprimable

20/06/2006, 14h09
olivier857

De int et long vers char*

Bonjour à tous,

j'ai un programme avec les 4 variables suivante :

int num_site, num_pm;
long num_dossier, num_carte;

que je voudrai transformer en char* :

char *var2, *var3, *var4, *var5;

et ajouter à la suite de chaine déjà existante :

char *chaine2, *chaine3,* chaine4, *chaine5;

chaine2="NumSit=";
chaine3="NumDos=";
chaine4="NumCar=";
chaine5="NumPm=";

Donc je veux transformer mes 2 int et 2 long en char* (var2, var3, var 4, var5) et les concaténer avec mes chaine2 à chaine5.

Je n'y arrive pas.
Merci de votre aide.
20/06/2006, 14h15
Fiquet

Utilise des std::string en C++ tu te simplifieras la vie. Pour la conversion tout est dans la :faq: : http://c.developpez.com/faq/cpp/?pag...RINGS_numtostr

Si après tu as besoin de char, tu peux récupérer le pointeur de caractères avec la méthode c_str() de std::string (tout est dans la FAQ aussi).
20/06/2006, 14h16
Matthieu Brucher

Pourquoi des char* et pas des std::string ? La concaténation est automatique dans ce cas. Et pour automatiser tout ce qui est dans la FAQ, il y a aussi Boost.Conversion : http://miles.developpez.com/tutoriel...st/conversion/
20/06/2006, 14h27
olivier857

Alors des char*, pourquoi ?

Tout simplement parceque ca va être des variables que j'envoie en paramètre à une fonction en C. En fait mes paramètre char* vont ensuite dans un char** que j'envoie en paramètre dans le "char** argv" du main d'une fonction C.

Voilà le pourquoi

Je ne veu donc pas convertir en string mais bien en char*.
20/06/2006, 14h35
Matthieu Brucher

Tu appelles une fonction main d'un programme en C ???
20/06/2006, 14h36
Fiquet

Citation:

Envoyé par olivier857

Tout simplement parceque ca va être des variables que j'envoie en paramètre à une fonction en C.

Citation:

Envoyé par Fiquet

Si après tu as besoin de char, tu peux récupérer le pointeur de caractères avec la méthode c_str() de std::string (tout est dans la FAQ aussi).

Comme ça tu pourras convertir facilement avec les streams, et concaténer en faisant +, et enfin envoyer dans la fonction C avec la fonction c_str(). Si vraiment tu as besoin d'une chaîne modifiable, il faut faire une copie. Voir http://c.developpez.com/faq/cpp/?pag...TRINGS_to_char .
20/06/2006, 14h40
Pragmateek
Citation:

Je ne veu donc pas convertir en string mais bien en char*.

On peut convertir une "string" C++ en "char*" C avec la méthode "c_str()".
Code:

1 2 string s1("abcde"); const char* s2=s1.c_str();
20/06/2006, 14h41
olivier857

Citation:

Envoyé par Miles

Tu appelles une fonction main d'un programme en C ???

Non, j'ai était un peu vite dans l'explication. C'est pas la fonction main, c'était juste pour imager.
C'est une fonction en C mais pas le main puisque l e main est en c++, c' est la fonction dans laquelle je fait la convertion. Biensur la fonction C est dans un autre fichier.

La fonction C est celle-ci : int post(int argc, char** argv);
20/06/2006, 15h06
Médinoc

Est-ce qu'elle peut être re-prototypée comme suit ?

Code:

int post(int argc, char const* const * argv);

Si oui, tu peux utiliser directement le contenu des std::string avec la fonction membre c_str().
Sinon, un petit strdup() du header <cstring> suffira à te donner une copie des chaînes...
20/06/2006, 15h26
olivier857

Citation:

Envoyé par Médinoc

Est-ce qu'elle peut être re-prototypée comme suit ?

Code:

int post(int argc, char const* const * argv);

Si oui, tu peux utiliser directement le contenu des std::string avec la fonction membre c_str().
Sinon, un petit strdup() du header <cstring> suffira à te donner une copie des chaînes...

Merci, mais non ca ne marche pas avec :
]int post(int argc, char const* const * argv);

Je viens d'eesayer.

Je vais essayer avec strdup.

Bon alors admettont que je prenne le schéma suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <iostream>
#include <cstdlib>
#include <string>
 
#include "post.h"
 
using namespace std;
 
int main(void)
{
  int num_site, num_pm;
  long num_dossier, num_carte;
  string num_site_ch, num_dossier_ch, num_carte_ch, num_pm_ch;
 
  //mes entiers :
  num_site=366;
  num_dossier=246685;
  num_carte=41;
  num_pm=7; 
 
  //conversion entier vers string :
 
  quel est la meilleur méthode ?
 
  //mes début de chaine avant concaténation :
  num_site_str="SitNum=";
  num_dossier_str="Inddos=";
  num_carte_str="CarNum=";
  num_pm_str="MonNum=";
 
  //concaténation des 2 string :
 ...
 
  //conversion des string vers des char*:
  ...
}

Cela vous parait'il bien.

20/06/2006, 15h57
orj30754

pourquoi tu ne fais pas :

sprintf(variable_finale,"%s %ld", char, long);

cette fonction t'enregistre dans variable_finale ton char suivi de ton long.

Bon alors je viens de faire cà :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <string>
 
#include "post.h"
 
using namespace std;
 
int main(void)
{
  int num_site, num_pm;
  long num_dossier, num_carte;
  string num_site_str, num_dossier_str, num_carte_str, num_pm_str;
  std::ostringstream oss1, oss2, oss3, oss4;
  std::string num_site_str2, num_dossier_str2, num_carte_str2, num_pm_str2;
 
  //entiers :
  num_site=366;
  num_dossier=5248;
  num_carte=25;
  num_pm=256;  
 
  //débuts de chaine avant concaténation :
  num_site_str="SitNum=";
  num_dossier_str="Inddos=";
  num_carte_str="CarNum=";
  num_pm_str="MonNum=";
 
 
  // Convertie les entiers en string :
  oss1 << num_site;
  num_site_str2 = oss1.str();
  oss2 << num_dossier;
  num_dossier_str2 = oss2.str();
  oss3 << num_carte;
  num_carte_str2 = oss3.str();
  oss4 << num_pm;
  num_pm_str2 = oss4.str();
 
  //concaténation des 2 string :
  num_site_str+=num_site_str2;
  num_dossier_str+=num_dossier_str2;
  num_carte_str+=num_carte_str2;
  num_pm_str+=num_pm_str2;
  cout << num_site_str << endl;
  cout << num_dossier_str << endl;
  cout << num_carte_str << endl;
  cout << num_pm_str << endl;
 
  //conversion des string vers les char*:
 .....
}

C'est donc presque fini.

Mais je viens de voir çà :

Citation:

Envoyé par orj30754

pourquoi tu ne fais pas :

sprintf(variable_finale,"%s %ld", char, long);

cette fonction t'enregistre dans variable_finale ton char suivi de ton long.

Effectivement ca me parait bien sympa :

je vais eesayer ca parait bcp plus simple et rapide. mais est-ce que c'est bien propre?

20/06/2006, 16h03
Matthieu Brucher

Non, tu dois allouer la mémoire en plus... Si tu veux qqch qui ressemble, regarde du côté de Boost.Format.

Voilà ca fait çà :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <iostream>
#include <cstdlib>
#include <string>
 
#include "post.h"
 
using namespace std;
 
int main(void)
{
  int nb_parm, i;
  char *param[10];
  int num_site, num_pm;
  long num_dossier, num_carte;
  char *num_site_ch, *num_dossier_ch, *num_carte_ch, *num_pm_ch;
  char *num_site_ch2, *num_dossier_ch2, *num_carte_ch2, *num_pm_ch2;
 
  //entiers :
  num_site=366;
  num_dossier=26846;
  num_carte=86;
  num_pm=7;  
 
  //débuts des chaines avant concaténation :
  num_site_ch="SitNum=";
  num_dossier_ch="Inddos=";
  num_carte_ch="CarNum=";
  num_pm_ch="MonNum=";
 
  //allocation mémoire :
  param[2]=(char *)malloc(strlen(num_site_ch)+4);
  param[3]=(char *)malloc(strlen(num_dossier_ch)+13);
  param[4]=(char *)malloc(strlen(num_carte_ch)+13);
  param[5]=(char *)malloc(strlen(num_pm_ch)+4);  
 
  //concaténations des débuts de chaine avec les entiers :
  sprintf(param[2],"%s %d", num_site_ch, num_site);
  sprintf(param[3],"%s %ld", num_dossier_ch, num_dossier);
  sprintf(param[4],"%s %d", num_carte_ch, num_carte);
  sprintf(param[5],"%s %d", num_pm_ch, num_pm);
 
  nb_parm=5;
 
  cout << param[2] << endl;
  cout << param[3] << endl;
  cout << param[4] << endl;
  cout << param[5] << endl;
 
  for(i=0; i<nb_parm; i++)
  {
    free(param[i]);
  }
}

Est-ce juste ?

20/06/2006, 17h11
Fiquet

Là ce n'est plus du C++ mais du C :? ... La méthode précédente était mieux. sprintf() est une fonction héritée du C et qui peut être dangeureuse si l'on ne fait pas attention aux buffers qu'on lui passe.
20/06/2006, 17h20
olivier857

Citation:

Envoyé par Fiquet

Là ce n'est plus du C++ mais du C :? ... La méthode précédente était mieux. sprintf() est une fonction héritée du C et qui peut être dangeureuse si l'on ne fait pas attention aux buffers qu'on lui passe.

Mois je suis newbee et je vous fait confiance.

Les 2 méthodes fonctionnent pour le moment mais effectivement il y en a certainement l'une mieux que l'autre. Plus stable et moins dangeurese, apparement c'est la 1ère d'après ce que tu me dit, donc je prend. Par contre il faut que je la finisse en faisant la conversion string vers char*. je vais retourner sur la faq pour cà.

Alors si je reprend la 1ère méthode j'ai ca :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <string>
 
#include "post.h"
 
using namespace std;
 
int post_name(char* site, char* dossier);
int post_solde(char* site, char* dossier, char* carte, char* pm);
 
int main(void)
{
	int num_site, num_pm;
	long num_dossier, num_carte;
	string num_site_str, num_dossier_str, num_carte_str, num_pm_str;
	std::ostringstream oss1, oss2, oss3, oss4;
	std::string num_site_str2, num_dossier_str2, num_carte_str2, num_pm_str2;
	char *num_site_ch, *num_dossier_ch, *num_carte_ch, *num_pm_ch;
 
	//entiers :
	num_site=26;
	num_dossier=2280;
	num_carte=21;
	num_pm=1;  
 
	//débuts de chaine avant concaténation :
	num_site_str="SitNum=";
	num_dossier_str="Inddos=";
	num_carte_str="CarNum=";
	num_pm_str="MonNum=";	
 
	// Convertie les entiers en string :
	oss1 << num_site;
	num_site_str2 = oss1.str();
	oss2 << num_dossier;
	num_dossier_str2 = oss2.str();
	oss3 << num_carte;
	num_carte_str2 = oss3.str();
	oss4 << num_pm;
	num_pm_str2 = oss4.str();
 
	//concaténation des 2 string :
	num_site_str+=num_site_str2;
	num_dossier_str+=num_dossier_str2;
	num_carte_str+=num_carte_str2;
	num_pm_str+=num_pm_str2;
	cout << num_site_str << endl;
	cout << num_dossier_str << endl;
	cout << num_carte_str << endl;
	cout << num_pm_str << endl;
 
	//conversion des string vers les char*:
	num_site_ch=num_site_str.c_str();
	num_dossier_ch=num_dossier_str.c_str();
	num_carte_ch=num_carte_str.c_str();
	num_pm_ch=num_pm_str.c_str();

Mais j'ai encore un pb car la dernière étape ne me convient pas, ca plante d'ailleurs et c'est normal. Car je ne veu pas une conversion string vers const char* mais vers char *, je n'ai pas le choix a cause de la fonction à laquel je me plug . Donc le .c_str() ne me convient pas, car il transforme le string en const char* et non char*.

20/06/2006, 18h01
Fiquet

Je t'ai déjà expliqué avant. Lis ça (particulièrement la deuxième partie) : http://c.developpez.com/faq/cpp/?pag...TRINGS_to_char
20/06/2006, 18h08
Foobar1329
Hello,
Citation:
Envoyé par olivier857

Alors si je reprend la 1ère méthode j'ai ca :

Code:

1 2 3 4 5 6 //conversion des string vers les char*: num_site_ch=num_site_str.c_str(); num_dossier_ch=num_dossier_str.c_str(); num_carte_ch=num_carte_str.c_str(); num_pm_ch=num_pm_str.c_str();

Mais j'ai encore un pb car la dernière étape ne me convient pas, ca plante d'ailleurs et c'est normal. Car je ne veu pas une conversion string vers const char* mais vers char *, je n'ai pas le choix a cause de la fonction à laquel je me plug . Donc le .c_str() ne me convient pas, car il transforme le string en const char* et non char*.
tu as la fonction membre std::string::copy() pour extraire le contenu de la chaine et la mettre dans un tampon modifiable.
Code:

1 2 3 4 std::string s = "Foobar"; char foobar[30] = { '\0' }; s.copy(foobar, sizeof(foobar)/sizeof*foobar - 1);
C'est sûr mais ça a le même défaut que strncpy() en C si la longueur de la chaine source est bien plus petite que la taille du tampon de destination.
Code:

1 2 3 4 5 6 std::string s = "Foobar"; char foobar[30] = { '\0' }; if ( s.length() < sizeof(foobar)/sizeof*foobar ) { s.copy(foobar, s.length()); }
A+

Citation:

Envoyé par Fiquet

Je t'ai déjà expliqué avant. Lis ça (particulièrement la deuxième partie) : http://c.developpez.com/faq/cpp/?pag...TRINGS_to_char

Oui ok d'accord, moi je me suis inspirer de la 1ère partie.
Donc en regardant la seconde ca devrait marcher et me donner çà :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <string>
 
#include "post.h"
 
using namespace std;
 
int post_name(char* site, char* dossier);
int post_solde(char* site, char* dossier, char* carte, char* pm);
 
int main(void)
{
	int num_site, num_pm;
	long num_dossier, num_carte;
	string num_site_str, num_dossier_str, num_carte_str, num_pm_str;
	std::ostringstream oss1, oss2, oss3, oss4;
	std::string num_site_str2, num_dossier_str2, num_carte_str2, num_pm_str2;
	size_t size_site, size_dossier, size_carte, size_pm;
	char *num_site_ch, *num_dossier_ch, *num_carte_ch, *num_pm_ch;
 
	//entiers :
	num_site=3655;
	num_dossier=23543;
	num_carte=56;
	num_pm=5;  
 
	//débuts de chaine avant concaténation :
	num_site_str    = "SitNum=";
	num_dossier_str = "Inddos=";
	num_carte_str   = "CarNum=";
	num_pm_str      = "MonNum=";	
 
	// Convertie les entiers en string :
	oss1 << num_site;
	oss2 << num_dossier;
	oss3 << num_carte;
	oss4 << num_pm;
	num_dossier_str2 = oss2.str();
	num_site_str2    = oss1.str();
	num_carte_str2   = oss3.str();
	num_pm_str2      = oss4.str();
 
	//concaténation des 2 string :
	num_site_str    += num_site_str2;
	num_dossier_str += num_dossier_str2;
	num_carte_str   += num_carte_str2;
	num_pm_str      += num_pm_str2;
 
	//conversion des string vers les char*:
	size_site    = num_site_str.size() + 1;
	size_dossier = num_dossier_str.size() + 1;
	size_carte   = num_carte_str.size() + 1;
	size_pm      = num_pm_str.size() + 1;	
	num_site_ch    = new char[ size_site ];
	num_dossier_ch = new char[ size_dossier ];
	num_carte_ch   = new char[ size_carte ];
	num_pm_ch      = new char[ size_pm ];
	strncpy( num_site_ch    , num_site_str.c_str()    , size_site );    
	strncpy( num_dossier_ch , num_dossier_str.c_str() , size_dossier );    
	strncpy( num_carte_ch   , num_carte_str.c_str()   , size_carte );    
	strncpy( num_pm_ch      , num_pm_str.c_str()      , size_pm );
 
	//appel des fonctions POST NAME et POST SOLDE
	post_name(num_site_ch, num_dossier_ch);
	post_solde(num_site_ch, num_dossier_ch, num_carte_ch, num_pm_ch);
 
        // désallocation :
	delete [] num_site_ch;
	delete [] num_dossier_ch;
	delete [] num_carte_ch;
	delete [] num_pm_ch;
 
	return 0;
}

21/06/2006, 10h16
olivier857

Bon alors me voilà devant un second problème. J'ai réaliser 2 examples grace a votre aide, 1 en C et l'autre en C++., mais je dois maitenant porter ces programmes sur une plate forme embarqué à base d'ARM7.

Le programme en C y fonctionne correctement, le programme en C++ lui compile bien mais plante quand je le lance sur cette platform. En fait il fait rien il reste bloquer sans rien afficher.

Auriez vous une idée dans mon code C++ (celui du message précédent) de ce qui purrait ne pas être portable. Pour info j'utilise un compilateur croisé arm-elf-g++ qui est lié à la uClibc-0.9.19w.
21/06/2006, 10h17
Matthieu Brucher

Tu as un moyen de savoir où il plante sur ta plateforme ?
21/06/2006, 10h32
olivier857

Citation:

Envoyé par Miles

Tu as un moyen de savoir où il plante sur ta plateforme ?

Non pas de débugger, alors j'ai mis des cout << "toto" << endl; un peu partout pour voir.

Résultat il plante juste au niveau d el'appel de mes fonctions post.

Mais c'est bizarre car mes fonctions post fonctionne très bien quand je les appel depuis le prog écrit en C. Et le code des fonctions post est strictement identique.
21/06/2006, 10h33
Matthieu Brucher

Et c'est quoi comme type de plantage ? Tu n'as aucun warning à la compilation ?
21/06/2006, 10h54
olivier857

Non pas d'erreur à la compilation.

J'ai ajouter des printf au début de ma fonction post pour vérifier que les paramètres y sont bien passés. Et c'est bon, ca print correctement.

Maintenant ma platform m'indique Buserror, mais c'est des messages bien spécifique à ma platform et qui ne sont pas parlant, et j'ai pas de listing d'eeur pour savoir ce que cette erreur signifie. Mais par expérience c'est en général un segmentation fault.

Alors voilà ou j'en suis :

J'ai fait un fichier post.c dans lequel se trouve la solution en C du code dont nous avons discuté ci dessus et le code de la fonction qui fait le post (récupéré sur internet et fonctionne bien).

Ce fichier contient donc 4 fonctions :
- pre_post : fonction qui me permet de convertir mes entiers en char*, puis fais appel aux 2 fonctions de post ("post_name"et "post_solde")
- post_name : fonction qui envoie à la fonction "post" les paramètres nécessaire pour faire un post qui récupère un nom
- post_solde : fonction qui envoie à la fonction post les paramètres nécessaire pour faire un post qui récupère un solde
- post : fonction qui fait le post (+ plusieurs sous fonctions)

Les fonctions pre_post, post_name et post_solde, sont celle que j'ai réalisé moi même, et la fonction post provient d'internet j'ai just changé son nom qui était bien évidement main.

Ce fichier est appellé depuis mon application c++, par la commande suivante :

Code:

pre_post(num_site, num_dossier, num_carte, num_pm);

L'organigramme du tout :
Mon prog C++
| fonction "pre_post"
| | fonction "post_name"
| | | fonction "post" et sous fonction
| | fonction "post_solde"
| | | fonction "post" et sous fonction
| |
|

Mon fichier à télécharger : post.c

Le problème :

Le fichier fonctionne très bien lorsqu'il est appellé par simple programme comme :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 int main(void) { int num_site, num_pm; long num_dossier, num_carte; num_site=22; num_dossier=75835486; num_carte=5369; num_pm=18; pre_post(num_site, num_dossier, num_carte, num_pm); return 0; }
Mais il ne fonctionne pas lorsque je l'appel depuis mon code en C++. Pourtant le code en C++ seul, c'est à dire sans la ligne qui fait appel à la fonction pre_post, fonctionne lui très bien aussi. Le seul moment ou ca ne marche pas c'est quand je lie les 2 codes gràce a la ligne "pre_post(num_site, num_dossier, num_carte, num_pm);".

Auriez vous une idée de ce qui pourrais faire planter le programme. Sachant que ca plante au niveau de l'appel de la fonction posturlbyparts.
J'ai l'impression que le prrogramme rale lorsque je passe mes arguments "num_site, num_dossier, num_carte, num_pm" d'une fonction à l'autre.

23/06/2006, 16h23
orj30754

T'inkiet pas sur le sprintf moi je m'en sert sur visual 6 C++ et ca marche nikel.
En plus je suis pas un dingue de l'info alors je pense que mes codes sont brouillons et ca a jamais planté. Ca marche nikel le SPRINTF.
Tu verras essaye.