Ein Zeiger auf ein 2D-Array
Ich habe eine Frage zu einem Zeiger auf das 2d-Array. Wenn ein Array etwas ist
int a[2][3];
ist dies ein Zeiger auf das Array a?
int (*p)[3] = a;
Wenn dies richtig ist, frage ich mich, was [3] von int(*p)[3] bedeutet.
Anstatt int[2][3] als '2d-Array' zu bezeichnen, sollten Sie es als 'Array von Arrays' betrachten. Es ist ein Array mit zwei Elementen darin, wobei jedes Element selbst ein Array mit 3 Ints ist.
int (*p)[3] = a;
Sie können p verwenden, um auf eines der beiden Elemente in a zu zeigen. p zeigt auf ein Drei-Int-Array - nämlich das erste derartige Element. p+1 würde auf das zweite Drei-Int-Array zeigen. Um p zu initialisieren, um auf das zweite Element zu zeigen, verwenden Sie:
int (*p)[3] = &(a[1]);
Im Folgenden finden Sie gleichwertige Möglichkeiten, auf den ersten der beiden Punkte zu verweisen.
int (*p)[3] = a; // as before
int (*p)[3] = &(a[0]);
int a[2][3];
a wird als Array 2 von Array 3 von int gelesen, bei dem es sich einfach um ein Array von Arrays handelt. Wenn du schreibst,
int (*p)[3] = a;
Es deklariert p als Zeiger auf das erste Element, das ein Array ist. Also zeigt p auf das 3-Zoll-Array, bei dem es sich um ein Array-Element handelt.
Betrachten Sie dieses Beispiel:
int a[2][3]
+----+----+----+----+----+----+
| | | | | | |
+----+----+----+----+----+----+
\_____________/
|
|
|
p int (*p)[3]
Hier ist p Ihr Zeiger, der auf das 3-Zoll-Array zeigt, das ein Element des Arrays von Arrays ist.
Nein, int (*p)[3] = a; ist kein Zeiger auf a. Es ist ein Zeiger auf das erste Element von a. Das erste Element von a ist ein Array von drei Ints. p ist ein Zeiger auf ein Array von drei Ints.
Ein Zeiger auf das Array a würde folgendermaßen deklariert:
int (*q)[2][3] = &a;
Der numerische Wert von p und q ist wahrscheinlich (oder muss sogar derselbe sein), aber es gibt unterschiedliche Typen. Dies kommt ins Spiel, wenn Sie mit p oder q rechnen. p+1 zeigt auf das zweite Element des Arrays a, während q+1 auf den Speicher direkt hinter dem Ende des Arrays a zeigt.
Denk daran: cdecl ist dein Freund: int a[2][3] , int (*q)[2][3] .
Der [3] ist ein Teil des Typs. In diesem Fall ist p ein Zeiger auf ein Array der Größe 3, das Ints enthält.
Der jeweilige Typ eines Arrays enthält immer seine Größe, so dass Sie die Typen int *[3] oder int *[5] haben, aber nicht nur int *[] mit undefinierter Größe.
int *x[20]; /* type of x is int *[20], not just int *[] */
int y[10][10]; /* type of y is int[10][10], not just int[][] */
Beachten Sie auch:
int *p[5] // p is an array of 5 pointers
int (*p)[5] // p points to an array of 5 ints
int (*(p+5))[10] // p is a pointer to a structure where the structure's 5th element has 10 ints .
sie können auf ein 2d-Array wie ein 1d-Array zeigen
#include <iostream>
int main()
{
int array[2][2] = {{0,1}, {2,3}}; // array
int *ptr;
ptr=(int*)array;
std::cout << *(ptr) << '\n';//out 0
std::cout << *(ptr+1) << '\n';//out 1
std::cout << *(ptr+2) << '\n';//out 2
std::cout << *(ptr+3) << '\n';//out 3
}