Wie werden mehrdimensionale Arrays im Speicher formatiert?

In C weiß ich, dass ich ein zweidimensionales Array auf dem Heap mithilfe des folgenden Codes dynamisch zuordnen kann:

int** someNumbers = malloc(arrayRows*sizeof(int*));

for (i = 0; i < arrayRows; i++) {
    someNumbers[i] = malloc(arrayColumns*sizeof(int));
}

Dies erzeugt eindeutig ein eindimensionales Array von Zeigern auf eine Reihe separater eindimensionaler Arrays von ganzen Zahlen, und "The System" kann herausfinden, was ich meine, wenn ich frage:

someNumbers[4][2];

Aber wenn ich statisch ein 2D-Array deklariere, wie in der folgenden Zeile ...:

int someNumbers[ARRAY_ROWS][ARRAY_COLUMNS];

... wird eine ähnliche Struktur auf dem Stapel erstellt oder hat sie eine vollständig andere Form? (dh ist es ein 1D-Array von Zeigern? Wenn nicht, was ist es und wie werden Verweise darauf herausgefunden?)

Und als ich "The System" sagte, was ist eigentlich dafür verantwortlich, das herauszufinden? Der Kernel? Oder sortiert der C-Compiler dies beim Kompilieren?

Ein statisches zweidimensionales Array sieht aus wie ein Array von Arrays - es ist nur zusammenhängend im Speicher angeordnet. Arrays sind nicht dasselbe wie Zeiger, aber da Sie sie häufig austauschbar verwenden können, kann es manchmal verwirrend werden. Der Compiler behält jedoch den Überblick, wodurch alles gut ausgerichtet ist. Sie müssen mit statischen 2D-Arrays, wie Sie sie erwähnen, vorsichtig sein, denn wenn Sie versuchen, eines an eine Funktion zu übergeben, die einen int **Parameter verwendet, werden schlimme Dinge passieren. Hier ist ein kurzes Beispiel:

int array1[3][2] = {{0, 1}, {2, 3}, {4, 5}};

Im Gedächtnis sieht es so aus:

0 1 2 3 4 5

genau das gleiche wie:

int array2[6] = { 0, 1, 2, 3, 4, 5 };

Wenn Sie jedoch versuchen, array1auf diese Funktion zuzugreifen:

void function1(int **a);

Sie erhalten eine Warnung (und die App kann nicht richtig auf das Array zugreifen):

warning: passing argument 1 of ‘function1’ from incompatible pointer type

Weil ein 2D-Array nicht dasselbe ist wie int **. Das automatische Zerfallen eines Arrays in einen Zeiger geht sozusagen nur "eine Ebene tief". Sie müssen die Funktion wie folgt deklarieren:

void function2(int a[][2]);

oder

void function2(int a[3][2]);

Um alles glücklich zu machen.

Das gleiche Konzept erstreckt sich auf n- dimensionale Arrays. Die Nutzung dieser Art von witzigem Geschäft in Ihrer Anwendung erschwert jedoch im Allgemeinen nur das Verständnis. Also sei da draußen vorsichtig.

Die Antwort liegt auf der Idee , dass C nicht wirklich hat 2D - Arrays - es hat Arrays-of-Arrays. Wenn Sie dies deklarieren:

int someNumbers[4][2];

Sie möchten someNumbersein Array von 4 Elementen sein, wobei jedes Element dieses Arrays vom Typ ist int [2](was selbst ein Array von 2 ints ist).

Der andere Teil des Puzzles besteht darin, dass Arrays immer zusammenhängend im Speicher angeordnet sind. Wenn Sie fragen nach:

sometype_t array[4];

dann wird das immer so aussehen:

| sometype_t | sometype_t | sometype_t | sometype_t |

(4 sometype_t nebeneinander angeordnete Objekte ohne Zwischenräume). In Ihrem someNumbersArray von Arrays sieht es also so aus:

