Mühelose Pointer-Array-Initialisierung in C:Tipps und Best Practices

Ein Zeiger ist eine Variable, die die Adresse einer anderen Variablen speichert. Dem Namen der Zeigervariablen muss das Symbol „*“ vorangestellt werden. Genau wie im Fall einer normalen Variablen können wir auch ein „Array von Zeigern“ deklarieren, wobei jeder Index des Arrays die Adresse eines Array-Typs enthält.

Wie initialisiere ich ein Array von Zeigern in C?

Eine Zeigervariable kann zum Zeitpunkt der Deklaration initialisiert werden, indem ihr die Adresse einer vorhandenen Variablen zugewiesen wird. Der folgende Ausschnitt zeigt, wie Sie einen Zeiger initialisieren können −

int x = 10;
int *y = &x;

Standardmäßig gehören alle Variablen einschließlich der Zeigervariablen zur „Auto-Storage-Klasse“. Dies bedeutet, dass eine Zeigervariable eine unvorhersehbare, fehlerhafte, zufällige Speicheradresse speichert, was zu undefiniertem Verhalten und potenziellen Risiken für ein Programm, wie z. B. Segmentierungsfehlern, führen kann. Daher sollte es auf NULL initialisiert werden, wenn wir zum Zeitpunkt der Deklaration keinen bestimmten Wert zum Speichern haben.

int *ptr = NULL;

Ein „Zeigerarray“ speichert die Adresse in jedem Element. Der Typ des Arrays muss mit dem Typ der Zielvariablen übereinstimmen.

Array von Zeigern mit statischem Schlüsselwort initialisieren

Sie können auch das Schlüsselwort static verwenden, um ein Array von Zeigern zu initialisieren, um in jedem Index „0“ zu speichern.

Beispiel

#include <stdio.h>
int main(){
 static int *ptr[5];
 for (int i = 0; i < 5; i++){
 printf("ptr[%d] = %d\n", i, ptr[i]); 
 }
 
 return 0;
}

Ausgabe

Führen Sie den Code aus und überprüfen Sie seine Ausgabe −

ptr[0]= 0
ptr[1]= 0
ptr[2]= 0
ptr[3]= 0
ptr[4]= 0

Array ganzzahliger Zeiger initialisieren

Hier deklarieren wir ein Array von Ganzzahlzeigern und speichern die Adressen von drei Ganzzahlvariablen.

Beispiel

#include <stdio.h>
int main(){
 int a = 10, b = 20, c = 30;
 int *ptr[3] = {&a, &b, &c};
 for (int i = 0; i < 3; i++){
 printf("ptr[%d]: address: %d value: %d\n", i, ptr[i], *ptr[i]);
 }
 
 return 0;
}

Ausgabe

Führen Sie den Code aus und überprüfen Sie seine Ausgabe −

ptr[0]: address: 6422040 value: 10
ptr[1]: address: 6422036 value: 20
ptr[2]: address: 6422032 value: 30

Array von Zeigern nach direkten Adressen initialisieren

Wir können die Adresse jedes Elements eines normalen Arrays im entsprechenden Element eines Zeiger-Arrays speichern.

Beispiel

#include <stdio.h>
int main(){
 int arr[] = {10, 20, 30};
 int *ptr[3] = {&arr[0], &arr[1], &arr[2]};
 for (int i = 0; i < 3; i++){
 printf("ptr[%d]: address: %d value: %d\n", i, ptr[i], *ptr[i]);
 }
 
 return 0;
}

Ausgabe

Führen Sie den Code aus und überprüfen Sie seine Ausgabe −

ptr[0]: address: 6422032 value: 10
ptr[1]: address: 6422036 value: 20
ptr[2]: address: 6422040 value: 30

Durchlaufen eines Arrays mit seiner Basisadresse

Wenn wir die Basisadresse eines Arrays (in diesem Fall „&arr[0]“) erhalten, können wir die Adressen seiner nachfolgenden Elemente erhalten, wobei wir wissen, dass der Zeiger um die Größe des Datentyps erhöht wird.

Daher können wir ein Array nur mit der Basisadresse (der Name des Arrays ist derselbe wie die Adresse des 0. Elements) durchlaufen.

Beispiel 1

Schauen Sie sich das folgende Beispiel an −

#include <stdio.h>
int main(){
 int arr[] = {10, 20, 30};
 int *ptr=arr;
 for (int i = 0; i < 3; i++){
 printf("ptr[%d]: address: %d value: %d\n", i,ptr+i, *(ptr+i));
 }
 
 return 0;
}

Ausgabe

Führen Sie den Code aus und überprüfen Sie seine Ausgabe −

ptr[0]: address: 6422020 value: 10
ptr[1]: address: 6422024 value: 20
ptr[2]: address: 6422028 value: 30

Beispiel 2:Durchlaufen eines 2D-Arrays mithilfe eines Zeiger-Arrays

