Voraussetzung: Zeigereinführung

Betrachten Sie das folgende Programm:

C

>

>

Im obigen Programm haben wir einen Zeiger ptr das zeigt auf die 0^ThElement des Arrays. Ebenso können wir auch einen Zeiger deklarieren, der auf das gesamte Array statt nur auf ein Element des Arrays zeigen kann. Dieser Zeiger ist nützlich, wenn es um mehrdimensionale Arrays geht.

Syntax:

data_type  (* var_name ) [size_of_array];>

Hier:

data_type ist der Datentyp, den das Array enthält. var_name ist der Name der Zeigervariablen. size_of_array ist die Größe des Arrays, auf das der Zeiger zeigt.

Beispiel

int (*ptr)[10];>

Hier ptr ist ein Zeiger, der auf ein Array mit 10 Ganzzahlen zeigen kann. Da Indizes eine höhere Priorität haben als Indirektionen, ist es notwendig, den Indirektionsoperator und den Zeigernamen in Klammern zu setzen. Hier ist der Typ von ptr „Zeiger auf ein Array von 10 ganzen Zahlen“.

Hinweis: Der Zeiger, der auf die 0 zeigt^ThElement des Arrays und der Zeiger, der auf das gesamte Array zeigt, sind völlig unterschiedlich. Folgendes Programm zeigt dies:

C

>

>

p = 0x7fff6463e890, ptr = 0x7fff6463e890 p = 0x7fff6463e894, ptr = 0x7fff6463e8a4>

Hier, P ist Zeiger auf 0^ThElement des Arrays arr , während ptr ist ein Zeiger, der auf das gesamte Array zeigt arr .

• Der Basistyp von P ist int während der Basistyp von ptr ist „ein Array von 5 ganzen Zahlen“.
• Wir wissen, dass die Zeigerarithmetik relativ zur Basisgröße ausgeführt wird. Wenn wir also ptr++ schreiben, dann der Zeiger ptr wird um 20 Byte nach vorne verschoben.

Die folgende Abbildung zeigt die Zeiger p und ptr. Der dunklere Pfeil bezeichnet einen Zeiger auf ein Array.

Beim Dereferenzieren eines Zeigerausdrucks erhalten wir einen Wert, auf den dieser Zeigerausdruck zeigt. Der Zeiger auf ein Array zeigt auf ein Array. Wenn wir es also dereferenzieren, sollten wir das Array erhalten, und der Name des Arrays gibt die Basisadresse an. Wenn also ein Zeiger auf ein Array dereferenziert wird, erhalten wir die Basisadresse des Arrays, auf das er zeigt.

C

>

>

p = 0x7fff55adbff0, ptr = 0x7fff55adbff0 *p = 3, *ptr = 0x7fff55adbff0 sizeof(p) = 8, sizeof(*p) = 4 sizeof(ptr) = 8, sizeof(*ptr) = 20>

Zeiger auf mehrdimensionale Arrays

1. Zeiger und zweidimensionale Arrays

In einem zweidimensionalen Array können wir auf jedes Element zugreifen, indem wir zwei Indizes verwenden, wobei der erste Index die Zeilennummer und der zweite Index die Spaltennummer darstellt. Auf die Elemente eines 2D-Arrays kann auch mit Hilfe der Zeigernotation zugegriffen werden. Angenommen, arr ist ein 2D-Array, wir können auf jedes Element zugreifen arr[i][j] des Arrays mithilfe des Zeigerausdrucks *(*(arr + i) + j) . Jetzt werden wir sehen, wie dieser Ausdruck abgeleitet werden kann.
Nehmen wir ein zweidimensionales Array arr[3][4] :

int arr[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };>

Da der Speicher in einem Computer linear organisiert ist, ist es nicht möglich, das 2D-Array in Zeilen und Spalten zu speichern. Das Konzept von Zeilen und Spalten ist nur theoretisch, tatsächlich wird ein 2D-Array in Zeilen-Hauptreihenfolge gespeichert, d. h. Zeilen werden nebeneinander platziert. Die folgende Abbildung zeigt, wie das obige 2D-Array im Speicher gespeichert wird.

Jede Zeile kann als eindimensionales Array betrachtet werden, sodass ein zweidimensionales Array als eine Sammlung eindimensionaler Arrays betrachtet werden kann, die nacheinander platziert werden. Mit anderen Worten können wir sagen, dass es sich um zweidimensionale Arrays handelt, die nacheinander platziert werden. Also hier arr ist ein Array aus 3 Elementen, wobei jedes Element ein 1-D-Array aus 4 ganzen Zahlen ist.
Wir wissen, dass der Name eines Arrays ein konstanter Zeiger ist, der auf 0 zeigt^Th1-D-Array und enthält Adresse 5000. Seitdem arr ist ein „Zeiger auf ein Array von 4 Ganzzahlen“. Gemäß der Zeigerarithmetik stellt der Ausdruck arr + 1 die Adresse 5016 und der Ausdruck arr + 2 die Adresse 5032 dar.
Das können wir also sagen arr zeigt auf die 0^Th1-D-Array, arr + 1 weist auf den 1. hin^st1-D-Array und arr + 2 weist auf die 2 hin^nd1-D-Array.

