⚙️ C & C++ Systems Engineering

C 02: Pointer, Speicheradressen (&/*) & Zeigerarithmetik

Das Herzstück von C: Verstehe physikalische Speicheradressen, die Operatoren & und *, Zeigertypen, Pointer-Arithmetik und Pass-by-Reference Simulation in C.

🧠 1. Das Fundament: Was ist eine Speicheradresse?

Der Arbeitsspeicher (RAM) ist eine gigantische, durchnummerierte Kette von Bytes. Jede Variable belegt ab einer bestimmten Adresse Speicher:

int zahl = 42;       // Liegt z. B. an Adresse 0x7ffd50
int* ptr = &zahl;    // 'ptr' speichert die Adresse 0x7ffd50
*ptr = 99;           // Dereferenzierung: Schreibt 99 an die Adresse von 'zahl'!
📍 Speicherlayout-Visualisierung:
[Adresse] [Typ] [Variable] [Wert / Inhalt]
--------------------------------------------------------
0x7ffd50 int zahl 42 (bzw. 99 nach *ptr=99)
0x7ffd58 int* ptr 0x7ffd50 ────┐ (Zeigt auf 'zahl')
│
▼
*ptr greift direkt auf 0x7ffd50 zu!
📦 Didaktische Analogie: Postfach und Adresszettel

Die Variable (zahl): Ein Schließfach in der Bank, in dem Goldmünzen (der Wert 42) liegen.

Der Adressoperator (&zahl): Ermittelt die exakte Schließfachnummer (z. B. Fach Nr. 50).

Der Pointer (ptr): Ein Notizzettel, auf dem "Fach Nr. 50" notiert ist.

Die Dereferenzierung (*ptr): Du gehst mit dem Zettel zum Schließfach Nr. 50, steckst den Schlüssel hinein und nimmst den Inhalt heraus oder legst etwas Neues hinein!

📐 2. Zeigerarithmetik (Pointer Arithmetic)

Wenn du zu einem Pointer + 1 addierst, addiert die CPU nicht 1 Byte, sondern springt um die Größe des Ziel-Datentyps (sizeof(*ptr)) weiter:

Zeigertyp Zielgröße sizeof(T) Operation ptr + 1 Speicherverschiebung
char* 1 Byte 0x1000 + 1 +1 Byte
int* 4 Bytes 0x1000 + 1 +4 Bytes (0x1004)
double* 8 Bytes 0x1000 + 1 +8 Bytes (0x1008)

Array-Decay & Pointer-Traversierung:

int werte[3] = {10, 20, 30};
int* p = werte; // Array-Decay: 'werte' zerfällt automatisch in Zeiger auf erstes Element

printf("%d\n", *p);       // 10
printf("%d\n", *(p + 1)); // 20 (Springt 4 Bytes weiter)
printf("%d\n", *(p + 2)); // 30 (Springt 8 Bytes weiter)

🔄 3. Pass-by-Reference Simulation mit Zeigern

In C gibt es ausschließlich Pass-by-Value. Wenn eine Funktion Variablen des Aufrufers modifizieren soll oder mehrere Rückgabewerte benötigt werden, übergeben wir Pointer auf die Variablen:

void swap(int* a, int* b) {
    if (a == NULL || b == NULL) return;
    int temp = *a;
    *a = *b;
    *b = temp;
}

int x = 5, y = 10;
swap(&x, &y); // x ist jetzt 10, y ist jetzt 5!

🧠 Diagnostischer Selbst-Check

Überprüfe dein Verständnis zu Speichersicherheit, Syntax und Systems-Design mit gezieltem Feedback:

🎯 Aufgaben & Checkliste in aufgabe.c

💡 Pointer Pro-Tipp: NULL-Pointer Safety

Dereferenziere niemals einen Zeiger ohne vorherige Null-Prüfung: if (ptr != NULL) { *ptr = 42; }. Ein Zugriff auf NULL führt zu einem sofortigen Segmentation Fault (SIGSEGV)!

💻 In Web-IDE öffnen → ← Zurück zu C 01 Weiter zu C 03 →