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

Ein Pointer ist eine Variable, die die Adresse einer anderen Variable speichert. Der Name der Pointer-Variable muss mit dem *-Symbol präfixiert sein. Genau wie bei einer normalen Variable können wir auch ein „Array von Pointern“ deklarieren, wobei jeder Subscript des Arrays die Adresse eines Array-Typs hält.

Wie initialisiert man ein Array von Pointern in C?

Eine Pointer-Variable kann bei der Deklaration initialisiert werden, indem man ihr die Adresse einer existierenden Variable zuweist. Der folgende Snippet zeigt, wie man einen Pointer initialisiert:

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

Standardmäßig gehören alle Variablen – einschließlich Pointer-Variablen – zur „auto storage class“. Das bedeutet, eine Pointer-Variable speichert eine unvorhersehbare, zufällige Speicheradresse (Garbage), was zu undefiniertem Verhalten und potenziellen Risiken wie Segmentation Faults führen kann. Daher sollte sie auf NULL initialisiert werden, wenn zum Deklarationszeitpunkt kein spezifischer Wert vorliegt.

int *ptr = NULL;

Ein „Pointer-Array“ speichert die Adresse in jedem Element. Der Typ des Arrays muss mit dem Typ der Zielvariable übereinstimmen.

Array von Pointern mit static-Keyword initialisieren

Man kann auch das static-Keyword nutzen, um ein Array von Pointern zu initialisieren, das in jedem Subscript 0 speichert.

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

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

Array von Integer-Pointern initialisieren

Hier deklarieren wir ein Array von Integer-Pointern und speichern die Adressen von drei Integer-Variablen.

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

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

Array von Pointern durch direkte Adressen initialisieren

Wir können die Adresse jedes Elements eines normalen Arrays im entsprechenden Element eines Pointer-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

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

Array mit seiner Basisadresse traversieren

Wenn wir die Basisadresse eines Arrays erhalten (in diesem Fall &arr[0]), können wir die Adressen der nachfolgenden Elemente ermitteln, da der Pointer um die Größe des Datentyps inkrementiert wird.

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

Beispiel 1

#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

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

Beispiel 2: 2D-Array mit einem Pointer-Array traversieren

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

#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

1 2 3 4
5 6 7 8

Beispiel 3

Wir brauchen nicht wirklich ein Pointer-Array, da wir den Namen dieses 2D-Arrays als Basis-Pointer nutzen und ihn zeilen- und spaltenweise inkrementieren können, um die Elemente im gegebenen 2D-Array zu holen.

#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 Character-Pointern (Strings) initialisieren

In C-Programmierung ist ein String ein Array vom char-Datentyp. Da der Name eines Arrays auch die Adresse seines 0. Elements repräsentiert, kann ein String wie folgt deklariert werden:

char arr[] = "Hello";

Mit Pointer-Notation wird ein String einem char-Pointer zugewiesen als:

char *arr = "Hello";

Wir können dann ein Array von char-Pointern deklarieren, um mehrere Strings zu speichern:

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

Beispiel

Das folgende Beispiel hat ein Array von char-Pointern, das die Namen von Programmiersprachen speichert:

#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

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

In diesem Programm ist langs ein Pointer auf ein Array von 10 Strings. Wenn also langs[0] auf Adresse 5000 zeigt, dann zeigt langs + 1 auf Adresse 5004, die den Pointer zum zweiten String speichert.

Daher können wir auch die folgende Variation der Schleife nutzen, um das Array von Strings auszugeben:

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

Initialisierung eines dynamischen Arrays von Pointern

Man kann die malloc()-Funktion nutzen, um ein Array von Pointern dynamisch zu deklarieren und zu initialisieren.

Beispiel

#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

0 0
1 1
2 2
3 3
4 4

Man kann sogar Benutzereingaben abfragen und die Werte den Elementen im Pointer-Array zuweisen:

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