Kette von Zeigern in C

Hallo da draußen, zukünftige Codewizarden! Heute machen wir uns auf eine aufregende Reise durch die magische Welt der Zeigerketten in C. Machen Sie sich keine Sorgen, wenn Sie neu im Programmieren sind - ich werde Ihr freundlicher Guide sein und wir werden dieses Thema Schritt für Schritt angehen. Also, holen Sie sich Ihre virtuellen Zauberstäbe (Tastaturen) und tauchen wir ein!

Was ist eine Kette von Zeigern in C?

Stellen Sie sich vor, Sie sind auf einer Schatzsuche und anstatt einer Karte haben Sie eine Reihe von Hinweisen. Jeder Hinweis führt zum nächsten, was eine Kette bildet, die letztendlich zum Schatz führt. Genau das ist eine Zeigerkette in C!

In der C-Programmierung ist eine Zeigerkette eine Abfolge von Zeigern, bei denen jeder Zeiger auf den nächsten zeigt, außer dem letzten, der typischerweise auf eine Variable eines bestimmten Datentyps zeigt.

Lassen Sie uns mit einem einfachen Beispiel beginnen:

int value = 42;
int *ptr1 = &value;
int **ptr2 = &ptr1;
int ***ptr3 = &ptr2;

In diesem Code:

• value ist unser Schatz (eine Ganzzahl mit dem Wert 42).
• ptr1 ist ein Zeiger, der die Adresse von value speichert.
• ptr2 ist ein Zeiger auf einen Zeiger (beachten Sie die doppelten Sternchen), der die Adresse von ptr1 speichert.
• ptr3 ist ein Zeiger auf einen Zeiger auf einen Zeiger (dreifache Sternchen!), der die Adresse von ptr2 speichert.

Es ist wie eine russische Puppenkiste der Zeiger! ?

Wie funktioniert Dereferenzierung?

Nun, lassen Sie uns über Dereferenzierung sprechen. Dereferenzierung ist so, als ob man jede Puppe öffnet, um zur einen innen zu gelangen. In unserer Zeigerkette verwenden wir das Sternchen (*), um zu dereferenzieren.

printf("Value: %d\n", ***ptr3);

Diese Zeile sieht vielleicht ein bisschen gruselig aus mit diesen drei Sternchen, aber lassen Sie uns das mal auseinandernehmen:

1. *ptr3 gibt uns die Adresse, die in ptr2 gespeichert ist
2. **ptr3 (oder *(*ptr3)) gibt uns die Adresse, die in ptr1 gespeichert ist
3. ***ptr3 (oder *(*(*ptr3))) gibt uns schließlich den Wert von value, der 42 ist

Es ist, als ob man sagt: "Öffne die große Puppe, dann öffne die mittlere Puppe darin, dann öffne die kleine Puppe darin, um den Schatz zu finden!"

Eine Kette von Fließpunktzahlenzeigern

Versuchen wir das mit Fließpunktzahlen:

float pi = 3.14159;
float *fPtr1 = π
float **fPtr2 = &fPtr1;
float ***fPtr3 = &fPtr2;

printf("Value of pi: %f\n", ***fPtr3);

Dies funktioniert genauso wie unser Beispiel mit Ganzzahlen, nur mit Fließpunktzahlen. Wenn wir ***fPtr3 ausgeben, folgen wir der Zeigerkette zurück zu unserem pi-Wert.

Aktualisierung der ursprünglichen Variable durch Dereferenzierung

Eine der coolen Sachen an Zeigerketten ist, dass wir damit den ursprünglichen Wert ändern können. Lassen Sie uns sehen, wie das geht:

int score = 85;
int *scorePtr1 = &score;
int **scorePtr2 = &scorePtr1;

printf("Original score: %d\n", score);

**scorePtr2 = 90;  // Aktualisierung des Wertes über die Zeigerkette

printf("Updated score: %d\n", score);

In diesem Beispiel verwenden wir **scorePtr2, um den Wert von score zu ändern. Es ist, als ob man eine Nachricht durch eine Kette von Leuten schickt, um die Anzeigetafel zu aktualisieren!

Eine Kette von Zeichenzeigern

Lassen Sie uns mit einem etwas komplexeren Beispiel abschließen, das Zeichenzeiger verwendet:

char letter = 'A';
char *charPtr1 = &letter;
char **charPtr2 = &charPtr1;
char ***charPtr3 = &charPtr2;

printf("Original letter: %c\n", ***charPtr3);

**charPtr2 = 'B';  // Aktualisierung des Wertes

printf("Updated letter: %c\n", letter);

Dies funktioniert genauso wie unsere vorherigen Beispiele, nur mit Zeichen. Wir können unser Zeichen von 'A' auf 'B' ändern, indem wir die Zeigerkette verwenden.

Methodenübersicht

Hier ist eine praktische Tabelle, die die Methoden zusammenfasst, die wir besprochen haben:

Methode	Beschreibung	Beispiel
Erstellen eines Zeigers	Verwenden Sie den &-Operator, um die Adresse einer Variable zu erhalten	int *ptr = &value;
Dereferenzierung	Verwenden Sie den *-Operator, um den Wert zu erhalten, auf den ein Zeiger zeigt	int x = *ptr;
Erstellen eines Zeigers auf einen Zeiger	Verwenden Sie das doppelte Sternchen **	int **ptr2 = &ptr1;
Dereferenzierung einer Kette	Verwenden Sie mehrere Sternchen	int value = ***ptr3;
Aktualisierung über eine Kette	Weisen Sie einen Wert mittels dereferenzierter Zeiger zu	**ptr2 = 90;

Und das war's, Leute! Wir haben den steinigen Pfad der Zeigerketten in C durchquert. Denken Sie daran, Übung macht den Meister, also fürchten Sie sich nicht, mit diesen Konzepten zu experimentieren. Bevor Sie es wissen, werden Sie Zeiger wie ein professioneller Zirkusartist jonglieren können! ?

Frohes Coden und möge Ihre Zeiger immer in die richtige Richtung zeigen! ?

Credits: Image by storyset