die dynamische Zuweisung/Freigabe von 2D & 3D-arrays

Ich weiß, über algorithmen zum reservieren/freigeben ein 2D-array dynamisch, allerdings bin ich mir auch nicht sicher ob das gleiche für 3D-arrays.
Mit diesem wissen und ein bisschen Symmetrie, kam ich mit den folgenden code.
(Ich hatte eine harte Zeit, Visualisierung in 3D, bei der Kodierung).

Bitte äußern Sie sich auf die Richtigkeit und schlage vor, keine bessere alternative (Effizienz-klug und intuitiv), falls vorhanden.
Außerdem denke ich, dass diese beiden 2D-und 3D-arrays zugegriffen werden kann wie normalerweise statische arrays wie arr2D[2][3] und
arr3D[2][3][2]. Richtig?

Code für 2D -

//allocate a 2D array
int** allocate2D(int rows,int cols)
{
    int **arr2D;
    int i;

    arr2D = (int**)malloc(rows*sizeof(int*));
    for(i=0;i<rows;i++)
    {
        arr2D[i] = (int*)malloc(cols*sizeof(int));
    }
}

//deallocate a 2D array
void deallocate2D(int** arr2D,int rows)
{
    int i;

    for(i=0;i<rows;i++)
    {
        free(arr2D[i]);
    }

    free(arr2D);
}

Code für 3D -

//allocate a 3D array
int*** allocate3D(int l,int m,int n)
{
int ***arr3D;
int i,j,k;

arr3D = (int***)malloc(l * sizeof(int **));

for(i=0;i<l;i++)
{
    arr3D[i] = (int**)malloc(m * sizeof(int*));
    for(j=0;j<m;j++)
    {
        arr3D[i][j] = (int*)malloc(n*sizeof(int));
    }
}

return arr3D;
}

//deallocate a 3D array
void deallocate3D(int arr3D,int l,int m)
{
    int i,j;

    for(i=0;i<l;i++)
    {
        for(int j=0;j<m;j++)
        {
            free(arr3D[i][j]);
        }
        free(arr3D[i]);
    }
    free(arr3D);
}

InformationsquelleAutor Ankur | 2009-12-01

11

Können Sie auch zuweisen ein array und berechne einzelnen Indizes. Dies erfordert weniger Zuweisung Anrufe und Ergebnissen sowohl eine geringere Fragmentierung und eine bessere cache-Nutzung.
```
typedef struct {
  int a;
  int b;
  int* data;
} Int2d;

Int2d arr2d = { 2, 3 };
arr2d.data = malloc(arr2d.a * arr2d.b * sizeof *arr2d.data);
```
Nun arr2d[r][c] wird arr2d.data[r * arr2d.b + c]. Die Freigabe ist eine single free() entfernt. Als bonus sind Sie sicher, dass Sie immer halten Sie Ihr dynamisches array von Größen mit Ihnen.

Hochgerechnet auf 3d:
```
typedef struct {
  int a;
  int b;
  int c;
  int* data;
} Int3d;

Int3d arr3d = { 2, 3, 4 };
arr3d.data = malloc(arr3d.a * arr3d.b * arr3d.c * sizeof *arr3d.data);

//arr3d[r][c][d]
//becomes:
arr3d.data[r * (arr3d.b * arr3d.c) + c * arr3d.c + d];
```
Sollten Sie Kapseln diese index-Operationen (und die (de-)Allokationen für diese Angelegenheit) in einer separaten Funktion oder ein makro.

(Die Namen für r, c, und d könnte besser sein—ich wollte für Zeile, Spalte und Tiefe. Während a, b und c sind die Grenzen Ihrer entsprechenden Abmessungen, die Sie vielleicht lieber etwas wie n1, n2, n3, oder auch ein array für Sie.)

