Discussion :

[psgman113]

Bonjour,

j'utilise une fonction qui construit une chaine de caractères pointée par un pointeur et qui la retourne , je veux l'afficher ensuite dans le main mais là probleme!
Ya t'il un souci dans ma gestion de chaines?
Merci
Je mets un bout de code (pas besoin de compiler)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
char  *codage_msg(char *message); // declaration de fonction
char *message_code=NULL; 
 
int main()
{
 
 message_code= codage_msg(message); 
  printf("%s\n",message_code); // ca n'affiche plus la chaine
 }
 
 
 
 
char * codage_msg(char *msg)
{
char *msg_code;
 
// je prends une chaine *msg en entrée 
et je construis une autre chaine *msg_code
 
  printf("%s\n",message_code); // ca affiche bien la chaine!!
 
return msg_code
 
}

[souviron34]

Je mets un bout de code (pas besoin de compiler)

vivi on avait bien compris

Ben tu l'alloues bien ta chaîne msg_code ??

[psgman113]

comment faire?

[thewho]

Bonjour,

comment faire?

As-tu seulement réfléchi une ou 2 secondes à ce que tu as écrit comme code ?

Sans blague, c'est un des trucs les plus étranges que j'aie vu jusqu'ici.

Et ça ne doit pas compiler, même en ajoutant les en-têtes nécessaires.

[Thierry Chappuis]

Salut,

Je vois au moins les problèmes suivants:

• message_code est une variable globale alors qu'il n'y a aucune justification pour cela (à corriger absolument)
• Plus grave encore, message_code n'est jamais initialisé
• message n'est ni défini, ni initialisé et est passé à la fonction codage_msg(), dont le paramètre formel msg n'est jamais utilisé.
• La fonction codage_msg renvoie msg_code qui n'est également jamais initialisé

A ceci, on peut ajouter que main doit retourner un entier. Par convention, on renvoie l'entier 0 si l'exécution n'a pas connu de problème. S'il n'y a pas d'instruction return à la fin de main, je crois que la valeur entière 0 est retournée par défaut, mais par soucis de cohérence, il vaut mieux terminer main par return 0 ou return EXIT_SUCCESS.

Pour terminer, la forme de main n'est pas une forme valide en C. Deux formes sont acceptées:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
int main(void)
 
/* ou */
 
int main(int argc, char *argv[])

Le meilleur conseil que j'ai à te donner est de te replonger dans tes cours de C pour approfondir les chapitres sur les chaînes de caractères, les pointeurs, les tableaux, les fonctions, et l'allocation dynamique (beau programme).

Meilleures salutations

Thierry

[Médinoc]

Il y a un début d'explication ici sur la différence entre "char*" et chaîne de caractères, mais cet article-là ne parle pas encore d'allocation...
http://emmanuel-delahaye.developpez.....htm#char_star

[fearyourself]

comment faire?

2 solutions pour allouer de la mémoire :

- Statique : tu déclares une variable dans ta fonction qui peut contenir de l'information. Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
int i;
char c;
int t[16];
char s[32];
char *ptr;

Comme tu vois, i, c sont des types simples. En les déclarant, on a alloué de la place en mémoire pour contenir leur valeur.

Pour les tableaux, on alloue aussi de l'espace pour eux. Ainsi, la déclaration de t a alloué 16 cases d'entiers.

Par contre, ptr est un pointeur. En déclarant ptr, finalement nous avons alloué de l'espace pour un pointeur vers un caractère et non une chaîne de caractères comme ce qui est fait pour s.

Le souci de l'allocation statique est qu'on ne peut pas retourner un pointeur vers une zone statique car, à la fin de la fonction, cette zone mémoire est récupérée.

NB: Juste parce qu'on déclare une variable ne veut pas dire que le compilateur va vraiment allouer de la mémoire pour elle. Il faudra s'en servir pour que cela soit vraie (du moins dans un compilateur un tant soit peu récent).

- L'allocation dynamique : on passe par une fonction : malloc.

La zone mémoire retournée par malloc est à nous et on peut en faire ce qu'on veut. Elle n'est pas perdue lorsque la fonction se termine comme dans le cas de l'allocation statique, donc on peut retourner une adresse allouée dynamiquement. C'est là tout son avantage.

Par contre, il faut prendre des précautions :

- Toujours vérifier le retour de malloc
- Ne pas perdre le pointeur retourner par malloc car il faudra faire une désallocation avec la fonction free



Enfin, dans ton cas, vu que tu veux retourner une chaîne de caractères, tu dois l'allouer dynamiquement. La seule autre solution serait de passer en paramètre la zone allouée pour la chaîne. Ceci permettrait de passer une zone allouée statiquement.

Jc

[psgman113]

message_code est une variable globale alors qu'il n'y a aucune justification pour cela (à corriger absolument)

J'ai besoin d'utiliser des variables globales dans mon programme!

Je ne vois vraiment pas comment m'en débarasser.

J'ai plusieurs fonctions qui doivent manipuler une chaine de caractères commune,
Que me proposez vous?

[Thierry Chappuis]

J'ai besoin d'utiliser des variables globales dans mon programme!

