Übersetzung ins Deutsche

# Zeiger auf Zeiger (Doppelter Zeiger) in C

Hallo在那里, aufstrebende Programmierer! Heute werden wir eine aufregende Reise in die Welt der Zeiger antreten - spezifisch in die Welt der Zeiger auf Zeiger. Ich weiß, was ihr vielleicht denkt: "Zeiger? Doppelte Zeiger? Das klingt wie ein Alptraum!" Aber keine Sorge, ich verspreche, dies so unterhaltsam und leicht verständlich wie möglich zu machen. Also, holt euch euer Lieblingsgetränk, macht euch bequem und lasst uns einsteigen!

Was ist ein Doppelter Zeiger in C?

Stellt euch vor, ihr seid auf einer Schatzsuche. Ihr habt eine Karte (nennt sie uns einen Zeiger), die euch zu einem Schatz führt. Aber Überraschung! In dem Schatz ist eine weitere Karte (ein weiterer Zeiger), die euch zum tatsächlichen Schatz führt. Das ist im Grunde genommen, was ein doppelter Zeiger ist - ein Zeiger, der auf einen anderen Zeiger zeigt.

In der C-Programmierung ist ein doppelter Zeiger genau das, was er klingt - ein Zeiger auf einen Zeiger. Es ist eine Variable, die die Adresse eines anderen Zeigers speichert. Das mag am Anfang etwas verwirrend klingen, aber keine Sorge, wir werden das Schritt für Schritt aufbrechen.

Deklaration eines Zeigers auf einen Zeiger

Beginnen wir mit der Deklaration eines doppelten Zeigers. Die Syntax ist ziemlich einfach:

int **ptr;

Hier ist ptr ein Zeiger auf einen Zeiger auf eine ganze Zahl. Der erste Stern * macht ihn zu einem Zeiger und der zweite * macht ihn zu einem Zeiger auf einen Zeiger.

Beispiel für Zeiger auf Zeiger (Doppelter Zeiger)

Sehen wir uns ein einfaches Beispiel an, um dies besser zu verstehen:

#include <stdio.h>

int main() {
    int x = 5;
    int *p = &x;
    int **pp = &p;

    printf("Wert von x: %d\n", x);
    printf("Wert von x mit p: %d\n", *p);
    printf("Wert von x mit pp: %d\n", **pp);

    return 0;
}

Ausgabe:

Wert von x: 5
Wert von x mit p: 5
Wert von x mit pp: 5

Lassen Sie uns das aufbrechen:

1. Wir deklarieren eine ganze Zahl x und initialisieren sie mit 5.
2. Wir erstellen einen Zeiger p, der auf x zeigt.
3. Wir erstellen einen doppelten Zeiger pp, der auf p zeigt.
4. Wir geben den Wert von x auf drei verschiedene Weisen aus:
   • Direkt mit x
   • Mit dem einfachen Zeiger p (wir dereferenzieren ihn einmal mit *p)
   • Mit dem doppelten Zeiger pp (wir dereferenzieren ihn zweimal mit **pp)

Alle drei Methoden geben uns den gleichen Wert: 5. Es ist, als würde man den Schatz mit verschiedenen Karten erreichen!

Wie funktioniert ein normaler Zeiger in C?

Bevor wir tiefer in doppelte Zeiger einsteigen, überprüfen wir schnell, wie normale Zeiger funktionieren:

int y = 10;
int *q = &y;

printf("Wert von y: %d\n", y);
printf("Adresse von y: %p\n", (void*)&y);
printf("Wert von q: %p\n", (void*)q);
printf("Wert, auf den q zeigt: %d\n", *q);

Ausgabe:

Wert von y: 10
Adresse von y: 0x7ffd5e8e9f44
Wert von q: 0x7ffd5e8e9f44
Wert, auf den q zeigt: 10

Hier zeigt q einen Zeiger, der die Adresse von y speichert. Wenn wir *q verwenden, greifen wir auf den Wert zu, der an dieser Adresse gespeichert ist.

Wie funktioniert ein Doppelter Zeiger?

Nun erweitern wir dies auf doppelte Zeiger:

int z = 15;
int *r = &z;
int **rr = &r;

printf("Wert von z: %d\n", z);
printf("Adresse von z: %p\n", (void*)&z);
printf("Wert von r: %p\n", (void*)r);
printf("Adresse von r: %p\n", (void*)&r);
printf("Wert von rr: %p\n", (void*)rr);
printf("Wert, auf den r zeigt: %d\n", *r);
printf("Wert, auf den rr zeigt: %p\n", (void*)*rr);
printf("Wert, auf den der angezeigte Wert von rr zeigt: %d\n", **rr);

