Modification de la taille d'un tableau 3D avec realloc

Bonjour!

J'ai un petit problème concernant les tableaux en 3 dimensions dynamiques. Mon but est d'avoir un tableau 3D et d'ensuite modifier sa taille à l'aide d'une fonction. J'ai déjà alloué la mémoire pour mon tableau avec le code suivant:

Code:

---

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

//Création du tableau carte à 3 dimensions carte = (int ***)malloc(sizeof(int **) * NB_BLOCS_HAUTEUR*2); for (i = 0 ; i < NB_BLOCS_HAUTEUR*2; i++) { carte[i] = (int **)malloc(sizeof(int *) * NB_BLOCS_LARGEUR*2);   for (j = 0; j < NB_BLOCS_LARGEUR*2; j++) carte[i][j] = (int *)malloc(sizeof(int) * 3); } if (carte == NULL) //On test si l'allocation a fonctionné exit(0); //Si non, on quitte

---

Je veux ensuite envoyer le tableau carte à une fonction qui en modifie la taille (des 2 premières dimensions, la 3e reste de 3). Je sais comment procéder avec un tableau d'une dimension en utilisant realloc, mais à 3, je bloque. J'imagine que je dois utiliser un code du genre:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

changeCarteSize(carte, rows, cols); //Appel de la fonction (correct, j'espère)   int changeCarteSize(int ***carte, int rows, int cols) { int i = 0, j = 0, k = 0; //Création du tableau carte à 3 dimensions carte = (int ***)realloc(carte, sizeof(int **) * rows); for (i = 0 ; i < rows; i++) { carte[i] = (int **)realloc(carte, sizeof(int *) * cols);   for (j = 0; j < cols; j++) carte[i][j] = (int *)realloc(carte, sizeof(int) * 3); } if (carte == NULL) //On test si l'allocation a fonctionné exit(0); //Si non, on quitte   return 1; }

---

Ce code ne fonctionne cependant pas. J'imagine que mon utilisation de realloc est mauvaise, surtout que je lui envoie les trois fois le même pointeur carte, alors qu'il me semble que ce ne devrais pas être le cas, mais j'ignore quel pointeur envoyer sinon. Je suis un peu perdu dans tous ces pointeurs de pointeurs de pointeurs... Si vous avez des suggestions de code pour modifier les tailles d'un tableau à 3 dimensions, j'aimerais bien que vous me l'expliquiez.
Merci d'avance pour votre aide!

Bonsoir,

Code:

---

1 2 3

if (carte == NULL) //On test si l'allocation a fonctionné exit(0); //Si non, on quitte

---

Et si carte[0][0] == NULL ?

Il faut verifier l'integralité du tableau

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

changeCarteSize(carte, rows, cols); //Appel de la fonction (correct, j'espère)   int changeCarteSize(int ***carte, int rows, int cols) { int i = 0, j = 0, k = 0; //Création du tableau carte à 3 dimensions carte = (int ***)realloc(carte, sizeof(int **) * rows); for (i = 0 ; i < rows; i++) { carte[i] = (int **)realloc(carte, sizeof(int *) * cols);   for (j = 0; j < cols; j++) carte[i][j] = (int *)realloc(carte, sizeof(int) * 3); } if (carte == NULL) //On test si l'allocation a fonctionné exit(0); //Si non, on quitte   return 1; }

---

Ah ? pourquoi ne pas tester le retour de ta fonction ?

Bref, si tu passe ton tableau comme ceci :

Code:

---

1 2	int changeCarteSize(int ***carte, int rows, int cols)

---

Et bien ... tu pourra changer le contenu mais pas le contenant.
Si tu veux changer la taille du tableau, il faut "rajouter un niveau d'etoile".

Grosso modo, essaye

Code:

---

1 2	int changeCarteSize(int ***(*carte), int rows, int cols)

---

en remplacant tout les

Code:

---

1 2

carte...

---

par

Code:

---

1 2	(*carte)...

---

Soit N lignes de M colonnes les anciennes dimensions du tableau.
Tu veux avoir rows lignes et cols colonnes.

1- Tu réalloues rows lignes :

Code:

---

carte = realloc(carte, sizeof(int **) * rows);

---

2- Les N premières lignes ont déjà M colonnes allouées et il faudra faire un realloc de ces colonnes.
Les lignes de N à rows - 1 n'ont pas de colonnes allouées et il faudra faire un malloc des colonnes pour ces lignes.
Le plus simple étant peut-être de mettre à NULL les (nouveaux) pointeurs de N à rows - 1 puis de faire un realloc pour tout le monde.
Dans tout les cas, cela impose de connaitre N !

Code:

---

1 2 3

carte[i] = NULL; (i = N .. rows-1) carte[i] = realloc(carte[i], sizeof(int *) * cols); (i = 0 .. rows-1)

---

3- Les lignes 0 à N-1 ont leurs colonnes M à cols - 1 incomplètes : Il faut allouer 3 int

Code:

---

1 2	carte[i][j] = malloc( sizeof(int) * 3); (i = 0..N-1; j = M..cols-1)

---

4- les lignes N à rows - 1 ont toutes leurs colonnes incomplètes

Code:

---

1 2	carte[i][j] = malloc( sizeof(int) * 3); (i = N..rows-1; j = 0..cols-1)

---

Merci beaucoup pour vos réponses!

