Erreur dans memset () un tableau 3D

J’alloue dynamicment un tableau 3D:

int n1=2,n2=5,n3=3; int in1,in2,in3; float ***a; a = (float ***)malloc(n1*sizeof(float **)); for (in1=0;in1<n1;in1++) a[in1] = (float **)malloc(n2*sizeof(float *)); for (in1=0;in1<n1;in1++) for (in2=0;in2<n2;in2++) a[in1][in2] = (float *)malloc(n3*sizeof(float));

Après cela, je veux initialiser ce tableau 3D. La manière conventionnelle est:

 for (in1=0; in1<n1; in1++) for (in2=0; in2<n2; in2++) for (in3=0; in3<n3; in3++) a[in1][in2][in3] = 1.0f;

Cependant, si je veux utiliser memset() pour initialiser le tableau, cela semble irréalisable car la première entrée est * ptr. Donc si j’écris

 memset(a[0],1,n1*n2*n3*sizeof(float));

La première entrée a [0] est un ** ptr, ce qui est faux. Si j’écris:

 memset(a[0][0],1,n2*n3*sizeof(float));

La première entrée est un * ptr, mais il n’y a plus de dimension n1.

Je me demande donc si memset() ne peut être utilisé que pour initialiser une masortingce 2D?

** Je comprends que memset ne peut pas être utilisé sur un tableau 3D, mais pour un tableau 2D, je pense que c’est faisable. Voici un exemple:

 int n1=2,n2=5; int in1,in2; float **a; a = (float **)malloc(n1*sizeof(float *)); for (in1=0;in1<n1;in1++) a[in1] = (float *)malloc(n2*sizeof(float)); memset(a[0],0,n1*n2*sizeof(float)); free(*a);free(a);

Ce n’est pas non plus une mémoire contiguë? Mais cela peut donner un résultat correct.

Votre “tableau 3D” n’est pas vraiment un tableau de tableaux comme le memset . Si nous le dessinons, cela ressemblera à quelque chose comme ça:

      + ------ + ------ + ----- + ----------- +
 a -> |  un [0] |  a [1] |  ... |  a [n1 - 1] |
      + ------ + ------ + ----- + ----------- +
              |
              v
              + --------- + --------- + ----- + -------------- +
              |  a [1] [0] |  a [1] [1] |  ... |  a [1] [n2 - 1] |
              + --------- + --------- + ----- + -------------- +
               |
               v
              + ------------ + ------------ + ----- + ----------------- +
              |  a [1] [0] [0] |  a [1] [0] [1] |  ... |  a [1] [0] [n3 - 1] |
              + ------------ + ------------ + ----- + ----------------- +

Cette disposition s’appelle également des tableaux déchiquetés . Mais quel que soit le nom memset , votre appel memset s’attend à ce que la mémoire que vous écrivez soit contiguë, ce que votre “tableau 3D” ne correspond pas .

En bref, vous ne pouvez pas utiliser memset pour initialiser vos tableaux.

Il existe des moyens d’en faire une zone de mémoire contiguë, mais vous ne pouvez plus utiliser d’indexation de tableaux, mais vous devez utiliser l’arithmétique pour calculer chaque index.

memset ne peut être utilisé que pour atsortingbuer une valeur à un bloc de mémoire contigu, ce que votre tableau 3D n’est pas. De la manière dont vous l’avez créé, vous créez de nombreux blocs de mémoire distincts et, surtout, les blocs contenant les valeurs réelles ne seront pas proches les uns des autres.

Vous pouvez créer le tableau en une allocation comme celle-ci

 float *big_chunk=malloc(sizeof(float)*n1*n2*n3);

et alors vous pouvez utiliser memset avec et vous référence dans comme ça

 big_chunk[x*n1+y*n2+z]=some_value;