Problème avec un tableau (deux dimensions) de chaînes de caractères

Bonsoir,

J'ai écrit un programme dans lequel je manipule un tableau à deux dimensions contenant des chaînes de caractères. Hors, je n'arrive pas à utiliser la moindre fonction (strcpy, strlen…) si je lui passe une case du tableau en paramètre. J'ai systématiquement droit à un « segmentation fault ».

J'ai isolé et simplifié le bout de code suivant. Le tableau fait 9 * 2 cases dans cet exemple, et chaque chaîne à une taille maximale de 5 caractères (« \0 » compris).

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <string.h>   int main () { char **resultat ; int i, j ;   resultat = malloc (9 * 2 * 5 * sizeof (char)) ; for (i = 0 ; i < 9 ; i++) { for (j = 0 ; j < 2 ; j++) { strcpy (resultat [i * 2 * 5 + j * 5], "") ; } } }

---

Le problème vient du « strcpy ». J'ai parcouru faqs et tutoriaux en long, en large, en travers et en vain… Si une âme charitable pouvait m'expliquer…

J.-B.

Si je ne me trompes pas, c'est plutôt ton malloc qui foire..
resultat est un char**
donc pour le malloc fait plutôt :

Code:

---

1 2	resultat=malloc(9*2*5*sizeof(char*));

---

et Après tu fais une boucle pour allouer les resultat[i]

P.S.: Merci d'utiliser la balise [code] à l'avenir. ;)

Non, ça n'a pas résolu le problème.

En gros, c'est comme si, au lieu d'avoir un tableau à deux dimensions (18 cases) contenant des chaînes de caractères (5 caractères), j'avais un tableau à trois dimensions (72 cases) contenant des caractères. D'où mon « malloc » initial.

En faisant comme tu l'indiques, je réserve 72 cases contenant un pointeur vers un caractère, ce n'est pas ce que je veux.

En revanche, suivant ton idée, j'ai essayé :

Code:

---

resultat = malloc (9 * 2 * sizeof (char *)) ;

---

Mais ça ne change rien, toujours mon « segmentation fault ».

Par contre, je viens d'avoir une autre idée, je vais tester ça tout de suite…

J.-B.

Edit : Oups, désolé pour la balise !

Edit 2 : Mon idée n'a rien donné, je reste ouvert à toutes les suggestions…

Bon, en fait tu avais raison…

J'ai fait mon tableau de 18 cases, et j'ai refait un malloc dans le « for » pour allouer cette fois les 5 caractères de la chaîne que contient la case. Et ça marche…

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#include <string.h>   int main () { char **resultat ; int i, j ;   resultat = malloc (9 * 2 * sizeof (char *)) ;   for (i = 0 ; i < 9 ; i++) { for (j = 0 ; j < 2 ; j++) { resultat [i * 2 + j] = malloc (5 * sizeof (char)) ; strcpy (resultat [i * 2 + j], "") ; } } }

---

Merci en tout cas, je commençais à déprimer. ^^

J.-B.

Citation:

---

Envoyé par Albireo16A

J'ai fait mon tableau de 18 cases, et j'ai refait un malloc dans le « for » pour allouer cette fois les 5 caractères de la chaîne que contient la case. Et ça marche…

---

Et où sont les tests de retour des malloc??

Code:

---

1 2 3 4 5 6 7 8 9 10 11

char **resultat ; int i, j ;   resultat = malloc (9 * 2 * sizeof (char *)) ; if(resultat==NULL) { /*   Gestion de l'erreur   */ }

---

De plus, si ton tableau a une taille fixe, je ne vois pas l'intérêt du malloc surtout que t'es dans le main...

Code:

---

1 2 3 4 5 6 7

char resultat[18][5]; int i, j ;   /*   Plus de gestion d'erreur   */

---

Enfin,

Code:

---

strcpy (resultat [i * 2 + j], "") ;

---

Est inutilement compliqué :

Code:

---

resultat[i*2+j][0] = '\0';

---

Jc

Citation:

---

Envoyé par Albireo16A

Code:

---

1 2 3 4 5

char **resultat ; int i, j ;   resultat = malloc (9 * 2 * 5 * sizeof (char)) ;

---

---

Tu mélanges 2 concepts.

Le tableau dynamique de tableaux dynamique

Code:

---

1 2 3 4 5 6 7 8 9 10 11

/* creation d'un tableau de L x C elements de type T */ T** pp = malloc (sizeof *pp * L); if (pp != NULL) { size_t i; for (i = 0; i < L; i++) { pp[i] = malloc (sizeof *pp[i] * C); } ...

---

dont on accède aux éléments par pp[i][j], et le tableau dynamique linéaire de N dimensions :

Code:

---

1 2 3 4 5 6

/* creation d'un tableau de L x C elements de type T */ T * p = malloc (sizeof *T * L * C); if (p != NULL) { ...

---

dont on accède aux éléments par p[(i * C) + j].