SofEvans, tu as raison, ma vérification de l'allocation de mémoire était erronée. Je ne suis cependant pas sûr d'avoir compris la partie sur la nécessité de rajouter "un niveau d'étoile". Si j'appelle ma fonction avec

Code:

---

1 2	changeCarteSize(carte, rows, cols);

---

et que son prototype est

Code:

---

1 2	int changeCarteSize(int ***(*carte), int rows, int cols);

---

Le compilateur me renvoie une erreur ('int ****' differs in levels of indirection from 'int ***') Si j'envoie &carte à la place de carte lors de mon appel, le programme compile sans erreur. Je ne saisi pas vraiment ce que &carte représente cependant et je suis septique sur cette procédure. Si tu pouvais m'expliquer ce point, ce serait apprécié.

Diogene, ton algorithme semble très valide, je n'avais pas pensé à ça. Je vais l'essayer et j'en redonne des nouvelles. Merci beaucoup pour cette solution détaillée. Si tu as des idées quant à l'appel de la fonction et son prototype (comme mentionné plus haut), ton avis est également apprécié.

Cet algo n'est valable que si tu agrandis les dimensions du tableau. Si tu diminues une (ou plusieurs) valeur, il faut prendre des précautions pour éviter des fuites mémoires.

En ce qui concerne le prototype, la fonction doit fournir la nouvelle adresse du tableau, soit par sa valeur de retour (qui serait alors int***), ou par la liste des paramètres (qui serait alors int ****).
Dans le premier cas l'appel est de la forme

Code:

---

carte = changeCarteSize(carte,...)

---

et dans le second

Code:

---

changeCarteSize(&carte,...)

---

J'ai finalement réussi à écrire ma fonction! Pour l'instant, elle est faite pour agrandir le tableau seulement, je vais bientôt plancher sur le cas ou sa taille diminue. Merci infiniment pour votre aide!

Une dernière petite question sur le sujet:

Si on a pas besoin de garder l'information dans le tableau originel, est-ce qu'une fonction du genre est fonctionnelle?

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

int changeCarteSize(int ****carte, int rows, int cols) { int i = 0, j = 0; int ***tmp;   //Allocation du tableau 3D tmp = (int ***)malloc(sizeof(int **) * rows); for (i = 0 ; i < rows; i++) { tmp[i] = (int **)malloc(sizeof(int *) * cols);   for (j = 0; j < cols; j++) tmp[i][j] = (int *)malloc(sizeof(int) * 3); }   free((*carte));   *carte = tmp; }

---

Le code compile et roule comme il faut, mais je me demandais s'il n'y avait pas fuite de mémoire, car à la fin de la fonction, est-ce que la mémoire où pointe ***tmp est libérée (comme ***tmp est local à la fonction)? Si c'est le cas, carte pointe alors vers de la mémoire qui n'est plus alloué et on a un problème... Donc selon vous, est-ce que cette fonction est correcte?

Il vaut mieux faire la désallocation avant de faire la nouvelle allocation (question d'occupation mémoire).

Le free(*carte) est tout à fait insuffisant pour libérer la mémoire précédemment allouée : Tu dois désallouer les tableaux de 3 int ((*carte)[i][j]) avant les colonnes ((*carte)[i]) puis les lignes (*carte). Ceci impose de connaitre les dimensions de l'ancien tableau (au moins le nombre de colonnes, puisqu'une des trois dimensions est fixe 3 et on n'a pas besoin de connaitre le nombre de lignes).

Je te suggère de regrouper toutes les informations concernant le tableau dans une structure, ça te simplifiera la vie si ces dimensions peuvent changer

Code:

---

1 2 3 4 5 6

typedef struct { int *** tab; size_t rows; size_t cols; } Tableau;

---

Tu devrais faire également une fonction qui réalise l'allocation. En voici une version simplifiée (dans le cas de l'utilisation d'une structure)

Code:

---

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

Tableau * CreerCarte( size_t rows, size_t cols) { // attention pour simplifier, le test des allocations n'est pas fait // La fonction doit être complétée pour le faire. // C'est impératif. size_t i , j ; Tableau * tab = malloc(sizeof *tab); tab->tab = malloc(rows * sizeof *tab->tab); for (i = 0 ; i < rows; i++) { tab->tab[i] = malloc(cols *sizeof ** tab->tab); for (j = 0; j < cols; j++) tab->tab[i][j] = malloc(3*sizeof ***tab->tab); } tab->rows = rows; tab->cols = cols; return tab; }

---

et également une fonction qui réalise la libération (de toute façon tu en auras besoin). Toujours avec la structure :

Code:

---

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

void LibererCarte(Tableau * tab) { size_t i,j; for(i=0; i<tab->rows;i++) { for(j=0; j<tab->cols;j++) { free(tab->tab[i][j]); } free(tab->tab[i]); } free(tab->tab); free(tab); }

---

Alors si tu adoptes la recréation d'un tableau plutôt que le redimensionnement :

Code:

---

1 2 3 4 5

Tableau * changeCarteSize(Tableau *tab, int rows, int cols) { LibererCarte(tab); return CreerCarte(rows,cols); }

---

Très bonne idée, l'utilisation de structures. Merci bien pour ces explications détaillées, j'ai maintenant pas mal compris comment jongler avec les tableaux dynamiques et la mémoire en C!