Wie Sie dynamisch reserviert einen zusammenhängenden block von Speicher für ein 2D-array

Wenn ich das zuordnen eines 2D-array wie folgt int a[N][N]; Sie weisen einen zusammenhängenden block von Speicher.

Aber wenn ich versuchen, es zu tun dynamisch wie diese :

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

Dieser verwaltet eine Einheit stride zwischen den Elementen in den Zeilen, aber dies kann nicht der Fall sein, zwischen den Zeilen.

One-Lösung ist die Konvertierung von 2D-zu-1D, außerdem gibt es einen anderen Weg, es zu tun?

Oh, und bitte, bitte, bitte nicht umgewandelt den Rückgabewert von malloc().
Mein Fehler, ich kopiere den code von c++ - thread xD

InformationsquelleAutor dreamcrash | 2012-11-23

arrays c multidimensional-array

20

Wenn Ihr array-Dimensionen zur Kompilierzeit bekannt:
```
#define ROWS ...
#define COLS ...

int (*arr)[COLS] = malloc(sizeof *arr * ROWS);
if (arr) 
{
  //do stuff with arr[i][j]
  free(arr);
}
```
Wenn Ihr array-Dimensionen zur Kompilierzeit nicht bekannt, und Sie sind mit einen C99-compiler oder ein C2011-compiler, unterstützt variable length arrays:
```
size_t rows, cols;
//assign rows and cols
int (*arr)[cols] = malloc(sizeof *arr * rows);
if (arr)
{
  //do stuff with arr[i][j]
  free(arr);
}
```
Wenn Ihr array-Dimensionen zur Kompilierzeit nicht bekannt, und Sie sind nicht Verwendung eines C99-compiler oder ein C2011-compiler, unterstützt variable-length-arrays:
```
size_t rows, cols;
//assign rows and cols
int *arr = malloc(sizeof *arr * rows * cols);
{
  //do stuff with arr[i * rows + j]
  free(arr);
}
```
+1, scheint dies ein guter Vorschlag - ich werde löschen "nicht möglich" Teil meiner Antwort...
Nette Antwort, vielen Dank für die Beantwortung.
Da der Benutzer mit der akzeptierten Antwort war löschen, tausche ich diese.
Wie würde ich mich übergeben, array an eine Funktion, oder zurück von einem? Ruft der compiler, was ist ein 'int(*)[cols]'.
im ersten Fall, der Prototyp wäre so etwas wie T foo( int (*arr)[COLS], size_t rows) wo COLS wird fest zur compile-Zeit (d.h. die Funktion kann nur auf arrays mit COLS Spalten). Im zweiten Fall, der Prototyp wäre so etwas wie T foo( size_t cols, int (*arr)[cols], size_t rows). cols müssen deklariert werden, bevor Sie verwendet werden können in der Erklärung zur arr. Im letzten Fall, der Prototyp wäre T foo( int *arr, size_t rows, size_t cols).

InformationsquelleAutor John Bode
8

In der Tat, n-dimensionale arrays (auf dem Stapel reserviert) sind wirklich nur 1-dimensionale Vektoren. Die mehrfache Indizierung ist nur syntaktischer Zucker. Aber Sie können schreiben, eine accessor-Funktion zu emulieren, so etwas wie das, was Sie wollen:
```
int index_array(int *arr, size_t width, int x, int y)
{
    return arr[x * width + y];
}

const size_t width = 3;
const size_t height = 2;
int *arr = malloc(width * height * sizeof(*arr));

//... fill it with values, then access it:

int arr_1_1 = index_array(arr, width, 1, 1);
```
Allerdings, wenn Sie C99 unterstützen, dann deklarieren Sie einen Zeiger auf ein array ist möglich, und Sie können sogar den syntaktischen Zucker:
```
int (*arr)[width] = malloc(sizeof((*arr) * height);
arr[x][y] = 42;
```
InformationsquelleAutor
4

