allouer dynamiquement tableau 3d

Question

Je suis un peu confus au sujet de l'allocation dynamique d'un tableau 3d. En ce moment, je suis juste attribution d'un grand bloc de mémoire comme ceci:

int height = 10; 
int depth = 20; 
int width = 5; 

int* arr; 
arr = new int[height * width * depth]; 

Maintenant, je voudrais changer une valeur dans le tableau 3D, par exemple:

//arr[depth][width][height] 
arr[6][3][7] = 4; 

Cependant, je peux n'utilisez pas le code ci-dessus pour changer la valeur. Comment puis-je utiliser un seul index pour accéder à l'élément à profondeur de position = 6, largeur = 3, hauteur = 7?

arr[?] = 4; 

Existe-t-il un meilleur moyen d'allouer dynamiquement un tableau 3D?

Answer 1

Pour index dans le tableau 3 dimensions à plat:

arr[x + width * (y + depth * z)] 

où x, y et z correspondent à la première, deuxième et troisième les dimensions respectivement et la largeur et la profondeur sont la largeur et la profondeur du tableau. Il s'agit d'une simplification de x + y * WIDTH + z * WIDTH * DEPTH.

Answer 2

C façon inclinée de le faire est:

int ***arr = new int**[X]; 
for (i = 0; i < z_size; ++i) { 
    arr[i] = new int*[Y]; 
    for (j = 0; j < WIDTH; ++j) 
    arr[i][j] = new int[Z]; 
} 

Answer 3

Pour avoir un mécanisme simple d'indexation comme arr [hauteur] [largeur] [profondeur], et aussi des valeurs par défaut dans la mémoire allouée à initialiser à 0, s'il vous plaît essayez ce qui suit:

// Dynamically allocate a 3D array 
/* Note the parenthesis at end of new. These cause the allocated memory's 
    value to be set to zero a la calloc (value-initialize). */ 
    arr = new int **[height](); 
    for (i = 0; i < height; i++) 
    { 
     arr[i] = new int *[width](); 
     for (j = 0; j < width; j++) 
      arr[i][j] = new int [depth](); 
    } 

et voici la désaffectation correspondante:

//Dynamically deallocate a 3D array 

for (i = 0; i < rows; i++) 
{ 
    for (j = 0; j < columns; j++) 
     delete[] arr[i][j]; 
    delete[] arr[i]; 
} 
delete[] arr; 

Answer 4

Allocation et récupération pour un tableau 3D (en tas) sont exactement le contraire de l'autre. La principale chose à retenir, tout en libérant correctement la mémoire, est d'utiliser les mots-clés delete autant de fois que le mot-clé new a été utilisé. Voici mon code pour l'initialisation et le nettoyage d'un tableau 3D:

int ***ptr3D=NULL; 
ptr3D=new int**[5]; 

for(int i=0;i<5;i++) 
{ 
    ptr3D[i] = new int*[5]; 

    for(int j=0;j<5;j++) 
    { 
     ptr3D[i][j]=new int[5]; 

     for(int k=0;k<5;k++) 
     { 
      ptr3D[i][j][k]=i+j+k; 
     } 
    } 
} 
//Initialization ends here 
... 
... //Allocation of values 

cout << endl <<"Clean up starts here " << endl; 

for(int i=0;i<5;i++) 
{ 
    for(int j=0;j<5;j++) 
    { 
     delete[] ptr3D[i][j]; 
    } 
    delete[] ptr3D[i]; 
} 
delete ptr3D; 

Notez que pour 3 new mots-clés, 3 mots-clés correspondants delete ont été utilisés. Cela devrait nettoyer toute la mémoire allouée au tableau 3D dans le tas et Valgrind peut être utilisé pour le vérifier à chaque étape.