Couper une chaine dans un tableau

**Z-fly** · 04/07/2008, 23h34

Bonjour,

J'ai ecris une petite fonction qui coupe une chaine de carractères et stocke les differentes parties dans un tableau.
Cela fonctionne trés bien en local, on peut envoyer autant de parties que l'on veut:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <arpa/inet.h>
#include <stdlib.h>
 
int separe_champs(char ch[],char **tab){
	char * s;
	int nbmot=0,i;
	s=strtok(ch,"-");
	tab[nbmot]=s;
	while (s != NULL){
			s=strtok(NULL,"-");
			if (s != NULL){ 
				nbmot++;
				tab=realloc(tab,(nbmot+1)*sizeof(char*));
				tab[nbmot]=s;
			}
	}
	for (i=0;i<=nbmot;i++){
		printf("separe_champs: champs %d : %s\n",i, tab[i]);
	}
 
	printf("\n");
 
	return(nbmot);
 }
 
int main() {
	char var1[200];
	char **tabchps;
	int i,n;
 
	printf("Entrez votre chaine :");
	scanf("%s",var1);
 
	tabchps=malloc(sizeof(char*));
 
	n=separe_champs(var1,tabchps);
	printf("\ntableau champs:\n");
	for (i=0;i<=n;i++){
		printf("champs %d : %s\n",i, tabchps[i]);
	}
 
	free(tabchps);
	printf("\n");
}

Mais le même code dans un contexte réseau ne fonctionne plus au dela de 3 parties, ce qui est genant

Le client envoi au serveur 5 chaine et le serveur separe les champs de la troisieme.
Quand je reparcours mon tableau dans le main le premier champs est null et fais uune erreur de segmentation apres!
Voici le serveur:

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
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
 
#include <stdio.h>
 
#include <sys/socket.h>
 
#include <netinet/in.h>
 
#include <string.h>
 
#include <arpa/inet.h>
#include <stdlib.h>
#include <time.h>
 
#include <dirent.h>
 
 
#define	MAXLINE		4096	/* max text line length */
#define	BUFFSIZE	8192	/* buffer size for reads and writes */
 
/* Following shortens all the typecasts of pointer arguments: */
#define	SA	struct sockaddr
 
int separe_champs(char ch[],char **tab);
 