Sagen, Sie wollen die dynamische Zuordnung ein 2-dimensionales integer array of ROWS Zeilen und COLS Spalten. Dann können Sie erst zuordnen, eine kontinuierliche Stück ROWS * COLS Ganzzahlen und dann manuell aufteilen in ZEILEN Zeilen. Ohne syntaktischen Zucker, das liest sich
```
int *mem = malloc(ROWS * COLS * sizeof(int));
int **A = malloc(ROWS * sizeof(int*));
for(int i = 0; i < ROWS; i++) 
   A[i] = mem + COLS*i;
//use A[i][j]
```
werden kann und effizienter durch die Vermeidung der Multiplikation,
```
int *mem = malloc(ROWS * COLS * sizeof(int));
int **A = malloc(ROWS * sizeof(int*));
A[0] = mem;
for(int i = 1; i < ROWS; i++) 
   A[i] = A[i-1] + COLS;
//use A[i][j]
```
Schließlich könnte man geben, bis der zusätzliche Zeiger insgesamt
```
int **A = malloc(ROWS * sizeof(int*));
A[0] = malloc(ROWS * COLS * sizeof(int));
for(int i = 1; i < ROWS; i++) 
   A[i] = A[i-1] + COLS;
//use A[i][j]
```
aber es ist ein wichtiger PUNKT! Sie würde vorsichtig sein müssen, um die ersten deallocate A[0] und dann Ein,
```
free(A[0]);
free(A);              //if this were done first, then A[0] would be invalidated
```
Die gleiche Idee kann erweitert werden, um 3 - oder höher-dimensionale arrays, obwohl der code chaotisch.

Pflege zu zeigen, wie zu erweitern, die Muster zu einem 3D-array?
Ich bin auch daran interessiert, wie diese generalisierten 3D!

InformationsquelleAutor Matei Tene
2

Können Sie behandeln, die dynamisch zugewiesenen Speicher als ein array von einem alle dimension durch den Zugriff auf Sie in Schritten:
```
int * a = malloc(sizeof(int) * N1 * N2 * N3);  //think "int[N1][N2][N3]"

a[i * N2 * N3 + j * N3 + k] = 10;              //like "a[i, j, k]"
```
Sie meinte sizeof(*a), richtig?
Du meinst sizeof *a? Manchmal mache ich das, aber es hängt von der phase des Mondes...

InformationsquelleAutor Kerrek SB

Entschuldigen Sie meine mangelnde Formatierung oder ein Fehler, aber das ist von einem Handy.

Ich auch festgestellt Fortschritte, wo ich versuchte zu verwenden, fwrite (), um die Ausgabe über die int** - variable, wie die src-Adresse.

War eine Lösung, um den Einsatz von zwei malloc () - Aufrufe:

#define HEIGHT 16
#define WIDTH 16
.
.
.
//allocate
int** data = malloc(HEIGHT*sizeof(int**));
int* realdata = malloc(HEIGHT*WIDTH*sizeof(int));
//manually index
for(int i = 0;i<HEIGHT;i++)
 data[i]=&realdata[i*WIDTH];

//populate
int idx = 0;
for(int i=0; i < HEIGHT; i++)
 for(int j=0; j < WIDTH; j++)
  data[i][j]=idx++;

//select
int idx=0;
for(int i=0; i < HEIGHT; i++){
 for(int j= 0; j < WIDTH; j++)
  printf("%i, ", data[i][j]);
 printf("/n");
}

//deallocate
.
.
.

InformationsquelleAutor Skullquake

Können Sie typedef array (weniger headake) und dann so etwas machen:

#include <stdlib.h>
#define N 10
typedef int A[N][N];
int main () {
  A a; //on the stack
  a[0][0]=1;
  A *b=(A*)malloc (sizeof(A)); //on the heap
  (*b)[0][0]=1;
}

InformationsquelleAutor pbhd

1

Die besten reservieren Sie einen Zeiger auf ein array,
```
int (*a)[cols] = malloc(rows * sizeof *a);
if (a == NULL) {
    //alloc failure, handle or exit
}

for(int i = 0; i < rows; ++i) {
    for(int j = 0; j < cols; ++j) {
        a[i][j] = i+j;
    }
}
```
Wenn der compiler nicht unterstützt variable length arrays, das funktioniert nur, wenn cols ist ein konstanter Ausdruck (aber dann sollten Sie aktualisieren Sie Ihren compiler sowieso).

InformationsquelleAutor Daniel Fischer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.