Verhalten von 2D-Arrays

Ich habe ein 2D-Array erstellt und versucht, bestimmte Werte wie unten gezeigt zu drucken:

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

printf("%d %d\n", *(a+1)[0], ((int *)a+1)[0]);

Die Ausgabe ist:

3 2

ich verstehe warum 3 ist die erste Ausgabe (a+1 zeigt auf die zweite Zeile, und wir drucken sie 0th Element.

Meine Frage bezieht sich auf die zweite Ausgabe, dh 2. Meine Vermutung liegt an der Typisierung a wie int *wird das 2D-Array wie ein 1D-Array behandelt und somit a+1 fungiert als Zeiger auf die 2nd Element, und so erhalten wir die Ausgabe als 2.

Sind meine Annahmen richtig oder steckt dahinter eine andere Logik?
Auch ursprünglich, was ist die Art von a wenn es als Zeiger behandelt wird int (*)[2] oder int **?

Als Sie Ausdruck geschrieben haben

(int *)a

dann kann das ursprüngliche Array logischerweise auf folgende Weise als eindimensionales Array betrachtet werden

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

Also Ausdruck a zeigt auf das erste Element gleich 1 dieses imaginären Arrays. Ausdruck ( a + 1 ) zeigt auf das zweite Element des imaginären Arrays gleich 2 und Ausdruck ( a + 1 )[0] gibt den Verweis auf dieses Element zurück, das heißt, Sie erhalten 2.

Sind meine Annahmen richtig oder steckt dahinter eine andere Logik?

Ja.

*(a+1)[0] ist äquivalent zu a[1][0].
((int *)a+1)[0] ist äquivalent zu a[0][1].

Erläuterung:

a zerfällt zum Zeiger auf das erste Element des 2D-Arrays, dh auf die erste Zeile. *a dereferenziert diese Zeile, die ein Array von 2 ist int. Deswegen *a kann als Array-Name der ersten Zeile behandelt werden, der weiter in einen Zeiger auf sein erstes Element zerfällt, dh 1. *a + 1 gibt den Zeiger auf das zweite Element. Dereferenzierung *a + 1 wird geben 1. So:

((int *)a+1)[0] == *( ((int *)a+1 )+ 0) 
                == *( ((int *)a + 0) + 1) 
                == a[0][1]   

Beachten Sie, dass a, *a, &a, &a[0] und &a[0][0] alle haben den gleichen Adresswert, obwohl sie unterschiedlichen Typs sind. Nach dem Verfall, a ist vom Typ int (*)[2]. Gießen Sie es zu int * macht nur den Adresswert zu tippen int * und die Arithmetik (int *)a+1 gibt die Adresse des zweiten Elements an.

Was ist ursprünglich der Typ von a, wenn es als Zeiger behandelt wird? (int (*)[2] oder int **?

Es wird typisiert Zeiger auf Array von 2 intdh int (*)[2]

Ein 2D-Array ist im Wesentlichen ein eindimensionales Array mit einigen zusätzlichen Compiler-Kenntnissen.

Wenn Sie werfen a zu int*entfernen Sie dieses Wissen und es wird wie ein normales eindimensionales Array behandelt (was in Ihrem Fall im Speicher so aussieht 1 2 3 4).

Das Wichtigste, was hier zu erkennen ist, ist, dass die a Dort steht der Wert der Adresse, an der sich die erste Zeile befindet. Da das gesamte Array an derselben Stelle beginnt, hat das gesamte Array auch denselben Adresswert; Gleiches gilt für das allererste Element.

Im C Bedingungen:

&a == &a[0];
&a == &a[0][0];
&a[0] == &a[0][0];
// all of these hold true, evaluate into 1
// cast them if you want, looks ugly, but whatever...
&a == (int (*)[2][2]) &a[0];
&a == (int (*)[2][2]) &a[0][0];
&a[0] == (int (*)[2]) &a[0][0];

Aus diesem Grund, wenn Sie die werfen a zu int *wird es einfach 1-zu-1-äquivalent zu &a[0][0] sowohl über den Typ als auch über den Wert. Wenn Sie diese Operationen auf anwenden würden &a[0][0]:

(&a[0][0] + 1)[0];
(a[0] + 1)[0];
*(a[0] + 1);
a[0][1];

Was die Art angeht a wenn es als Zeiger behandelt wird, obwohl ich mir nicht sicher bin, sollte es sein int (*)[2].