int
main(int argc, char **argv)
{
	int					listenfd, connfd, n, i=0,nb=0;
	struct sockaddr_in	servaddr, cliaddr;
	socklen_t			len;
	char				buff[MAXLINE+1], recvline[MAXLINE +1];
 
 
	char				entre[BUFFSIZE];	
 
 
	listenfd = socket(AF_INET, SOCK_STREAM, 0);
 
	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family      = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port        = htons(25000);	
 
	bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
 
	listen(listenfd, 10);
	printf("ecoute sur le port 25000 ...\n\n");
	for ( ; ; ){
		char				**tablignes;
		char 				**tabchps;
 
		tabchps=malloc(sizeof(char*));
 
		tablignes=malloc(5*sizeof(char*));
		tablignes[0]=malloc(BUFFSIZE);	tablignes[1]=malloc(BUFFSIZE);
		tablignes[2]=malloc(BUFFSIZE);	tablignes[3]=malloc(BUFFSIZE);
		tablignes[4]=malloc(BUFFSIZE);
 
		len=sizeof(cliaddr);
		connfd = accept(listenfd, (SA *)&cliaddr, &len);
		printf("conexion de %s sur le port source %d\n",inet_ntop(AF_INET,&cliaddr.sin_addr,buff,sizeof(buff)),ntohs(cliaddr.sin_port));
  /***************************** 1  *****************************************/
		if ( (n = read(connfd, recvline, MAXLINE)) > 0) {
 
        		recvline[n] = 0;        
       		}
       	snprintf(tablignes[0],BUFFSIZE,recvline);				
		printf("1: '%s' recu\n",tablignes[0]);
		snprintf(buff, MAXLINE, "1 OK");		
		write(connfd, buff, strlen(buff));
/****************************** 2  **********************************/
		if ( (n = read(connfd, recvline, MAXLINE)) > 0) {
 
        		recvline[n] = 0;        
       		}
       	snprintf(tablignes[1],BUFFSIZE,recvline);
		printf("2: '%s' recu\n",tablignes[1]);
		snprintf(buff, MAXLINE, "2 OK");		
		write(connfd, buff, strlen(buff));        
/***************************** 3  ***********************************/
		if ( (n = read(connfd, recvline, MAXLINE)) > 0) {
 
        		recvline[n] = 0;        
       	}
       	snprintf(tablignes[2],BUFFSIZE,recvline);		
       	snprintf(entre, sizeof(entre), recvline);
		printf("3: '%s' recu\n",tablignes[2]);
		snprintf(buff, MAXLINE, "3 OK");		
		write(connfd, buff, strlen(buff));
/******************************* 4  **********************************/
		if ( (n = read(connfd, recvline, MAXLINE)) > 0) {
 
        	recvline[n] = 0;        
       	}
       	snprintf(tablignes[3],BUFFSIZE,recvline);
		printf("4: '%s' recu\n",tablignes[3]);
		snprintf(buff, MAXLINE, "4 OK");		
		write(connfd, buff, strlen(buff));
/******************************* 5  *******************************/
		if ( (n = read(connfd, recvline, MAXLINE)) > 0) {
 
        	recvline[n] = 0;        
       	}
       	snprintf(tablignes[4],BUFFSIZE,recvline);
		//fprintf(fmail,"Expediteur: '%s' recu\n",recvline);				
		printf("5: '%s' recu\n",tablignes[4]);
		snprintf(buff, MAXLINE, "5 OK");		
		write(connfd, buff, strlen(buff));
/************************************************************/    
 
			nb=separe_champs(entre, tabchps);
			for (i=0;i<nb;i++){
				//printf("il ya %d personnes en copie\n", nb);
				printf("main: champs %d : '%s'\n",i,tabchps[i]);
			}
		close(connfd);
	}
}
int separe_champs(char ch[],char **tab){
	char * s;
	int nbmot=0,i;
	s=strtok(ch,";");
	tab[nbmot]=s;
	while (s != NULL){
			s=strtok(NULL,";");
			if (s != NULL){ 
				nbmot++;
				tab=realloc(tab,(nbmot+1)*sizeof(char*));
				tab[nbmot]=s;
			}
	}
	for (i=0;i<=nbmot;i++){
		printf("fonction:champs %d : %s\n",i, tab[i]);
	}
 
	printf("\n");
 
	return(nbmot+1);
 }

Et voici le client:

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
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
 
#include <stdlib.h>
 
#include <stdio.h>
 
#include <string.h>
 
 
#include <sys/socket.h>
 
#include <netinet/in.h>
 
#include <arpa/inet.h>
 
#define	MAXLINE		4096	/* max text line length */
#define	BUFFSIZE	8192	/* buffer size for reads and writes */
 
/* Following shortens all the typecasts of pointer arguments: */
#define	SA	struct sockaddr
 
 
 int main(int argc, char **argv)
{
 int sockfd,n;
 char var1[200];
 char  buff[MAXLINE],  recvline[MAXLINE + 1], recvline2[MAXLINE + 1];
 
 struct sockaddr_in servaddr;
 
 
 if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
 
        printf("socket error");
 
 
 
    bzero(&servaddr, sizeof(servaddr));
 
    servaddr.sin_family = AF_INET;
 
    servaddr.sin_port = htons(25000);  /* daytime server */
 
    if (inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr) <= 0)
 
    	printf("inet_pton error for 127.0.0.1");
 
 
 
    if (connect(sockfd, (SA *) &servaddr, sizeof(servaddr)) < 0) {
    	perror("Impossible de se connecter au serveur!");
    	exit(0);
    }
    snprintf(buff, sizeof(buff),"rien");write(sockfd,buff,strlen(buff)); 
    if ( (n = read(sockfd, recvline, MAXLINE)) > 0) {
 
       recvline[n] = 0;        /* null terminate */
       printf("reçu:%s\n",recvline);
    }
    snprintf(buff, sizeof(buff),"rien");write(sockfd,buff,strlen(buff));   
  	if ( (n = read(sockfd, recvline, MAXLINE)) > 0) {
 
       recvline[n] = 0;        /* null terminate */
       printf("reçu:%s\n",recvline);
    }
    printf("Entrez la ligne avec ';'  pour separateur: "); // copie a
	scanf("%s",var1);
	printf("envoi du champs copie a\n");
	snprintf(buff, sizeof(buff),var1);
	write(sockfd,buff,strlen(buff)); 
 
 
    if ( (n = read(sockfd, recvline, MAXLINE)) > 0) {
 
       recvline[n] = 0;        /* null terminate */
       printf("reçu:%s\n",recvline);
    }
    snprintf(buff, sizeof(buff),"rien");write(sockfd,buff,strlen(buff)); 
    if ( (n = read(sockfd, recvline, MAXLINE)) > 0) {
 
       recvline[n] = 0;        /* null terminate */
       printf("reçu:%s\n",recvline);
    }
    snprintf(buff, sizeof(buff),"rien");write(sockfd,buff,strlen(buff)); 
    if ( (n = read(sockfd, recvline, MAXLINE)) > 0) {
 
       recvline[n] = 0;        /* null terminate */
       printf("reçu:%s\n",recvline);
    }
 
    return(EXIT_SUCCESS);
 
}