Je ne vois vraiment pas comment m'en débarasser.

J'ai plusieurs fonctions qui doivent manipuler une chaine de caractères commune,
Que me proposez vous?

Les cas où il est absolument nécessaire d'utiliser une variable globale sont rares, du moins dans ma pratique de tous les jours. Si tu as plusieurs fonctions qui doivent manipuler des chaines de caractère, passe à chaque fois les chaînes en paramètre des fonctions en question, c'est fait pour ça.

Thierry

[psgman113]

si dans une fonction, je crée ma chaine de caractères et que j'en ai besoin dans une autre fonction , je fais donc un return, mais quand je la retourne, il faut bien que je la stocke dans une nouvelle chaine globale
sinon l'autre solution est que j'imbrique les fonctions

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
// déclaration des fonctions
void decodage_msg(char *msg_code);
char  *codage_msg(char *message);
char * saisie_msg();
 
 main ()
{
 
decodage_msg ( codage_msg(saisie_msg));
 
 
}
 
 
char * saisie_msg()
{
message="crist";
return message;
}
 
char * codage_msg()
{
char *msg_code
// je remplis cette nouvelle chaine de caractères 
return msg_code;
}

[DaZumba]

mais quand je la retourne, il faut bien que je la stocke dans une nouvelle chaine globale[/CODE]

Non, ce peut-etre une variable locale a la fonction qui appelle toutes les autres (main() par exemple).

[psgman113]

j'ai proposé une autre solution au dessus

Non, ce peut-etre une variable locale a la fonction qui appelle toutes les autres (main() par exemple).
DaZumba est déconnecté(e) Envoyer un message privé Réponse avec citation

pas compris

[DaZumba]

C'est assez simple. Il suffit de faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
void decodage_msg(char *msg_code);
char *codage_msg(char *message);
char *saisie_msg(void);
 
int main(void)
{
   char *msg = saisie_msg();
   if (msg != NULL)
   {
      char *coded_msg = codage_msg(msg);
      if (coded_msg != NULL)
      {
         decode_msg(coded_msg);
         free(coded_msg);
      }
      free(msg);
   }
   return 0;
}

Evidemment, il faut s'assurer que les pointeurs retournes par codage_msg() et decode_msg() ne sont pas locaux a la fonction (un retour de malloc(), par exemple, fait tres bien l'affaire).

[Médinoc]

Ou bien, on peut travailler sur des buffers passés en paramètre, comme strcpy() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
char *codage_msg(char *dest, char const *source)
{
   if(source==NULL || dest==NULL)
      return NULL;
 
   /* Copier les caractères de source vers dest en les codant au passage. */
   /* ... */
   if(erreur)
      return NULL;
 
   /* À la fin, on retourne dest. */
   return dest;
}

[psgman113]

Et vous allouez pas de l'espace aux pointeurs avec malloc???

[psgman113]

Et vous allouez pas de l'espace aux pointeurs avec malloc???

Dans une fonction ,je fais appel à une autre fonction en procédant de la meme maniere que Dazumba:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
char * codage_msg(char *msg)
{
// decimal est bien un entier
char *chaine= conversion ( decimal); 
printf("%s\n",chaine); 
// il m'affiche pas la meme chose que la chaine pointée                           //par pointeur dans la fonction conversion!!
 
}
 
 
 
char * conversion (  int decimal)
{
char octet[9];
 
char *tempo;
..........
// je construit la le tableaut octet en oubliant pas le dernier caractere \0  
 
tempo=octet; // je met le pointeur en début de chaine
printf("%s",tempo);      // j'ai testé d'afficher la chaine pointée par tempo 
//  ca marche
return tempo;
}

[Thierry Chappuis]

Le problème, c'est que le tableau de caractères octet est local à la fonction conversion et la mémoire pour octet est allouée sur la pile. Cet espace mémoire est libéré lorsqu'on sort de la fonction. le pointeur tempo contient l'adresse du premier caractère de octet. Cette valeur est retournée par la fonction convertion et est récupérée par le pointeur chaîne, local à codage_chaine(). Malheureusement cette adresse ne correspond plus à l'endroit où se trouve ta chaîne de caractère, car l'espace mémoire en question a été libéré à la sortie de la fonction conversion(). Ainsi,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

printf("%s\n",chaine);

affiche probablement n'importe quoi!!!

Thierry

[psgman113]

D'où le besoin d'utiliser une variable globale ...

[Emmanuel Delahaye]

D'où le besoin d'utiliser une variable globale ...

Non. Mauvaise réponse à un vrai problème. La bonne réponse est de passer un paramètre ou de retourner l'adresse d'un bloc alloué dynamiquement.

[psgman113]

J'ai pourtant alloué de la memoire dynamique:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
 
 main(void) 
{
     char *coded_msg; 
    coded_msg= (char *)malloc (n * sizeof (char)) ;
 
.... 
//coded_msg a  bien été construit!
 
 
       printf(" %s\n",coded_msg);  // m'affiche une chaine de caracteres
         decodage_msg(coded_msg); 
 
}
 
void decodage_msg(char *msg_code)
{
 
printf("%s\n",msg_code); // il m'affiche rien
}