| int [2]    | int [2]    | int [2]    | int [2]    |

Und jedes int [2]Element ist selbst ein Array, das so aussieht:

| int        | int        |

Insgesamt erhalten Sie also Folgendes:

| int | int  | int | int  | int | int  | int | int  |

unsigned char MultiArray[5][2]={{0,1},{2,3},{4,5},{6,7},{8,9}};

im Speicher ist gleich:

unsigned char SingleArray[10]={0,1,2,3,4,5,6,7,8,9};

Als Antwort auf Ihre Frage auch: Beides, obwohl der Compiler den größten Teil des schweren Hebens erledigt.

Bei statisch zugewiesenen Arrays ist "The System" der Compiler. Der Speicher wird wie für jede Stapelvariable reserviert.

Im Fall des malloc'd-Arrays ist "The System" der Implementierer von malloc (normalerweise der Kernel). Der Compiler weist lediglich den Basiszeiger zu.

Der Compiler wird den Typ immer so behandeln, wie er deklariert ist, außer in dem Beispiel, das Carl gegeben hat, wo er die austauschbare Verwendung herausfinden kann. Wenn Sie ein [] [] an eine Funktion übergeben, muss davon ausgegangen werden, dass es sich um eine statisch zugewiesene Wohnung handelt, wobei ** als Zeiger auf Zeiger angenommen wird.

Nehmen wir an , wir haben a1und a2definiert und initialisiert wie unter (c99):

int a1[2][2] = {{142,143}, {144,145}};
int **a2 = (int* []){ (int []){242,243}, (int []){244,245} };

a1ist ein homogenes 2D-Array mit einem einfachen kontinuierlichen Layout im Speicher, und der Ausdruck (int*)a1wird als Zeiger auf sein erstes Element ausgewertet:

a1 --> 142 143 144 145

a2wird aus einem heterogenen 2D-Array initialisiert und ist ein Zeiger auf einen Wert vom Typ int*, dh der Dereferenzierungsausdruck wird *a2zu einem Wert vom Typ ausgewertet. Das int*Speicherlayout muss nicht kontinuierlich sein:

a2 --> p1 p2
       ...
p1 --> 242 243
       ...
p2 --> 244 245

Trotz völlig unterschiedlicher Speicherlayouts und Zugriffssemantik sieht die C-Sprach-Grammatik für Array-Zugriffsausdrücke für homogene und heterogene 2D-Arrays genau gleich aus:

• Ausdruck a1[1][0]holt Wert 144ausa1Array
• Ausdruck a2[1][0]holt Wert 244aus a2Array

Der Compiler weiß, dass der Zugriffsausdruck für den a1Typ bearbeitet int[2][2], wenn der Zugriffsausdruck für den a2Typ bearbeitet int**. Der generierte Assemblycode folgt der homogenen oder heterogenen Zugriffssemantik.

Der Code stürzt normalerweise zur Laufzeit ab, wenn ein Array vom Typ int[N][M]typisiert und dann als Typ aufgerufen wird int**, zum Beispiel:

((int**)a1)[1][0]   //crash on dereference of a value of type 'int'

Um auf ein bestimmtes 2D-Array zuzugreifen, betrachten Sie die Speicherzuordnung für eine Array-Deklaration wie im folgenden Code gezeigt:

    0  1
a[0]0  1
a[1]2  3

Um auf jedes Element zuzugreifen, reicht es aus, nur das Array, an dem Sie interessiert sind, als Parameter an die Funktion zu übergeben. Verwenden Sie dann den Versatz für die Spalte, um auf jedes Element einzeln zuzugreifen.

int a[2][2] ={{0,1},{2,3}};

void f1(int *ptr);

void f1(int *ptr)
{
    int a=0;
    int b=0;
    a=ptr[0];
    b=ptr[1];
    printf("%d\n",a);
    printf("%d\n",b);
}

int main()
{
   f1(a[0]);
   f1(a[1]);
    return 0;
}