J'ai retourné le truc dans tous les sens je ne comprend pas.

**diogene** · 05/07/2008, 12h20

Serveur

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
for ( ; ; )
{
  char **tablignes;
  char **tabchps;
...
  nb=separe_champs(entre, tabchps);
  for (i=0;i<nb;i++)
  {
    printf("main: champs %d : '%s'\n",i,tabchps[i]);
  }
...
}

Après l'appel à separe_champs, la valeur de la variable tabchps n'est pas modifiée.
Si separe_champs réalloue la zone en changeant l'adresse du tableau, tabchps contient ensuite une adresse illégale

Code :

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

1
2
3
4
5
6
7
8
int separe_champs(char ch[],char **tab)
{
...
    if (s != NULL)
    { 
     nbmot++;
     tab=realloc(tab,(nbmot+1)*sizeof(char*));
...

Il faut que la fonction puisse modifier tabchps donc passer son adresse et modifier le code de separe_champs en conséquence.

**Z-fly** · 06/07/2008, 20h35

mille merci !!!

J'ai enfin pu comprendre mon erreur!

J'ai modifié ma fonction pour qu'elle renvoi l'adresse du nouveau tableau et ça fonctionne nickel

Ceci dit je ne pige pas pourquoi pour l'usage en locale cela fonctionne, l'adresse serait donc par hazard la même que le tableau finale lol

merci encore !!

**diogene** · 06/07/2008, 20h50

l'adresse serait donc par hazard la même que le tableau finale

cela arrive et dans ce cas pas de problèmes, mais ce n'est absolument pas garanti

Si la fonction qui fait le realloc peut étendre la zone allouée à partir de la même adresse de départ, alors pas de problèmes. Si on ne dispose pas à partir de cette adresse de la place suffisante pour réallouer, l'adresse de départ va changer et là il y aura problème.

Code :

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

1
2
3
 
tab=realloc(tab,(nbmot+1)*sizeof(char*));
tab[nbmot]=s;

Il est de bonne programmation de tester le retour du realloc (comme pour toute allocation d'ailleurs) avant de le réaffecter au pointeur d'origine. Sinon, en cas d'échec de la réallocation,
1- on va dans les décors (tab == NULL)
2- on perd l'adresse de la zone précédemment allouée

**Z-fly** · 06/07/2008, 21h11

Envoyé par diogene

Code :

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

1
2
3
 
tab=realloc(tab,(nbmot+1)*sizeof(char*));
tab[nbmot]=s;

Il est de bonne programmation de tester le retour du realloc (comme pour toute allocation d'ailleurs) avant de le réaffecter au pointeur d'origine. Sinon, en cas d'échec de la réallocation,
1- on va dans les décors (tab == NULL)
2- on perd l'adresse de la zone précédemment allouée

il faudrait faire quelquechose comme:

Code :

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

1
2
3
4
 
tabtemporaire=realloc(tab,(nbmot+1)*sizeof(char*));
(tabtemporaire==NULL)?perror("pas de memoire disponible!"):tab=tebtemporaire;
tab[nbmot]=s;

C'est juste ?

**diogene** · 06/07/2008, 21h31

Oui, je verrais plutôt la forme :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
tabtemporaire=realloc(tab,(nbmot+1)*sizeof(char*));
if(tabtemporaire==NULL)
{
// Eventuellemnt faire free(tab);
 perror("pas de memoire disponible!");
}
else
{
  tab=tebtemporaire;
  tab[nbmot]=s ;
...
}

Couper une chaine dans un tableau

Réseau C

Discussions similaires

Partager

Partager