Ausgabe:

Wert von z: 15
Adresse von z: 0x7ffd5e8e9f48
Wert von r: 0x7ffd5e8e9f48
Adresse von r: 0x7ffd5e8e9f50
Wert von rr: 0x7ffd5e8e9f50
Wert, auf den r zeigt: 15
Wert, auf den rr zeigt: 0x7ffd5e8e9f48
Wert, auf den der angezeigte Wert von rr zeigt: 15

Dies mag etwas überwältigend aussehen, aber lassen Sie uns das aufbrechen:

1. z ist eine ganze Zahl mit dem Wert 15.
2. r ist ein Zeiger, der die Adresse von z speichert.
3. rr ist ein doppelter Zeiger, der die Adresse von r speichert.
4. *r gibt uns den Wert von z (15).
5. *rr gibt uns den Wert von r (welcher die Adresse von z ist).
6. **rr gibt uns den Wert von z (15).

Stellen Sie sich das so vor: rr zeigt auf r, der wiederum auf z zeigt. Also ist **rr wie das Sagen: "Folge dem ersten Zeiger, dann folge dem zweiten Zeiger und gib mir den Wert dort".

Ein Doppelter Zeiger verhält sich genau wie ein normaler Zeiger

Hier ist ein kleiner Geheimnis: Ein doppelter Zeiger ist nur ein Zeiger, aber anstatt auf eine ganze Zahl oder einen Fließkommawert zu zeigen, zeigt er auf einen anderen Zeiger. Das bedeutet, dass wir alle die gleichen Dinge mit doppelten Zeigern tun können, wie wir es mit normalen Zeigern tun können.

Zum Beispiel können wir doppelte Zeiger mit Arrays verwenden:

int main() {
    char *fruits[] = {"Apfel", "Banane", "Kirsche"};
    char **ptr = fruits;

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

    return 0;
}

Ausgabe:

Apfel
Banane
Kirsche

In diesem Beispiel ist fruits ein Array von Zeigern (jeder zeigt auf einen String), und ptr ist ein Zeiger auf einen Zeiger auf ein Zeichen (der auf Elemente von fruits zeigen kann).

Mehrfachzeiger in C (Ist ein Dreifacher Zeiger Möglich?)

Ja, ihr könnt dreifache Zeiger, vierfache Zeiger und so weiter haben! Es gibt keine theoretische Grenze für die Levels der Indirektion, die ihr haben könnt. Allerdings ist es in der Praxis selten, mehr als doppelte Zeiger zu sehen.

Hier ist ein Beispiel für einen dreifachen Zeiger:

int x = 5;
int *p = &x;
int **pp = &p;
int ***ppp = &pp;

printf("Wert von x: %d\n", ***ppp);

Ausgabe:

Wert von x: 5

Aber denken Sie daran, nur weil Sie können, bedeutet das nicht, dass Sie sollten. Mehrere Ebenen der Indirektion können den Code schwerer zu lesen und zu pflegen machen. Wie das alte Programmier Sprichwort sagt: "Alle Probleme in der Informatik können durch eine weitere Ebene der Indirektion gelöst werden ... außer das Problem der zu vielen Ebenen der Indirektion!"

Schlussfolgerung

Herzlichen Glückwunsch! Sie haben gerade die kniffligen Gewässer der doppelten Zeiger in C navigiert. Bedenken Sie, dass wie viele Konzepte in der Programmierung, Zeiger auf Zeiger vielleicht am Anfang verwirrend erscheinen, aber mit Übung werden sie zweiter Natur.

Hier ist eine Tabelle, die die wichtigsten Punkte zusammenfasst, die wir behandelt haben:

Konzept	Syntax	Beschreibung
Normaler Zeiger	int *p;	Zeigt auf eine ganze Zahl
Doppelter Zeiger	int **pp;	Zeigt auf einen Zeiger auf eine ganze Zahl
Dereferenzierung	*p	Greift auf den Wert zu, auf den p zeigt
Doppelte Dereferenzierung	**pp	Greift auf den Wert zu, auf den der Zeiger zeigt, den pp zeigt
Adress-of-Operator	&x	Holt die Adresse von x

Üben Sie weiter, bleiben Sie neugierig und denken Sie daran - jeder Expert war einmal Anfänger. Frohes Coden!

Credits: Image by storyset