Problème pour remplir un tableau de string

Version imprimable

Bonjour,

Tout d'abord, voici le code :

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
void ImpDiffUnComp( char *TypCompImp, char AttrImp, tSchema *SchemaPtr, tSchema *Schema2Ptr, int TypeDiff, ListeDetail *liste, Tableau_Recap *recap )
{
	/* variables locales */
	tBoolean SousType;
	tBoolean PremEquiv; /* premier d'une liste de composants equivalents avec
                          numero consecutifs ( pour les 2 schemas )           */
	int 	PremInd;   	/* indice du 1er composant a traiter dans TabSchema */
	int 	DernInd;   	/* indice du dernier composant a traiter dans TabSchema */
	int 	IndTab;    	/* indice courant dans le tableau */
 
	/* corps fonction */
	/* entete suivant le type de composant et l'attribut */
	TeteEltDiff ( TypeDiff );
	PremEquiv = FALSE;
 
	char* test;
 
	int i = initialiser_Detail(TypeDiff, liste, recap);
	char *remplissage_donnees[i];
	int cpt = 0;
	remplissage_donnees[0] = "test";
	/* Intervalle du tableau des composants suivant le type de composant */
	/* un sous type existe pour les E/S */
	switch (TypeDiff/10)
	{
	case 0 :
	case 2 :
		SousType = TRUE;
		IntervTab ( ENTREE, SchemaPtr, &PremInd , &DernInd );
		break;
 
	case 7 :
		SousType = FALSE;
		IntervTab ( EDV, SchemaPtr,	&PremInd , &DernInd );
		break;
 
	case 1 :
	case 3 :
		SousType = TRUE;
		IntervTab ( SORTIE, SchemaPtr, &PremInd , &DernInd );
		break;
 
	case 5 :
	case 6 :
		SousType = TRUE;
		IntervTab ( STATION, SchemaPtr,	&PremInd , &DernInd );
		break;
	case 4 :
		SousType = FALSE;
		IntervTab ( OPERATEUR, SchemaPtr, &PremInd , &DernInd );
		break;
	}
 
	for ( IndTab = PremInd; IndTab <= DernInd; IndTab ++ )
	{	
		if ( (SchemaPtr->TabSchema[IndTab].Attribut == AttrImp ) &&
				( (SousType == FALSE ) ||
						(SchemaPtr->TabSchema[IndTab].TypeComposant[1] == TypCompImp[1])
				)   )
		{
			if (AttrImp == 'E')  /* equivalents, on n'imprime que le 1er d'une
                               liste consecutives de composants */
			{
				if ( PremEquiv == FALSE )
				{
					test = ImpLigDiff( SchemaPtr, Schema2Ptr, IndTab, TypeDiff );
					printf("test : %s\n",test);
					PremEquiv = ListeEquiv ( SchemaPtr, IndTab, DernInd );
					PremEquiv = FALSE;
					/* Modif Th.P car non comprehensible sur listing
                 if ( PremEquiv == TRUE )
                 ImpLigTab ("...|...|...");      */
				}
				else
					if ( ListeEquiv ( SchemaPtr, IndTab, DernInd ) == FALSE )
					{
						test = ImpLigDiff( SchemaPtr, Schema2Ptr, IndTab, TypeDiff );
						printf("test : %s\n",test);
						/* Modif Th.P car non comprehensible sur listing
                   PremEquiv = FALSE;            */
					}
			}
			else
			{
				test = ImpLigDiff( SchemaPtr, Schema2Ptr, IndTab, TypeDiff );					
				printf("test : %s\n",test);
			}
			remplissage_donnees[cpt] = test;
			cpt++;
		}
	}	
	int j;
	for (j = 0;j<i;j++){
		printf("TAB : %s\n",remplissage_donnees[j]);
	}
	FermerTableau();
	SautLigne(4);
 
	return;
}

