probleme avec fonction decoupe

Version imprimable

Bonjour à tous, :yaisse2:

Je viens vous demander votre aide car j'en ai marre des "core dumped" en tentant de créer une fonction qui découpe une chaine de caractère en un tableau de "mots" :cry:

Je vous montre ma fonction (qui à l'air pourtant simple à faire)
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 #include <stdio.h> #include <string.h> #include <unistd.h> #include <stdlib.h> char** decoupe(char* chaine){ char** t = (char**)malloc(5*sizeof(char*)); char* morceau; morceau = strtok(chaine," "); while (morceau != NULL){ int i=0; t[i]=morceau; i++; morceau=strtok(NULL," "); } return t; free(t); } int main() { char** tableau=decoupe("toto bibi keke"); printf("salut je mapelle %s",tableau[1]); }
Désolé pour le main() et les "toto bibi keke", c'est uniquement pour tester la fonction :P

Merci de votre aide

Citation:
Envoyé par teufa14
Je viens vous demander votre aide car j'en ai marre des "core dumped" en tentant de créer une fonction qui découpe une chaine de caractère en un tableau de "mots" :cry:

Je vous montre ma fonction (qui à l'air pourtant simple à faire)
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 #include <stdio.h> #include <string.h> #include <unistd.h> #include <stdlib.h> char** decoupe(char* chaine){ char** t = (char**)malloc(5*sizeof(char*)); char* morceau; morceau = strtok(chaine," "); while (morceau != NULL){ int i=0; t[i]=morceau; i++; morceau=strtok(NULL," "); } return t; free(t); } int main() { char** tableau=decoupe("toto bibi keke"); printf("salut je mapelle %s",tableau[1]); }
Désolé pour le main() et les "toto bibi keke", c'est uniquement pour tester la fonction :P

Merci de votre aide
Il faut que la chaine soit modifiable.

Soit tu passes une chaine modifiable :
Code:

1 2 3 4 5 6 7 int main() { char chaine[] = "toto bibi keke"; char** tableau=decoupe(chaine); printf("salut je mapelle %s",tableau[1]); }
soit tu fais une copie locale avec strdup() :
Code:

1 2 3 4 5 6 7 8 char** decoupe(char const * chaine_ori) { char *chaine = strdup (chaine_ori); char** t = (char**)malloc(5*sizeof(char*)); char* morceau; morceau = strtok(chaine," ");
Le cast est inutile... Par contre, il manque les vérifications d'usage (toute allocation peut échouer).

Attention aussi à la libération ... et le i est trop 'local'. Il est remis à 0 à chaque tour...

07/11/2007, 17h30
teufa14

ah d'accord. J'essairai cela demain à l'IUT. Il est vrai que la chaîne que j'ai passé n'est pas modifiable, je n'avais pas pensé à ça...

Merci de ton aide :D

Me revoici, j'espère que je ne vous dérange pas.

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
 
/*Fonction qui découpe une chaine de caractères en un tableau de mots*/
 
char** decoupe(char* chaine){
 
       char** tableau = NULL;
       /*Allocation de mémoire pour le tableau*/
       tableau = malloc(10*sizeof(char*));
       /*On teste sur l'allocation a bien fonctionné*/
       if (tableau == NULL){
                   perror("Erreur lors du malloc()");
                   exit(0);
                   }
       /*Si elle a bien fonctionné, on continue...*/
       char* morceau = NULL;
       morceau = strtok(chaine," ");
 
       int cpt = 0;
       while (morceau != NULL){
             tableau[cpt] = morceau;
             morceau = strtok(NULL," ");
             }
 
       char**t = tableau;
       free(tableau);
 
       return t;
 
}

Je précise que je dois réaliser un projet de messagerie instantanée en cours, c'est pour cela que j'ai besoin que cette fonction soit correcte...
Je précise aussi que j'ai un peu de mal avec les pointeurs :lol:

Voilà je voudrais juste avoir votre avis, si vous voyez des fautes ou non...

Merci de votre aide

07/11/2007, 18h33
Emmanuel Delahaye

Citation:

Envoyé par teufa14

Je précise aussi que j'ai un peu de mal avec les pointeurs :lol:

Voilà je voudrais juste avoir votre avis, si vous voyez des fautes ou non...

cpt n'avance pas...

Il y a une grosse faute de libération. La fonction ne peut pas libérer le bloc dont elle retourne l'adresse. C'est à l'appelant de le faire...

D'autre part, que se passe-t-il si la chaine a plus de 10 mots ?

Tu devrais commencer par compter les mots, puis allouer le tableau de pointeurs (avec un de plus pour terminer par un pointeur NULL, par exemple)...
07/11/2007, 20h04
teufa14

Oups désolé j'ai oublié en effet le cpt++, la fatigue peut-être :?.
Ma fonction n'utilisera jamais plus de 10 mots, il y en aura 2 ou 3 au maximum.
Pour le free, je dois le mettre dans la fonction appelant ma fonction découpe c'est bien ça? (je suis désolé de te poser autant de questions mais j'aimerais bien réussir mon projet... :()

Je te remercie encore une fois pour ton aide

Citation:

Envoyé par teufa14

Pour le free, je dois le mettre dans la fonction appelant ma fonction découpe c'est bien ça?

Oui.

Une base de départ :

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
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
/* Fonction qui découpe une chaine de caractères en un tableau de mots*/
char **decoupe (char *chaine)
{
   /*Allocation de mémoire pour le tableau */
   char **tableau = malloc (10 * sizeof (char *));
 
   /*On teste sur l'allocation a bien fonctionné */
   if (tableau != NULL)
   {
      /*Si elle a bien fonctionné, on continue... */
      char *morceau = NULL;
      morceau = strtok (chaine, " ");
 
      int cpt = 0;
      while (morceau != NULL)
      {
         tableau[cpt] = morceau;
         cpt++;
         morceau = strtok (NULL, " ");
      }
   }
 
   return tableau;
}
 
int main (void)
{
   char chaine[] = "toto bibi keke";
   char **tableau = decoupe (chaine);
   if (tableau != NULL)
   {
      printf ("salut je m'apelle '%s'\n", tableau[0]);
      printf ("salut je m'apelle '%s'\n", tableau[1]);
      printf ("salut je m'apelle '%s'\n", tableau[2]);
      free (tableau), tableau = NULL;
   }
   else
   {
      perror ("Erreur lors du malloc()");
   }
 
   return 0;
}

Mais en fait, comme le tableau a une taille fixe, il pourrait être défini par l'appelant :

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
 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
/* Fonction qui découpe une chaine de caractères en un tableau de mots*/
void decoupe (char **tableau, char *chaine)
{
   char *morceau = strtok (chaine, " ");
   int cpt = 0;
   while (morceau != NULL)
   {
      tableau[cpt] = morceau;
      cpt++;
      morceau = strtok (NULL, " ");
   }
}
 
int main (void)
{
   char chaine[] = "toto bibi keke";
   char *tableau[10];
 
   decoupe (tableau, chaine);
 
   printf ("salut je m'apelle '%s'\n", tableau[0]);
   printf ("salut je m'apelle '%s'\n", tableau[1]);
   printf ("salut je m'apelle '%s'\n", tableau[2]);
 
   return 0;
}

Ce qui est nettement plus simple... On pourrait passer le nombre max d'éléments du tableau et retourner le nombre effectif...

07/11/2007, 20h35
droggo

Lio,

Citation:

Envoyé par teufa14

Ma fonction n'utilisera jamais plus de 10 mots, il y en aura 2 ou 3 au maximum.

Mais prévoir les exceptions ne fait pas de mal, et faire une fonction plus généraliste donne de bonnes habitudes. :)
07/11/2007, 21h23
teufa14

D'accord.

J'essairais de corriger mon programme demain. Je vous dis un grand merci pour votre aide, surtout à toi Emmanuel, tu m'a bien éclairé :D

Je m'y remettrai demain après les cours (malheureusement pour moi cette fonction est loin d'être la plus compliquée dans le projet que j'ai à faire, et vu mon allergie au C ... :lol:).

Bonne soirée à tous

Bonsoir à tous,

Je suis toujours sur mon projet en C, et j'avance à petits pas (mon niveau en C n'est vraiment pas terrible :().

Je voulais demander si quelque aurait le courage de bien regarder le début de mon code, c'est-à-dire la fonction main tout en bas ainsi que le début de la fonction interp_commande.

J'ai mis tout mon code exprès afin que vous puissiez comprendre un peu le "contexte" du programme.

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
/* Pour printf et fgets */
#include <stdio.h>
/* Pour strcmp */
#include <string.h>
/* Pour fork, pipe et exec */
#include <unistd.h>
/* Pour malloc, free, exit ... */
#include <stdlib.h>
 
/*Fonction qui découpe une chaine de caractères en un tableau de mots*/
char **decoupe (char *chaine)
{
   /*Allocation de mémoire pour le tableau */
   char **tableau = malloc (10 * sizeof (char *));
 
   /*On teste sur l'allocation a bien fonctionné */
   if (tableau != NULL)
   {
      /*Si elle a bien fonctionné, on continue... */
      char *morceau = NULL;
      morceau = strtok (chaine, " ");
 
      int cpt = 0;
      while (morceau != NULL)
      {
         tableau[cpt] = morceau;
         cpt++;
         morceau = strtok (NULL, " ");
      }
   }
 
   return tableau;
 
/*
 * Interpréteur de commandes, renvoie 1 si il faut quitter
 * l'application, 0 sinon.
 */
int interp_commande(char* ligne, char* mon_nom) {
 
	/* découpage de la ligne de commande en un tableau de mots */
	char **tableau = NULL;
	tableau = decoupe(ligne);
	commande = tableau[0];
	char *mon_nom = tableau[1];
 
  switch (commande) {
  case 'p':
		pid_t pid;
 
		/* Tester si il y a bien un nom en argument*/
		if (mon_nom == NULL)
		         {
                 perror("Pas de nom en argument.");
                 return quit = 1;
                 }
           /*Remarque: ce test a déjà été effectué dans le 'main()'*/
 
		/* pour parler il faut creer 2 processus, chacun devant executer
			 une fenetre de dicussion */
 
		/* Création du 1er processus fils*/
		pid = fork();
		if (pid < 0) {
			perror("fork");
		} else if (!pid) {
			/* Code du premier processus fils */
			int moi_vers_autre[2];
 
			/* creation des DEUX tuyaux de communication (pipe) */
			if (pipe(moi_vers_autre) < 0) {
				perror("pipe moi vers autre");
				/* quitter */
				return 1;
			}
			//...
 
			/* creation d'un 2eme processus */
			//...
 
			if (pid) {
				/* 1er processus (fenetre 1 : autre) */
 
				/* fermeture des DEUX extrémités du pipe non utilisées */
				close(moi_vers_autre[1]);
				//...
 
				/* Ecriture des DEUX descripteurs des pipe dans des chaines */
				sprintf(spfdin, "%d", moi_vers_autre[0]);
				//...
 
			} else {
				/* 2eme processus (fenetre 2 : moi) */
				/* fermeture des DEUX extrémités du pipe non utilisées */
				//...
 
				/* Ecriture des DEUX descripteurs des pipe dans des chaines */
				//...
 
			}
			/* Retour dans les 2 processus fils (fenetres 1 et 2) */
 
			/* Creation du titre de la fenetre de dicussion */
			sprintf(...);
 
			/* Execution des 2 processus de discussion dans des terminaux
				 graphiques. Utiliser le terminal 'xterm' avec l'option '-T'
				 pour donner un titre a la fenetre et l'option '-e' pour donner
				 la commande a executer */
			execlp(...);
 
			/* Si exec() retourne c'est qu'il y a eu une erreur */
			perror("exec");
		} /* Retour dans le pere (PMI) */
 
    break;
  case 'q':
		return 1;
		break;
  default:
		//...
  }
 
	/* Liberation de la mémoire occupée par le tableau d'arguments (args) */
	free(tableau);
  /* Retourner en signalant que l'on ne quitte pas le processus */
	//return ...
}
 
int main(int argc, char **argv) {
	int quit = 0;
 
	/* Faire un test de présence du nom d'utilisateur en argument */
	if (argc != 2)
	         {
             printf("Erreur. Pas de nom d'utilisateur en argument");
             }
 
	/* Boucle d'interprétation ds commandes */
  while(!quit) {
        char[64]=ligne;
		/* afficher un prompt */
		printf("> ");
 
		/* Lecture d'une ligne */
		fgets(ligne,64,stdin);
 
		/* Suppression du retour chariot */
		lgrChaine = strlen(ligne);
		ligne[lgrChaine - 1] = '\0';
 
		/* Interprétation de la ligne de commande */
    quit = interp_commande(ligne, argv[1]);
  }
 
}

Je ne vous demande en aucun cas de faire le boulot à ma place. J'aimerais juste que vous m'aidiez en me disant si je tiens le bon bout où non...

Merci de votre aide

10/11/2007, 15h30
teufa14

Bonjour tout le monde,

Si j'ai mis tout le code comprenez bien que ce n'est pas pour que vous fassiez mon boulot, mais uniquement pour que vous compreniez le contexte de ma fonction decoupe. J'aimerais justement savoir si celle-ci effectue bien ce que j'attends d'elle, et si elle est appelée correctement dans ma fonction inter_commande (juste au début de cette fonction).

Voilà, j'espère que vous pourrez m'aider.

Merci de votre aide,

Teufa14

Quelques commentaires :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
int interp_commande(char* ligne, char* mon_nom) {
	/* découpage de la ligne de commande en un tableau de mots */
	char **tableau = NULL;
	tableau = decoupe(ligne);
	commande = tableau[0]; 
// Attention, decoupe peut retourner NULL et tableau est alors NULL
// commande non défini char* commande =
	char *mon_nom = tableau[1];
	
  switch (commande) {
  case 'p':.......
// Non, commande est un char* , l'adresse d'une chaîne de caractères, et non pas un caractère

J'ai effectué quelques modifications en suivant tes remarques.

Ceci est-il plus correct ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*
 * Interpréteur de commandes, renvoie 1 si il faut quitter
 * l'application, 0 sinon.
 */
int interp_commande(char* ligne, char* mon_nom) {
 
	/* découpage de la ligne de commande en un tableau de mots */
	char **tableau = NULL;
	*tableau = decoupe(ligne);
 
	if (*tableau != NULL)
	{
	char *commande = tableau[0];
	char *mon_nom = tableau[1];
	}
	else
	{
	perror("Erreur, la fonction decoupe a retourné NULL");
	return 1;
	}
 
  switch (*commande) {
  case 'p':

La ligne "char *mon_nom = tableau[1];" n'est-elle pas inutile dans le fait que mon_nom est passé en paramètre de la fonction?

12/11/2007, 18h01
diogene
Code:

1 2 3 4 5 int interp_commande(char* ligne, char* mon_nom) { /* découpage de la ligne de commande en un tableau de mots */ char **tableau = NULL; *tableau = decoupe(ligne);
decoupe renvoie un char**, pas un char *. Je pense qu'on devrait avoir
Code:

1 2 char **tableau = decoupe(ligne); if (tableau != NULL)
Citation:

La ligne "char *mon_nom = tableau[1];" n'est-elle pas inutile dans le fait que mon_nom est passé en paramètre de la fonction?

Je n'en sais pas si l'information qui t'interesse ici est le paramètre ou dans le tableau. Toi, tu devrais le savoir.
12/11/2007, 18h02
Emmanuel Delahaye
Citation:

Envoyé par teufa14

J'ai effectué quelques modifications en suivant tes remarques.

Ceci est-il plus correct ?

Non.
Citation:
Code:

1 2 3 4 5 6 /* int interp_commande(char* ligne, char* mon_nom) { /* découpage de la ligne de commande en un tableau de mots */ char **tableau = NULL; *tableau = decoupe(ligne);
tableau vaut NULL, donc *tableau invoque un comportement indéterminé. T'es mort.

Si tu as du mal avec les pointeurs, commence par des choses plus simple que les tableaux de pointeurs...
12/11/2007, 19h02
teufa14

Oui en effet j'ai beaucoup de mal avec les pointeurs... :cry:

Ok je vais donc revoir (pour la n-ième fois :?) mon cours sur les pointeurs, je pense que c'est la partie qui me pose le plus de problèmes et qui m'empêche d'avancer...

Désolé de vous déranger, en effet c'est à moi de tout d'abord relire mon cours avant de vous montrer mon code, ça sera plus constructif :)

Bonne soirée à tous !