📘 Kapitel 6 · Zeiger & Speicher

Pointer und
Arrays

Array-Name = Pointer · Pointer-Arithmetik · *(arr+i)

27 / 30 Units
Ömer
Unit 27 von 30 ~45 Min. Theorie + Simulator + Quiz + Spickzettel
Ömer
Ömer sagt:

Arrays und Pointer – in C sind sie das gleiche! Der Array-Name ist ein Pointer auf das erste Element. arr[i] und *(arr+i) sind identisch!

Array-Name ist Pointer

arr_ptr.cC
int a[] = {10,20,30};
int *p = a;     // kein &!
printf("%d %d\n", a[1], *(a+1)); // 20 20
printf("%d %d\n", p[2], *(p+2)); // 30 30

arr[i] ≡ *(arr+i)

Der Compiler übersetzt beide Schreibweisen identisch. arr[i] ist lesbarer, *(arr+i) zeigt was wirklich passiert.

Warum Arrays ohne & übergeben werden

Weil der Array-Name bereits ein Pointer ist: f(arr) übergibt die Adresse des ersten Elements – kein & nötig und keine Kopie!

Pointer-Arithmetik im Detail

Wenn du einen Pointer um 1 erhöhst (p++), springt er nicht 1 Byte weiter, sondern genau sizeof(Typ) Bytes – also zum nächsten Element im Array.

Typsizeofp++ springt um
int *p4 Bytes4 Bytes weiter
char *p1 Byte1 Byte weiter
double *p8 Bytes8 Bytes weiter
ptr_arith.cC
int arr[] = {10, 20, 30, 40};
int *p = arr;
while (p < arr + 4) {
    printf("%d ", *p);
    p++;
}
// Output: 10 20 30 40
▶ Ausgabe
10 20 30 40

Typ bestimmt die Schrittweite

Der Compiler berechnet automatisch die richtige Byte-Anzahl pro Schritt – basierend auf dem deklarierten Zeigertyp. Deshalb ist der Typ bei Pointern so wichtig!

arr[i] ist dasselbe wie *(arr+i)

Der Compiler übersetzt arr[i] intern immer zu *(arr+i). Beide Schreibweisen sind exakt identisch – das ist keine Vereinfachung, sondern die tatsächliche C-Semantik.

arr_equiv.cC
int a[] = {5, 10, 15};
printf("%d\n", a[2]);       // 15
printf("%d\n", *(a + 2));  // 15  – identisch!
printf("%d\n", 2[a]);       // 15  – auch gültig aber nicht empfohlen!
▶ Ausgabe
15 15 15

2[a] – warum funktioniert das?

Weil a[2] zu *(a+2) wird und Addition kommutativ ist: *(a+2) == *(2+a) == 2[a]. Technisch korrekt, aber nie in echtem Code verwenden – verwirrend!

Häufige Fehler

Array-Name ist unveränderlicher Pointer

arr++ funktioniert nicht! Der Array-Name ist ein konstanter Pointer – er zeigt immer auf das erste Element und kann nicht verschoben werden. Nur ein int *p = arr; und dann p++ ist erlaubt.

FehlerProblemRichtig
arr++Array-Name ist kein veränderbarer Pointerint *p = arr; p++;
*(arr + 10) bei arr[5]Lesen nach Array-Ende → Undefined BehaviorIndex < Größe prüfen
sizeof(p) in FunktionGibt Pointer-Größe (4 oder 8), nicht Array-GrößeGröße als Parameter übergeben

sizeof-Falle in Funktionen

In einer Funktion void f(int *arr) liefert sizeof(arr) immer 4 oder 8 (Pointer-Größe), nie die Array-Größe. Das Array "zerfällt" beim Übergeben zum Pointer – die Größeninformation geht verloren. Lösung: Größe als zweiten Parameter int n übergeben.

⚡ Code-Simulator

Teste den Code direkt im Browser – printf-Ausgaben werden simuliert:

C Simulator – Unit 27
▶ Ausgabe
– Klicke AUSFÜHREN –
Ömer
Ömer sagt:

Experimentiere mit dem Code – das ist der beste Weg um Pointer und structs wirklich zu verstehen!

🎯 Wissens-Quiz

Frage 1
Was ist ein Array-Name in C?
AEin Wert
BEin Pointer auf das erste Element
CEin spezieller Typ
DEin String
Frage 2
Was ergibt *(arr+2) für int arr[]={5,10,15}?
A5
B10
C15
DFehler
Frage 3
Warum übergibt man Arrays ohne & an Funktionen?
AKonvention
BDer Array-Name ist bereits ein Pointer
CArrays sind zu groß für &
DMuss man nicht
Frage 4
Was ist arr[i] equivalent zu?
Aarr+i
B*(arr)+i
C*(arr+i)
D&arr+i
Frage 5
Was zeigt p+1 wenn p ein int-Pointer ist?
A1 Byte weiter
B4 Bytes weiter (nächstes int)
Cp verdoppelt
DNichts
Frage 6
Was ist arr[i] äquivalent zu?
Aarr+i
B&arr[i]
C*(arr + i)
D*(arr) + i
Frage 7
Warum kann arr++ nicht verwendet werden wenn arr ein Array-Name ist?
A++ ist nur für int erlaubt
Barr ist ein konstanter Pointer auf das erste Element
CArrays haben keine Adresse
D++ würde das Array löschen
Frage 8
Was ergibt arr+3 wenn arr ein int-Array ist?
ADer Wert arr[3]
BDie Adresse plus 3 Bytes
CDen Wert 3
DAdresse des vierten Elements (arr + 3*sizeof(int))

📋 Spickzettel

Array & Pointer
int *p = arr;Pointer auf Array
arr[i] = *(arr+i)Gleich!
p++Nächstes Element
f(arr, n)Übergabe ohne &
Pointer-Arithmetik
p+1Nächstes Element
p-1Vorheriges Element
p2-p1Abstand in Elementen
Typ bestimmtBytes-Sprung

✅ Checkliste Unit 27

  • Ich weiß dass Array-Name = Pointer ist
  • Ich kenne den Zusammenhang arr[i] = *(arr+i)
  • Ich verstehe warum Arrays ohne & übergeben werden
  • Ich kann Pointer-Arithmetik anwenden