Je souhaite récupérer une chaîne de caractères via la fonction ImpLigDiff dans un char* test.
( la fonction renvoie bien elle aussi, un char* )
Une fois cette ligne récupérée, je la mets dans un tableau (remplissage_donnees) de type char**.
Le problème est qu'à la fin (lorsque je boucle sur le tableau avant de sortir de la fonction), toutes les lignes sont écrasées par la dernière ligne reçue
Pourtant le compteur augmente bien, j'ai vérifié....
et les printf("test..) donne bien à chaque fois une chaîne différente...

Auriez-vous une idée du problème ?

Merci d'avance

19/05/2011, 23h56
Sve@r

Citation:

Envoyé par Mescalito50

Une fois cette ligne récupérée, je la mets dans un tableau (remplissage_donnees) de type char**.

Code:

remplissage_donnees[cpt] = test

Le problème est qu'à la fin (lorsque je boucle sur le tableau avant de sortir de la fonction), toutes les lignes sont écrasées par la dernière ligne reçue
Pourtant le compteur augmente bien, j'ai vérifié....
et les printf("test..) donne bien à chaque fois une chaîne différente...

Auriez-vous une idée du problème ?

Un char * n'est qu'une adresse, rien de plus. Donc quand tu copies ton "test" dans ton char**, (avec ton simple "="), tu ne fais que recopier une adresse et non la chaine qui s'y trouve...

Citation:

Envoyé par Mescalito50

( la fonction renvoie bien elle aussi, un char* )

Oui mais ce n'est pas suffisant. Si le char* qu'elle renvoie est une variable allouée alors ça va. Mais il te faudra ensuite penser, en fin de traitement, à libérer les zones récupérées.
Si maintenant la zone est une static (ce que pour ma part je présuppose), alors il n'y a qu'une seule et même zone à chaque fois réécrasée. Mais toi, tu ne récupères que l'adresse de la zone et non son contenu.

Autre façon d'expliquer: imagine qu'il y ait dans ton bureau de Poste une case n° 157 qui te sois réservée.
La fonction "ImpLigDiff" c'est l'employé postal qui a un colis pour toi et qui le met dans ta case 157 et qui, ensuite, te préviens que tu as un colis case 157. Toi, ton travail ce serait de récupérer le colis pour l'amener chez-toi mais tout ce que tu fais, c'est simplement de noter "penser à récupérer colis case 157" dans ton carnet.
Puis l'employé "ImpLigDiff" a un nouveau colis => il enlève d'abord le colis précédent qui prend toute la place puis place le nouveau colis dans la case 157 puis te téléphone en te disant "vous avez un colis case 157". Et toi, au lieu de récupérer le colis ben tu notes de nouveau "penser à récupérer colis case 157" dans ton carnet.
Le jour où tu vas finalement à ton bureau de poste récupérer "les" différents colis qui sont tous indiqués dans ton carnet, ben tu ne récupères que le dernier...

Remplace

Code:

remplissage_donnees[cpt] = test

par

Code:

strcpy(remplissage_donnees[cpt], test)
20/05/2011, 09h37
Mescalito50

Oui, merci, on m'a fait remarqué mon erreur.
Bêtement, j'ai lu sur différents sites que char *tab[] est un tableau composé de string, donc j'avais supposé que char* permettait de récupérer une string sans définir de taille ( donc éviter les tableaux et malloc ).
J'aurai dû revenir aux bases des pointeurs, plutôt que voir la solution de facilité :)

Pour la première ligne que tu as citée, j'ai compris ce que tu m'as dit mais ça marchait quand même....

Edit : Je viens de remplacer mon char* par un tableau char tab[20].
J'ai fait un sprintf pour remplir ce tableau avec les bonnes valeurs dans l'autre fonction.
Résultat : Dans toutes les cases, j'ai toujours que la dernière ligne. Donc ça n'a pas changé..

Edit 2 : J'ai remplacé

Code:

char *remplissage_donnees[i];

par

Code:

char remplissage_donnees[i][20];

et ça fonctionne.

Par contre, pouvez-vous m'expliquer pourquoi sur certains sites, ils font des char *tab[i] qui contiennent des string et qui fonctionnent ?
C'est parce que l'initialisation est faite en même temps ? (contrairement à mon code où l'on pourrait alors penser que j'ai fait un pointeur sur la première case du tableau)
20/05/2011, 12h11
diogene

Citation:

Par contre, pouvez-vous m'expliquer pourquoi sur certains sites, ils font des char *tab[i] qui contiennent des string et qui fonctionnent ?

char *tab[] définit un tableau de pointeurs sur char. Ce tableau ne peut pas contenir les chaines de caractères mais uniquement leur adresse. Les chaines de caractères sont ailleurs.

On trouve effectivement ce genre de choses lors d'initialisation comme ici :

Code:

char const * tab[] = {"chaine1", "chaine2", NULL};

les deux chaines sont quelque part (en mémoire non modifiable, d'où le const que j'ai ajouté par précaution) et leur adresse de début sont dans tab[0] et tab[1].
J'ai rajouté, comme exemple, dans tab[2] l'adresse NULL pour bien montrer que ce sont des adresses qui sont stockées.
20/05/2011, 15h48
Mescalito50

Donc si j'ai bien compris.
En fait dans ce type de tableau, on définit des pointeurs qui pointent sur les string que l'on souhaite accéder.

Donc dans tout exemple tab[0], qui est un pointeur de type char, pointe à l'adresse où se situe la string "chaine1" .

C'est bien ça ?
20/05/2011, 18h06
diogene

Oui