Discussion :

[Oblivion0]

Bonjour à tous,

J'ai besoin de votre concernant un problème basique (je fais du C depuis 48h, je demande donc votre indulgence ) concernant une portée de variable. Ci-joint mon code dans lequel le main appelle une fonction AllocInitMat allouant l'espace mémoire pour 3 matrices. Cette fonction remplit également les trois matrices (de façon simpliste, pour l'exemple).

Mon problème est le suivant : Je peux très bien, après remplissage, dans la fonction imprimer le contenu des matrices. Cependant, je voudrais que celles-ci restent accessibles dans le main une fois l'exécution de la fonction terminée (pour par exemple les réutiliser dans une autre fonction, etc.).

L'erreur semble donc apparaître lorsque intervient (A semble disparu ou non accessible !):

Code :

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

  printf("%d", A[0][0]);

Que manque t-il à cet exemple ?

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
#include <stdlib.h>
#include <stdio.h>
 
void AllocInitMat(int** , int** , int** , int , int );
 
int main(void){
 
  int dimL = 0, dimC = 0, i = 0, j = 0;
  int** A = NULL;
  int** B = NULL;
  int** RES = NULL;
 
  // Récupération des dimensions
  printf("Nombre de lignes : "); scanf("%d", &dimL);
  printf("Nombre de colonnes : "); scanf("%d", &dimC);
 
  // Allocation et remplissage
  AllocInitMat(A, B, RES, dimL, dimC);
 
  printf("%d", A[0][0]);
 
  // Libération de la mémoire allouée
  free(A); free(B);  free(RES);
 
  return 0;
}
 
void AllocInitMat(int** matA, int** matB, int** matC, int nbL, int nbC){
  int i = 0, j = 0;
 
  matA = (int**)malloc(nbL*sizeof(int*));
  matB = (int**)malloc(nbL*sizeof(int*));
  matC = (int**)malloc(nbL*sizeof(int*));
 
  for (i = 0; i < nbL; i++){
    matA[i] = (int*)malloc(nbC*sizeof(int));
    matB[i] = (int*)malloc(nbC*sizeof(int));
    matC[i] = (int*)malloc(nbC*sizeof(int));
  }
 
  for (i = 0; i < nbL; i++){
    for (j = 0; j < nbC; j++){
      matA[i][j] = (i == j) ? 2 : 0;
      matB[i][j] = (i == j) ? 3 : 0;
      matC[i][j] = (i == j) ? 4 : 0;
    }
  }
  for (i = 0; i < nbL; i++){
    for (j = 0; j < nbC; j++) printf("[%d] ", matA[i][j]);
    printf("\n");
}

Merci beaucoup par avance pour votre aide !!

[Kraane]

Hello,

Je vais te dire pourquoi ça ne fonctionne pas.
Mais je ne te donnerai pas la solution, ce sera a toi de la trouver (c'est plus formateur).

Analysons ensemble ton code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
int main(void)
{
    // [...]
 
    int** A = NULL;
    int** B = NULL;
    int** RES = NULL;
 
    // [...]
}

Dans le main, tu déclares 3 variables, qui sont des pointeurs.
Chaque pointeurs correspond a une case mémoire.

Ta mémoire ressemble donc a ça:

| A** (NULL) | B** (NULL) | RES** (NULL) |

Code :

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

1
2
3
4
5
6
7
8
9
int main(void)
{
    // [...]
 
    // Allocation et remplissage
    AllocInitMat(A, B, RES, dimL, dimC);
 
    // [...]
}

Par la suite, tu passes ces 3 variables a ta fonction AllocInitMat.
Cependant, en C, les variables que tu passes en paramètre sont copiées. Elles ne référencent donc pas la même case mémoire!

Ta mémoire ressemble maintenant a cela:

| A** (NULL) | B** (NULL) | RES** (NULL) | A** copie (NULL) | B** copie (NULL)| RES** copie (NULL) |

Code :

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

1
2
3
4
5
6
7
8
9
10
void AllocInitMat(int** matA, int** matB, int** matC, int nbL, int nbC)
{
    // [...]
 
    matA = (int**)malloc(nbL*sizeof(int*));
    matB = (int**)malloc(nbL*sizeof(int*));
    matC = (int**)malloc(nbL*sizeof(int*));
 
    // [...]
}

Dans ta fonction AllocInitMat, lorsque tu alloues de la mémoire sur ces 3 variables, tu stock l'adresse dans la case de la variable copiée.

Ce qui donne:

| A** (NULL) | B** (NULL) | RES** (NULL) | A** copie (Adresse) | B** copie (Adresse) | RES** copie (Adresse) |


En sortant du scope de la fonction AllocInitMat, toutes les variables copiées sont détruite. Et par conséquent, tes adresses également.
Tu te retrouve donc avec les 3 premières cases que tu avais au debut:

| A** (NULL) | B** (NULL) | RES** (NULL) |


C'est pour cela que tu n'a plus accès a tes matrices dans le main.


Maintenant que tu connais la cause de ton problème, a toi de trouver une solution.
Il en existe plusieurs

[Oblivion0]

Merci de ta réponse !
Je pensais justement avoir anticipé ce type de problème de passage par valeur/passage par adresse en passant bien des pointeurs en entrée de la fonction !
Preuve que j'ai pas tout compris encore...
Cependant, je comprends bien qu'il faut modifier l'appel de la fonction pour que ça pointe vers le bon emplacement mémoire...

[Oblivion0]

J'en suis arrivé à ça qui marche. Mais s'il y'a plus simple je veux bien l'astuce.

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
 
#include <stdlib.h>
#include <stdio.h>
 
void AllocInitMat(int*** , int*** , int*** , int* , int* );
 
int main(void){
 
  int dimL = 0, dimC = 0;
  int i = 0, j = 0;
  int** A = NULL;
  int** B = NULL;
  int** RES = NULL;
 
  // Récupération des dimensions
  printf("Nombre de lignes : "); scanf("%d", &dimL);
  printf("Nombre de colonnes : "); scanf("%d", &dimC);
 
  // Allocation et remplissage
  AllocInitMat(&A, &B, &RES, &dimL, &dimC);
 
  // Test d'affichage/disponibilité de A
  for (i = 0; i < dimL; i++){
    for (j = 0; j< dimC; j++){
      printf("[%d] ", A[i][j]);
    }
  printf("\n");
  }
 
  // Libération de la mémoire allouée
  free(A); free(B); free(RES);
 
  return 0;
}
 
void AllocInitMat(int*** matA, int*** matB, int*** matC, int* nbL, int* nbC){
  int i = 0, j = 0;
 
  (*matA) = malloc(*nbL * sizeof *(*matA));
  (*matB) = malloc(*nbL * sizeof *(*matB));
  (*matC) = malloc(*nbL * sizeof *(*matC));
 
  for (i = 0; i < *nbL; i++){
    (*matA)[i] = malloc(*nbC * sizeof *(*matA)[i]);
    (*matB)[i] = malloc(*nbC * sizeof *(*matB)[i]);
    (*matC)[i] = malloc(*nbC * sizeof *(*matC)[i]);
  }
 
  for (i = 0; i < *nbL; i++){
    for (j = 0; j < *nbC; j++){
      (*matA)[i][j] = (i == j) ? 2 : 0;
      (*matB)[i][j] = (i == j) ? 3 : 0;
      (*matC)[i][j] = (i == j) ? 4 : 0;
    }
  }
}

[dalfab]

Bonjour,

Pour modifier un tableau de tableaux, il faut bien l'adresse d'un pointeur de pointeur.
Pour les tailles par contre, pourquoi les passer par pointeurs ?
Et il y beaucoup plus de malloc() que de free(), il manque beaucoup de free().

[Bousk]

Tu devrais utiliser des tableaux 1 dimension pour les matrices, et en découpant les fonctions ce serait plus simple : 1 fonction pour allouer la matrice, 1 pour la remplir, 1 pour l'afficher, etc.
Ton code est aussi un nid à fuites mémoire.

[Sve@r]

Bonjour

J'en suis arrivé à ça qui marche. Mais s'il y'a plus simple je veux bien l'astuce.

Ben déjà, au lieu de faire une fonction qui alloue les 3 matrices (avec un code donc répétitif dans la fonction) tu peux faire une fonction un peu plus générique qui alloue une matrice ; et l'appeler 3 fois. La fonction sera bien plus légère donc bien plus lisible.

Ensuite tu peux représenter chaque matrice par un tableau 1D. En effet, un tableau 2D, 3D, 4D, en mémoire, c'est toujours une suite de cases alignées donc une suite en une dimension.

L'avantage, c'est que tu t'embêtes plus avec tes malloc/free en cascade (d'autant plus qu'il faut les tester et prévoir une solution de nettoyage si le Xième malloc échoue => nettoyer alors tout ce qui a été alloué). En 1D, un seul malloc, un seul free.
Le petit inconvénient, c'est qu'il te faut ensuite convertir des coordonnées 2D (lig/col) en 1D pour taper au bon endroit. Et inversement, quand tu balayes ton tableau avec un indice "i", il te faut lui-aussi le convertir en lig/col pour savoir de quelle case 2D il s'agit. Mais c'est pas vraiment compliqué car dans le sens lig/col vers i alors i=lig * nb_col + col. Et dans l'autre sens i vers lig/col alors lig=i/nb_col et col=i%nb_col (nb_col étant le nombre de colonnes de ton tableau 2D). Et bien évidemment on trouve des formules similaires pour passer de 3D, 4D, 5D vers 1D.

[Obsidian]

J'ajoute également que lorsque l'on déclare dynamiquement des tableaux multidimensionnels, il est tout-à-fait possible de réserver la mémoire nécessaire en une fois avec malloc() puis de transtyper le pointeur renvoyé en pointeur sur un tableau multidimensionnel :

Code C :

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
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
 
int main (void)
{
    int (*ptr) [4][3];
    int i,j,k;
 
    printf("%lu\n",sizeof ptr);
    ptr = malloc(5*4*3*sizeof (int));
 
    for (i=0;i<60;i++) ((int *)ptr)[i] = i;
 
    for (i=0;i<5;i++)
    for (j=0;j<4;j++)
    for (k=0;k<3;k++) printf ("%d %d %d: %2d\n",i,j,k,ptr[i][j][k]);
 
    free (ptr),ptr=NULL;
    return 0;
}

C'est d'ailleurs un sujet qui revient régulièrement. La seule réelle contrainte est que cela oblige à fixer à l'avance les dimensions du tableau, ou d'utiliser les VLA pour redéfinir le pointeur à l'intérieur d'un bloc local à l'exécution, ce qui peut le rendre compliqué à transmettre d'une fonction à l'autre.

C'est aussi quelque chose qu'on évite d'aborder d'emblée (on devrait peut-être, d'ailleurs) avec quelqu'un qui n'a que 48 heures de C mais comme le primo-postant a l'air d'être expérimenté et de bien maîtriser ce qu'il nous présente, c'est peut-être la meilleure option.

[Oblivion0]

Merci à tous pour vos réponses et merci à Obsidian d'avoir anticipé ma question sur la possibilité éventuelle de faire un seul malloc( ) pour l'allocation de tableaux multi-D.

Cependant, il me reste un point en suspens concernant l'utilisation de free( ). En reprenant la première version du code proposé, pour faire les choses "correctement", étant donné qu'il y a 6 utilisations de malloc(), cela suppose qu'il faut obligatoirement 6 free() en fin de main ?

Code :

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

 free(A); free(B);  free(RES);

n'est pas suffisant ?

De même, si une fonction utilise deux fois malloc( ) et que cette même fonction est appelée trois fois, faut-il 6 free() ?

[Bousk]

- Tu n'as pas 6 malloc mais bien plus parce qu'ils sont dans une boucle

Code :

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

1
2
3
4
5
  for (i = 0; i < *nbL; i++){
    (*matA)[i] = malloc(*nbC * sizeof *(*matA)[i]);
    (*matB)[i] = malloc(*nbC * sizeof *(*matB)[i]);
    (*matC)[i] = malloc(*nbC * sizeof *(*matC)[i]);
  }

- Quand bien même tu n'aurais que 6 malloc, tu n'as toujours que 3 free dans ton code et non 6, donc t'es loin du compte et non c'est pas suffisant

[Obsidian]

De même, si une fonction utilise deux fois malloc( ) et que cette même fonction est appelée trois fois, faut-il 6 free() ?

Pour compléter ce que dit Bousk, malloc() et free() sont des fonctions système. Elles servent respectivement à allouer et à libérer une plage quelque part dans la mémoire disponible pour que l'on puisse s'en servir. Cela veut dire que ces notions sont complètement détachées de celles de tableau ou de matrices et, à dire vrai, le système d'exploitation n'a aucune idée de ce que tu vas en faire. C'est comme un prêt d'argent. :-) La seule chose qui est importante est que tu lui rendes à la fin de l'opération.

Donc, à chaque fois que tu vas appeler malloc(), le système va t'allouer un segment de mémoire quelque part. Le segment proprement dit est garanti d'être contigu et en un seul morceau, mais les différents segments ne seront pas consécutifs : chacun d'eux sera indépendant des autres et pourra se trouver n'importe où en mémoire. En outre, le système d'exploitation va conserver la trace de chaque segment alloué dans une table et c'est pour cela qu'il faut tous les libérer un par un.

À noter qu'il n'y a pas non plus de « structure objet » dotés d'une fonction-membre « destructeur » comme en C++ et langages postérieurs, qui se chargeraient de faire leur propre ménage et qui pourraient être appelés en cascades (un objet composés de sous-objets désallouerait ses ressources propres, puis détruirait ses sous-objets, ce qui conduirait ceux-ci à faire à leur tour leur propre ménage aussi). Donc, si tu fais un free() sur le tableau principal, tu ne vas pas avoir de free() implicites sur la valeur de chacune des cases qu'il contient. D'abord, parce que le système ne sait tout bonnement pas ce qu'il y a dans ces cases, ensuite parce que la libération du tableau principal ne signifie pas non plus que les sous-tableaux qu'il référence ne sont plus utilisés ailleurs. Surtout en environnement parallèle et/ou multi-threadé.


Là où l'on voit que le langage C a été très bien pensé mais où cela peut dérouter un peu les débutants également est que l'on constate que là où on peut atteindre le même résultat via deux approches légèrement différentes (tableaux de pointeurs ou tableaux multidimensionnels directement déclarés comme tels), la syntaxe va naturellement converger vers la même représentation aussi.

[Sve@r]

De même, si une fonction utilise deux fois malloc( ) et que cette même fonction est appelée trois fois, faut-il 6 free() ?

Hé oui (quoi que dans la pratique, je pense qu'il y aura plutôt une autre fonction qui fera deux free() et qu'on appellera trois fois). Autant de malloc, autant de free.

Et pire, il faut tester chaque malloc et prévoir une solution de repli si un malloc intermédiaire ne réussit pas. Et comme généralement l'allocation complète de tout l'ensemble conditionne toute la suite de l'algorithme, la solution de repli généralement envisagée est d'abandonner en libérant tout ce qui a été alloué correctement devenu inutile.

Donc généralement, on crée une fonction dédiée à l'allocation du tout, et une autre dédiée à la libération du même tout en s'arrangeant pour qu'elle puisse, en plus, distinguer ce qui a été alloué de ce qui ne l'a pas été. Par exemple si la fonction dédiée à l'allocation commence par mettre à NULL les pointeurs avant de les allouer, la fonction de libération pourra distinguer ceux qui sont alloués de ceux qui ne le sont pas encore si elle est appelée avant la fin normale du traitement.

Une autre façon de faire, si on veut tout faire (allocation, travail, libération) dans la même fonction est, en cas de libération anticipée, d'utiliser un goto vers la partie du code dédiée à la libération (et située généralement en fin de fonction évidemment).

[Oblivion0]

Merci Obsidian, ça répond parfaitement à ma question !