j'utilise des fonctions d'une librairie du genre lafonction(int val,char
*toto)
elle mettent la reponse dans toto.
comment se gère char *toto ?
voici un petit bout de code dont les fontions remplissent une chaine passée
en paramètre
char mon_char[32];
lafonction(1,&mon_char);
cout << mon_char << endl;
autrefontion(3,&mon_char);
cout << mon_char << endl; <----ici s'affiche la chaine retournee + un bout
de l'autre
entre les deux appels la chaine mon_char doit être effacée ? réinitialisée ?
suis je obligé d'en présicer la taille ?
Au bout de plusieurs appels, ma_chaine contient des bouts de plusieurs
appels
entre les deux appels la chaine mon_char doit être effacée ? réinitialisée ?
suis je obligé d'en présicer la taille ? Au bout de plusieurs appels, ma_chaine contient des bouts de plusieurs appels Tout est dans autrefonction().
De toute évidence, elle ne positionne pas le ' ' final. Peut-être devriez-vous forcer mon_char[32] tout à ' ' avant chaque appel ? Mais ça ressemble à une rustine, à première vue .... Pierre
"Didier" <toto@wanadoo.fr> a écrit dans le message de news:
bvvaoq$rot$1@news-reader5.wanadoo.fr...
bonjour,
j'utilise des fonctions d'une librairie du genre lafonction(int
val,char
*toto)
elle mettent la reponse dans toto.
comment se gère char *toto ?
voici un petit bout de code dont les fontions remplissent une chaine
passée
entre les deux appels la chaine mon_char doit être effacée ? réinitialisée
?
suis je obligé d'en présicer la taille ?
Au bout de plusieurs appels, ma_chaine contient des bouts de plusieurs
appels
Tout est dans autrefonction().
De toute évidence, elle ne positionne pas le ' ' final.
Peut-être devriez-vous forcer mon_char[32] tout à ' ' avant chaque appel ?
Mais ça ressemble à une rustine, à première vue ....
Pierre
entre les deux appels la chaine mon_char doit être effacée ? réinitialisée ?
suis je obligé d'en présicer la taille ? Au bout de plusieurs appels, ma_chaine contient des bouts de plusieurs appels Tout est dans autrefonction().
De toute évidence, elle ne positionne pas le ' ' final. Peut-être devriez-vous forcer mon_char[32] tout à ' ' avant chaque appel ? Mais ça ressemble à une rustine, à première vue .... Pierre
M. B.
"Didier" a écrit dans le message de news: bvvaoq$rot$
bonjour,
j'utilise des fonctions d'une librairie du genre lafonction(int val,char
*toto) elle mettent la reponse dans toto.
comment se gère char *toto ? voici un petit bout de code dont les fontions remplissent une chaine passée
entre les deux appels la chaine mon_char doit être effacée ? réinitialisée
?
suis je obligé d'en présicer la taille ? Au bout de plusieurs appels, ma_chaine contient des bouts de plusieurs appels
Je suis surpris que ton compilateur laisse passer ca. Effectivement, impossible tel quel en C++ (GNU, Borland, VC7).
En C, c'est accepté (avec warning, of course).
Donc il faut l'appeler comme ca :
lafonction(1, mon_char);
Et pas comme ca :
lafonction(1, &mon_char); // Faux
Normal que les resultats soient foireux. Je ne suis pas certain que ce soit l'explication.
Si le compilateur l'accepte, la valeur de &mon_char n'est pas ambigüe, je veux dire par là que puisque c'est un tableau qui a été déclaré, et non un char**, il n'y a pas de risque d'avoir l'adresse d'un pointeur. Donc, SI LE COMPILATEUR ACCEPTE, les formes suivantes sont équivalentes : lafonction(1, &mon_char); // c'est un char(*)[32], ou char[32]* lafonction(1, (char*)&mon_char); lafonction(1, mon_char); lafonction(1, &mon_char[0]);
entre les deux appels la chaine mon_char doit être effacée ?
réinitialisée
?
suis je obligé d'en présicer la taille ?
Au bout de plusieurs appels, ma_chaine contient des bouts de plusieurs
appels
Je suis surpris que ton compilateur laisse passer ca.
Effectivement, impossible tel quel en C++ (GNU, Borland, VC7).
En C, c'est accepté (avec warning, of course).
Donc il faut l'appeler comme ca :
lafonction(1, mon_char);
Et pas comme ca :
lafonction(1, &mon_char); // Faux
Normal que les resultats soient foireux.
Je ne suis pas certain que ce soit l'explication.
Si le compilateur l'accepte, la valeur de &mon_char n'est pas ambigüe, je
veux dire par là que puisque c'est un tableau qui a été déclaré, et non un
char**, il n'y a pas de risque d'avoir l'adresse d'un pointeur.
Donc, SI LE COMPILATEUR ACCEPTE, les formes suivantes sont équivalentes :
lafonction(1, &mon_char); // c'est un char(*)[32], ou char[32]*
lafonction(1, (char*)&mon_char);
lafonction(1, mon_char);
lafonction(1, &mon_char[0]);
entre les deux appels la chaine mon_char doit être effacée ? réinitialisée
?
suis je obligé d'en présicer la taille ? Au bout de plusieurs appels, ma_chaine contient des bouts de plusieurs appels
Je suis surpris que ton compilateur laisse passer ca. Effectivement, impossible tel quel en C++ (GNU, Borland, VC7).
En C, c'est accepté (avec warning, of course).
Donc il faut l'appeler comme ca :
lafonction(1, mon_char);
Et pas comme ca :
lafonction(1, &mon_char); // Faux
Normal que les resultats soient foireux. Je ne suis pas certain que ce soit l'explication.
Si le compilateur l'accepte, la valeur de &mon_char n'est pas ambigüe, je veux dire par là que puisque c'est un tableau qui a été déclaré, et non un char**, il n'y a pas de risque d'avoir l'adresse d'un pointeur. Donc, SI LE COMPILATEUR ACCEPTE, les formes suivantes sont équivalentes : lafonction(1, &mon_char); // c'est un char(*)[32], ou char[32]* lafonction(1, (char*)&mon_char); lafonction(1, mon_char); lafonction(1, &mon_char[0]);
Pierre
James Kanze
"M. B." writes:
|> "Didier" a écrit dans le message de news: |> bvvaoq$rot$
|> > j'utilise des fonctions d'une librairie du genre |> > lafonction(int val,char *toto) |> > elle mettent la reponse dans toto.
|> > comment se gère char *toto ?
Ça dépend de la spécification de la fonction.
|> > voici un petit bout de code dont les fontions remplissent une |> > chaine passée en paramètre
|> > entre les deux appels la chaine mon_char doit être effacée ? |> > réinitialisée ?
Qui sait ? Ça dépend de la spécification de la fonction appelée.
|> > suis je obligé d'en présicer la taille ?
Normallement, je dirais qu'une interface où tu dois passer les tableaux de type C, mais que tu n'en spécifies pas la longueur, est mal conçu. Il en existe néanmoins (dans l'interface Posix, par exemple, mais ce n'est pas un modèle) où tu dois fournir un taille spécifique.
|> > Au bout de plusieurs appels, ma_chaine contient des bouts de |> > plusieurs appels
|> Je suis surpris que ton compilateur laisse passer ca.
|> char mon_char[32]; // C'est un tableau de char
|> Donc 'mon_char' est un pointeur sur char, un char *
Non. Pas, au moins, selon la norme. 'mon_char' est bien un tableau [32] de char.
|> lafonction(int val, char * toto); // le 2ieme arg est un char *
|> Donc il faut l'appeler comme ca :
|> lafonction(1, mon_char);
|> Et pas comme ca :
|> lafonction(1, &mon_char); // Faux
|> Normal que les resultats soient foireux.
Je ne sais pas. Je m'attendrais à une erreur de compilation -- si je lis la norme correctement, le type de &mon_char est char (*)[ 32 ] (pointeur à un tableau de char), et non char*. Le code ne doit pas se compiler.
-- James Kanze mailto: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93
"M. B." <m_binder@magicnet.com> writes:
|> "Didier" <toto@wanadoo.fr> a écrit dans le message de news:
|> bvvaoq$rot$1@news-reader5.wanadoo.fr...
|> > j'utilise des fonctions d'une librairie du genre
|> > lafonction(int val,char *toto)
|> > elle mettent la reponse dans toto.
|> > comment se gère char *toto ?
Ça dépend de la spécification de la fonction.
|> > voici un petit bout de code dont les fontions remplissent une
|> > chaine passée en paramètre
|> > entre les deux appels la chaine mon_char doit être effacée ?
|> > réinitialisée ?
Qui sait ? Ça dépend de la spécification de la fonction
appelée.
|> > suis je obligé d'en présicer la taille ?
Normallement, je dirais qu'une interface où tu dois passer les
tableaux de type C, mais que tu n'en spécifies pas la longueur, est
mal conçu. Il en existe néanmoins (dans l'interface Posix, par
exemple, mais ce n'est pas un modèle) où tu dois fournir un taille
spécifique.
|> > Au bout de plusieurs appels, ma_chaine contient des bouts de
|> > plusieurs appels
|> Je suis surpris que ton compilateur laisse passer ca.
|> char mon_char[32]; // C'est un tableau de char
|> Donc 'mon_char' est un pointeur sur char, un char *
Non. Pas, au moins, selon la norme. 'mon_char' est bien un tableau [32]
de char.
|> lafonction(int val, char * toto); // le 2ieme arg est un char *
|> Donc il faut l'appeler comme ca :
|> lafonction(1, mon_char);
|> Et pas comme ca :
|> lafonction(1, &mon_char); // Faux
|> Normal que les resultats soient foireux.
Je ne sais pas. Je m'attendrais à une erreur de compilation -- si je
lis la norme correctement, le type de &mon_char est char (*)[ 32 ]
(pointeur à un tableau de char), et non char*. Le code ne doit pas se
compiler.
--
James Kanze mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93
|> > entre les deux appels la chaine mon_char doit être effacée ? |> > réinitialisée ?
Qui sait ? Ça dépend de la spécification de la fonction appelée.
|> > suis je obligé d'en présicer la taille ?
Normallement, je dirais qu'une interface où tu dois passer les tableaux de type C, mais que tu n'en spécifies pas la longueur, est mal conçu. Il en existe néanmoins (dans l'interface Posix, par exemple, mais ce n'est pas un modèle) où tu dois fournir un taille spécifique.
|> > Au bout de plusieurs appels, ma_chaine contient des bouts de |> > plusieurs appels
|> Je suis surpris que ton compilateur laisse passer ca.
|> char mon_char[32]; // C'est un tableau de char
|> Donc 'mon_char' est un pointeur sur char, un char *
Non. Pas, au moins, selon la norme. 'mon_char' est bien un tableau [32] de char.
|> lafonction(int val, char * toto); // le 2ieme arg est un char *
|> Donc il faut l'appeler comme ca :
|> lafonction(1, mon_char);
|> Et pas comme ca :
|> lafonction(1, &mon_char); // Faux
|> Normal que les resultats soient foireux.
Je ne sais pas. Je m'attendrais à une erreur de compilation -- si je lis la norme correctement, le type de &mon_char est char (*)[ 32 ] (pointeur à un tableau de char), et non char*. Le code ne doit pas se compiler.
-- James Kanze mailto: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France +33 1 41 89 80 93