Sie können auch reservieren, ein n-dimensionales array in einem einzelnen block groß genug, um enthalten sowohl Hinweise und Daten. So können Sie gehen, int ***** array = allocate (sizeof(int), 10, 10, 10, 10, 10, 0); die Verteilung der 5D int-array, und indizieren von array [a][b][c][d][e] ohne die Notwendigkeit der Berechnung der Indizes. Ich habe diese, wenn ich brauchte, um zu ersetzen, große Stapel von arrays heap diejenigen zu code funktioniert auf Handys mit begrenztem stack-Größe, ohne ernsthafte Anpassung an die code-Indizierung der arrays. Siehe hier: sourceforge.net/p/gnugos60/code/HEAD/tree/trunk/GNUGoS60/common/...

InformationsquelleAutor
4

arr3d sollte ein dreifach-Zeiger ist und nicht nur eine int. Ansonsten sieht Sie OK:
```
void deallocate3D(int*** arr3D,int l,int m)
{
    int i,j;

    for(i=0;i<l;i++)
    {
        for(int j=0;j<m;j++)
        {
                free(arr3D[i][j]);
        }
        free(arr3D[i]);
    }
    free(arr3D);
}
```
arr3D ist ein Zeiger-auf-Zeiger-auf-Zeiger, so arr3D[i] ist ein Zeiger-auf-Zeiger und arr3D[i][j] nur ein Zeiger. Ist es richtig zu release die niedrigste dimension, in einer Schleife zuerst, und dann hinauf in den Abmessungen bis arr3D selbst veröffentlicht.

Außerdem ist es mehr idiomatische geben malloc den sizeof-der Spitzen-Typ implizit. Statt:
```
  arr3D[i] = (int**)malloc(m * sizeof(int*));
```
Machen:
```
  arr3D[i] = (int**)malloc(m * sizeof(*arr3D[i]));
```
Und ja, solche dynamisch zugewiesen werden multidimensionale arrays zugegriffen werden kann, nur als statisch zugeordneten multi-dimensionale arrays.

+1 für die guten Tipps.

InformationsquelleAutor Eli Bendersky

Können Sie sehen den folgenden code:

#include <stdio.h>
#include <stdlib.h>

void main()
{
    // Array 3 Dimensions
    int x = 4, y = 5, z = 6;

    // Array Iterators
    int i, j, k;

    // Allocate 3D Array
    int *allElements = malloc(x * y * z * sizeof(int));
    int ***array3D = malloc(x * sizeof(int **));

    for(i = 0; i < x; i++)
    {
        array3D[i] = malloc(y * sizeof(int *));

        for(j = 0; j < y; j++)
        {
            array3D[i][j] = allElements + (i * y * z) + (j * z);
        }
    }

    // Access array elements
    for(i = 0; i < x; i++)
    {
        printf("%d\n", i);

        for(j = 0; j < y; j++)
        {
            printf("\n");

            for(k = 0; k < z; k++)
            {
                array3D[i][j][k] = (i * y * z) + (j * z) + k;
                printf("\t%d", array3D[i][j][k]);
            }
        }

        printf("\n\n");
    }

    // Deallocate 3D array
    free(allElements);
    for(i = 0; i < x; i++)
    {
        free(array3D[i]);
    }
    free (array3D);
}

Weitere details finden Sie unter diesem link 3d array

InformationsquelleAutor Ashwani K

Dies ist eine version der Idee in der Frage aber nur mit einem malloc, inspiriert durch die anderen Antworten. Es ermöglicht eine intuitive Nutzung der eckigen Klammern und einfache Reinigung. Ich hoffe, es macht nicht jeder compiler-Implementierung spezifische Annahme.

int main(int argc, char *argv[])
{
  int **array, i, j;
  array = allocate2d(3, 4);
  for (i = 0; i < 3; i++)
  {
    for (j = 0; j < 4; j++)
    {
      array[i][j] = j + i + 1;
    }
  }
  for (i = 0; i < 3; i++)
  {
    for (j = 0; j < 4; j++)
    {
      printf("array[%d][%d] = %d\n", i, j, array[i][j]);
    }
  }
  free(array);
  return EXIT_SUCCESS;
}

int **allocate2d(int x, int y)
{
  int i;
  int **array = malloc(sizeof(int *) * x + sizeof(int) * x * y);
  for (i = 0; i < x; i++)
  {
    array[i] = ((int *)(array + x)) + y * i;
  }
  return array;
}

InformationsquelleAutor Palas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.