In diesem Beispiel haben wir ein 2D-Array. Die Adresse des 0. Elements jeder Zeile wird in einem Zeiger-Array gespeichert. Beim Durchlaufen wird die in jedem Element des Zeiger-Arrays gespeicherte Adresse, die auf das 0. Element der entsprechenden Zeile zeigt, jeweils inkrementiert, um die Werte in jeder Zeile abzurufen.

#include <stdio.h>
int main(){
 // 2d array
 int arr[3][4] = {
 {1, 2, 3, 4},
 {5, 6, 7, 8},
 };
 int ROWS = 2, COLS = 4;
 int i, j;
 // pointer
 int (*ptr)[4] = arr;
 // print the element of the array via pointer ptr
 for (i = 0; i < ROWS; i++) {
 for (j = 0; j < COLS; j++) {
 printf("%d ", *(ptr[i]+j));
 }
 printf("\n");
 }
 
 return 0;
}

Ausgabe

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

1 2 3 4 
5 6 7 8

Beispiel 3

Wir brauchen hier nicht wirklich ein Zeiger-Array, da wir den Namen dieses 2D-Arrays als Basiszeiger verwenden und ihn zeilen- und spaltenweise inkrementieren können, um die Elemente im angegebenen 2D-Array abzurufen −

#include <stdio.h>
int main(){
 // 2d array
 int arr[3][4] = {
 {1, 2, 3, 4},
 {5, 6, 7, 8},
 };
 int ROWS = 2, COLS = 4;
 int i, j;
 // pointer
 int *ptr = arr;
 // print the element of the array via pointer ptr
 for (i = 0; i < ROWS; i++){
 for (j = 0; j < COLS; j++){
 printf("%d ", *(ptr + i * COLS + j));
 }
 printf("\n");
 }
 
 return 0;
}

Ausgabe

Die Ausgabe ähnelt der des vorherigen Codes −

1 2 3 4 
5 6 7 8

Array von Zeichenzeigern (String) initialisieren

In der C-Programmierung ist ein String ein Array vom Datentyp char. Da der Name eines Arrays auch die Adresse seines 0. Elements darstellt, kann ein String als −

deklariert werden

char arr[] = "Hello";

Mithilfe der Zeigernotation wird einem Zeichenzeiger ein String als −

zugewiesen

char *arr = "Hello";

Anschließend können wir wie folgt ein Array von char-Zeigern zum Speichern mehrerer Zeichenfolgen deklarieren:−

char *arr[3] = {"string1", "string2", "string3", . . . };

Beispiel

Das folgende Beispiel verfügt über ein Array von char-Zeigern, die zum Speichern der Namen von Computersprachen verwendet werden −

#include <stdio.h>
int main(){
 char *langs [10] = {
 "PYTHON", "JAVASCRIPT", "PHP",
 "NODE JS", "HTML", "KOTLIN", "C++",
 "REACT JS", "RUST", "VBSCRIPT"
 };
 for(int i = 0; i < 10; i++)
 printf("%s\n", langs[i]);
 return 0;
}

Ausgabe

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

PYTHON
JAVASCRIPT
PHP
NODE JS
HTML
KOTLIN
C++
REACT JS
RUST
VBSCRIPT

In diesem Programm ist „langs“ ein Zeiger auf ein Array mit 10 Strings. Wenn also „langs[0]“ auf die Adresse 5000 zeigt, dann zeigt „langs + 1“ auf die Adresse 5004, die den Zeiger auf die zweite Zeichenfolge speichert.

Daher können wir auch die folgende Variante der Schleife verwenden, um das String-Array auszugeben:−

for (int i = 0; i < 10; i++){
 printf("%s\n", *(langs + i));
}

Initialisierung eines dynamischen Arrays von Zeigern

Sie können die Funktion malloc() verwenden, um ein Array von Zeigern auf dynamische Weise zu deklarieren und zu initialisieren.

Beispiel

Schauen Sie sich das folgende Beispiel an −

#include <stdio.h>
int main(){
 int *arr = (int *)malloc (sizeof (int) * 5); 
 for(int i = 0; i < 5; i++){
 arr[i] = i;
 }
 for (int x = 0; x < 5; x++){
 printf("%d %d\n", x, arr[x]);
 }
 
 return 0;
}

Ausgabe

Wenn Sie diesen Code ausführen, wird die folgende Ausgabe erzeugt:

Sie können sogar Benutzereingaben anfordern und die Werte den Elementen im Zeiger von Arrays zuweisen −

for(i = 0; i < 5; i++){
 scanf("%d", &x);
 arr[i] = x;
}

Master-C-Inkrementierungs- und Dekrementierungsoperatoren:Verwendung und Best Practices Beherrschen von Konstantenzeigern und Zeigern auf Konstanten in C

C Sprache