dynamische Speicherzuweisung für die 3D-Array

Question

mögliche Dubletten:
Malloc a 3-Dimensional array in C?
dynamic allocation/deallocation of 2D & 3D arrays

Wie kann ich 3D-Arrays malloc zurechnen?

Answer 1

array = malloc(num_elem * num_elem * num_elem * sizeof(array_elem)); 

Warum nicht? :)

Answer 2

Dies würde

int main() 
{ 

    int ***p,i,j; 

    p=(int ***) malloc(MAXX * sizeof(int **)); 

    for(i=0;i<MAXX;i++) 
    { 
     p[i]=(int **)malloc(MAXY * sizeof(int *)); 
     for(j=0;j<MAXY;j++) 
      p[i][j]=(int *)malloc(MAXZ * sizeof(int)); 
    } 

    for(k=0;k<MAXZ;k++) 
     for(i=0;i<MAXX;i++) 
      for(j=0;j<MAXY;j++) 
       p[i][j][k]=<something>; 
} 

Answer 3

arbeitet Es gibt zwei verschiedene Möglichkeiten, um einen 3D-Array zuzuordnen. Sie können es entweder als ein 1D-Array von Zeigern einem (1D-Array von Zeigern zu einem 1D-Array) zuordnen. Dies kann folgendermaßen geschehen:

int dim1, dim2, dim3; 
int i,j,k; 
double *** array = (double ***)malloc(dim1*sizeof(double**)); 

     for (i = 0; i< dim1; i++) { 

     array[i] = (double **) malloc(dim2*sizeof(double *)); 

      for (j = 0; j < dim2; j++) { 

       array[i][j] = (double *)malloc(dim3*sizeof(double)); 
      } 

     } 

Manchmal ist es sinnvoller, das Array als zusammenhängendes Chunk zuzuordnen. Sie werden feststellen, dass viele vorhandene Bibliotheken möglicherweise erfordern, dass das Array im zugewiesenen Speicher vorhanden ist. Der Nachteil davon ist, dass, wenn Ihr Array sehr groß ist, Sie möglicherweise nicht einen so großen zusammenhängenden Chunk im Speicher haben.

const int dim1, dim2, dim3; /* Global variables, dimension*/ 

#define ARR(i,j,k) (array[dim2*dim3*i + dim3*j + k]) 
double * array = (double *)malloc(dim1*dim2*dim3*sizeof(double)); 

Um Ihre Array zugreifen Sie nur das Makro verwenden:

ARR(1,0,3) = 4; 

Answer 4

Für einen bestimmten Typ T (nicht zusammenhängende):

size_t dim0, dim1, dim2; 
... 
T ***arr = malloc(sizeof *arr * dim0); //type of *arr is T ** 
if (arr) 
{ 
    size_t i; 
    for (i = 0; i < dim0; i++) 
    { 
    arr[i] = malloc(sizeof *arr[i] * dim1); // type of *arr[i] is T * 
    if (arr[i]) 
    { 
     size_t j; 
     for (j = 0; j < dim1; j++) 
     { 
     arr[i][j] = malloc(sizeof *arr[i][j] * dim2); 
     } 
    } 
    } 
} 

Es sei denn, Sie arbeiten mit einem sehr alten (Pre-C89) Implementierung, müssen Sie nicht das Ergebnis malloc() zu werfen, und die Praxis wird abgeraten. Wenn Sie vergessen, stdlib.h einzuschließen oder keinen Prototyp für malloc() im Geltungsbereich haben, gibt der Compiler es ein, um int zurückzugeben, und Sie werden eine Warnung vom Typ "inkompatible Typ für Zuweisung" erhalten. Wenn Sie das Ergebnis umsetzen, wird die Warnung unterdrückt, und es gibt keine Garantie dafür, dass eine Konvertierung von einem Zeiger auf einen int Zeiger wieder sinnvoll ist.

Answer 5

@Poita_, ok, vielleicht haben Sie recht, aber wenn jemand noch 3-dimensionales Array will in einem großen Teil zugeordnet verwenden, ist hier, wie Sie fügen normale Indizierung es:

void*** newarray(int icount, int jcount, int kcount, int type_size) 
{ 
    void*** iret = (void***)malloc(icount*sizeof(void***)+icount*jcount*sizeof(void**)+icount*jcount*kcount*type_size); 
    void** jret = (void**)(iret+icount); 
    char* kret = (char*)(jret+icount*jcount); 
    for(int i=0;i<icount;i++) 
     iret[i] = &jret[i*jcount]; 
    for(int i=0;i<icount;i++) 
     for(int j=0;j<jcount;i++) 
      jret[i*jcount+j] = &kret[i*jcount*kcount*type_size+j*kcount*type_size]; 
    return iret; 
}