C-Zeiger meistern: Praxisnahes Experten-Tutorial

C-Zeiger meistern

Entdecken Sie die Kernkonzepte von Zeigern in C – von Speicheradressen bis zu praktischen Beispielen und häufigen Fallstricken. Geschrieben für Entwickler, die ihr Verständnis mit realitätsnahen Code vertiefen möchten.

Zeiger sind ein Eckpfeiler effizienter C-Programmierung. Bevor wir in Zeiger eintauchen, wiederholen wir, wie Speicheradressen in C funktionieren.

---

Speicheradressen in C

Wenn Sie eine Variable var haben, liefert der Ausdruck &var die Adresse, an der var gespeichert ist.

Adressmanipulation tritt häufig auf, beispielsweise in scanf():

scanf("%d", &var);

Dies speichert die Benutzereingabe direkt in der Speicherstelle von var. Eine kurze Demo:

#include <stdio.h>
int main() {
    int var = 5;
    printf("var: %d\n", var);
    printf("address of var: %p", &var);
    return 0;
}

Ausgabe

var: 5
address of var: 0x7fffc1a2b1c8

Hinweis: Die Adresse unterscheidet sich bei jedem Lauf und auf jedem System.

---

Was ist ein Zeiger?

Ein Zeiger ist eine Variable, die eine Speicheradresse statt eines konventionellen Werts hält. Durch das Speichern von Adressen ermöglichen Zeiger den indirekten Zugriff auf Daten, was dynamische Speicherverwaltung, effiziente Datenstrukturen und Low-Level-Systemkontrolle erlaubt.

Zeiger deklarieren

Typische Deklarationssyntax:

int *p;

Variationen sind ebenfalls üblich:

int *p1; int *p2;

Beachten Sie, dass Leerzeichen um den Stern die Deklaration nicht beeinflussen. Seien Sie jedoch vorsichtig bei kommagetrennten Deklarationen:

int *p1, p2; /* p1 ist ein Zeiger, p2 ist ein int */

---

Adressen an Zeiger zuweisen

Beispiel:

int *pc, c;
c = 5;
pc = &c;

Hier erhält c den Wert 5, und pc speichert die Adresse von c.

---

Zeiger dereferenzieren

Um auf den Wert zuzugreifen, der an der Adresse liegt, auf die ein Zeiger verweist, verwenden Sie den Dereferenzierungsoperator *:

int *pc, c;
c = 5;
pc = &c;
printf("%d", *pc); /* Gibt 5 aus */

Merken Sie sich: pc ist der Zeiger; *pc ruft den Wert ab, auf den er zeigt. Der Versuch, eine Adresse *pc zuzuweisen (z. B. *pc = &c;), ist ungültig.

Der *-Operator wird als Dereferenzierungsoperator bezeichnet.

---

Werte über Zeiger ändern

Sie können die zugrunde liegenden Daten über ihren Zeiger ändern:

int *pc, c;
c = 5;
pc = &c;
*pc = 1; /* c wird 1 */
printf("%d", c); /* Gibt 1 aus */

Mehrere Variablen können nach Neuzuweisung denselben Zeiger teilen:

int *pc, c, d;
c = 5;
d = -15;
pc = &c;
printf("%d", *pc); /* 5 */
pc = &d;
printf("%d", *pc); /* -15 */

---

Praktisches Beispiel

Führen Sie dieses vollständige Programm aus, um zu beobachten, wie Zeigerwerte konstant bleiben, während die referenzierten Daten sich ändern können:

#include <stdio.h>
int main() {
    int *pc, c;
    c = 22;
    printf("Address of c: %p\n", &c);
    printf("Value of c: %d\n\n", c);
    pc = &c;
    printf("Address of pointer pc: %p\n", pc);
    printf("Content of pointer pc: %d\n\n", *pc);
    c = 11;
    printf("Address of pointer pc: %p\n", pc);
    printf("Content of pointer pc: %d\n\n", *pc);
    *pc = 2;
    printf("Address of c: %p\n", &c);
    printf("Value of c: %d\n\n", c);
    return 0;
}

Ausgabe

Address of c: 0x7fffc1a2b1c8
Value of c: 22
Address of pointer pc: 0x7fffc1a2b1c8
Content of pointer pc: 22
Address of pointer pc: 0x7fffc1a2b1c8
Content of pointer pc: 11
Address of c: 0x7fffc1a2b1c8
Value of c: 2

---

Erklärung

1. int *pc, c; – deklariert einen Zeiger pc und ein int c.
2. c = 22; – speichert 22 im Speicher von c.
3. pc = &c; – lässt pc auf c zeigen.
4. c = 11; – aktualisiert den Wert über direkten Zugriff.
5. *pc = 2; – ändert den Wert über den Zeiger.

---

Häufige Fehler mit Zeigern

Typische Fehler sind das Verwechseln von Zeigern und Werten:

int c, *pc; // Falsch – weist einen Wert einem Zeiger zu
pc = c; // Fehler
// Falsch – versucht, eine Adresse dem dereferenzierten Zeiger zuzuweisen
*pc = &c; // Fehler
// Richtig – Adresse dem Zeiger zuweisen
pc = &c; // OK
// Richtig – Wert dem Ort zuweisen, auf den gezeigt wird
*pc = c; // OK

Für Anfänger kann die Syntax int *p = &c; verwirrend sein. Sie ist äquivalent zu:

int *p;
p = &c;

Das Schreiben als int* p = &c; reduziert Mehrdeutigkeit.

---

Nun, da Sie Zeiger verstehen, sind Sie bereit, deren Beziehung zu Arrays im nächsten Tutorial zu erkunden.