Im Allgemeinen können wir schreiben:

 arr + i Points to ith element of arr ->Zeigt auf das 1-D-Array>

• Da arr + i auf i zeigt^ThElement von arr , bei der Dereferenzierung wird es i bekommen^ThElement von arr Das ist natürlich ein 1-D-Array. Daher der Ausdruck *(arr + i) gibt uns die Basisadresse von i^Th1-D-Array.
• Wir kennen den Zeigerausdruck *(arr + i) entspricht dem tiefgestellten Ausdruck arr[i] . Also *(arr + i) was dasselbe ist wie arr[i] gibt uns die Basisadresse von i^Th1-D-Array.
• Um auf ein einzelnes Element unseres 2D-Arrays zuzugreifen, sollten wir auf jedes beliebige j zugreifen können^ThElement von i^Th1-D-Array.
• Da der Basistyp von *(arr + i) Ist int und es enthält die Adresse 0^ThElement von i^Th1-D-Array können wir die Adressen nachfolgender Elemente im i abrufen^Th1-D-Array durch Hinzufügen ganzzahliger Werte *(arr + i) .
• Zum Beispiel *(arr + i) + 1 wird die Adresse von 1 darstellen^stElement von 1^stElement von i^Th1-D-Array und *(arr+i)+2 wird die Adresse von 2 darstellen^ndElement von i^Th1-D-Array.
• Ebenso stellt *(arr + i) + j die Adresse von j dar^ThElement von i^Th1-D-Array. Durch Dereferenzierung dieses Ausdrucks können wir das j erhalten^ThElement des i^Th1-D-Array.

Zeiger und dreidimensionale Arrays

int arr[2][3][2] = { {{5, 10}, {6, 11}, {7, 12}}, {{20, 30}, {21, 31}, {22, 32}} };>

In einem dreidimensionalen Array können wir auf jedes Element zugreifen, indem wir drei Indizes verwenden. Nehmen wir ein 3D-Array. Wir können ein dreidimensionales Array als Array eines 2D-Arrays betrachten, d. h. jedes Element eines 3D-Arrays wird als 2D-Array betrachtet. Das 3D-Array arr kann als Array betrachtet werden, das aus zwei Elementen besteht, wobei jedes Element ein 2D-Array ist. Der Name des Arrays arr ist ein Zeiger auf die 0^Th2D-Array.

Also der Zeigerausdruck *(*(*(arr + i ) + j ) + k) entspricht dem tiefgestellten Ausdruck arr[i][j][k].
Wir wissen, dass der Ausdruck *(arr + i) äquivalent zu arr[i] und der Ausdruck *(*(arr + i) + j) äquivalent zu arr[i][j] ist. Wir können also sagen, dass arr[i] die Basisadresse von i darstellt^Th2-D-Array und arr[i][j] stellt die Basisadresse von j dar^Th1-D-Array.

Beispiel

Java mit MySQL verbinden

Das folgende Beispiel zeigt das Programm zum Drucken von Elementen eines 3D-Arrays mithilfe von Zeigern.

C

>

>

5 10 6 11 7 12 20 30 21 31 22 32>

Die folgende Abbildung zeigt, wie das im obigen Programm verwendete 3D-Array im Speicher gespeichert wird.

Abonnieren eines Zeigers auf ein Array

Vermuten arr ist ein 2D-Array mit 3 Zeilen und 4 Spalten und ptr ist ein Zeiger auf ein Array von 4 Ganzzahlen und ptr enthält die Basisadresse des Arrays arr .

int arr[3][4] = {{10, 11, 12, 13}, {20, 21, 22, 23}, {30, 31, 32, 33}}; int (*ptr)[4]; ptr = arr;>

Seit ptr ist ein Zeiger auf das 2D-Array der ersten Zeile, d. h. ein Array mit 4 ganzen Zahlen, ptr + i werde auf mich zeigen^ThReihe. Zur Dereferenzierung ptr + i , wir erhalten die Basisadresse von i^ThReihe. Um auf die Adresse von j zuzugreifen^ThElement von i^ThZeile können wir j zum Zeigerausdruck hinzufügen *(ptr + i) . Also der Zeigerausdruck *(ptr + i) + j gibt die Adresse von j an^ThElement von i^ThZeile und den Zeigerausdruck *(*(ptr + i)+j) gibt den Wert von j an^ThElement von i^ThReihe.
Wir wissen, dass der Zeigerausdruck *(*(ptr + i) + j) dem tiefgestellten Ausdruck ptr[i][j] entspricht. Wenn wir also eine Zeigervariable haben, die die Basisadresse eines 2D-Arrays enthält, können wir auf die Elemente des Arrays zugreifen, indem wir diese Zeigervariable doppelt indizieren.

Beispiel

C

>

>

0x7ffc9556b790 0x7ffc9556b7a0 0x7ffc9556b7b0 0x7ffc9556b790 0x7ffc9556b7a0 0x7ffc9556b7b0 10 22 33 10 22 33>