„Hugo Hase gibt euch seine Visitenkarte”

• Größe eines Zeigers ist konstant, aber abhängig von Rechnerarchitektur

• Speichergröße

  • 4 Bytes → 32-Bit-Architektur
  • 8 Bytes → 64 Bit-Architektur

• Adresse, auf die gezeigt wird, kann an beliebiger Stelle stehen

• Bei Funktionen

  • Übergabe von Zeigern anstatt Kopie
  • Arbeitet über Zeiger auf Original

• Zuweisung einer Adresse ist unkompliziert möglich

  → Referenzierungsoperator &

• Achtung: Nicht zu verwechseln mit dem binären UND!

• Beliebter Fehler: Referenzieren wurde vergessen

  → Wert der Variable wird Adresswert

int i = 1;          // An Adresse 0x20
int * ptr = &i;     // Wert von ptr: 0x20

• Zugriff auf den Wert ist ebenso einfach → Dereferenzierungsoperator *

• Verwechselungsgefahr: Multiplikationsoperator oder Pointer-Stern

• Beliebter Fehler: Dereferenzieren wurde vergessen → Adresse anstatt Wert

• Wichtig: Typ einer Zeigervariable bestimmt die Anzahl der gelesenen Bytes ab der Adresse des Zeigers

int i = 1;
int * ptr = &i;
*ptr;

• Mit Zeigern Problem des Wertetauschs (Kap. 4) lösbar
• Bisher: Parameterübergabe als Kopie → Call by Value

int add(int sum1, int sum2) { return sum1 + sum2; };
int sum = add(1, 2);

• Funktionsparameter können auch Zeiger sein → Call by Reference

int add(int * sum1, int * sum2) { return *sum1 + *sum2; };
int sum = add(1, 2);

• Deklaration nun mit Zeigern anstatt mit elementaren Variablen

Welchen Wert hat dieser Zeiger nach der Deklaration? (64-Bit-Architektur)

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
#include <stdio.h>
int main() {
    int *ptr;
    printf("Adress: %p", ptr);
    return 0;
}

• Zeiger können NULL/nullptr sein

  • NULL häufig als #define NULL 0 implementiert (suboptimal)
  • nullptr seit C++11 bzw. C23 (spezielle Bedeutung)
  • nullptr ist immer zu bevorzugen, sofern verfügbar

• Guter Ton: Zeiger vor Verwendung überprüfen

  → Defensives Programmieren

void foo(int * ptr) {
    if (ptr == nullptr) {
        return;
    }
    else {/* ... */ }
}

Was aber, wenn der Zeiger nicht initialisiert ist?

• Verhalten einer Funktion dokumentieren, einschließlich erwarteter Parameterwerte

  → Verantwortung auf die Benutzer:in abwälzen

• Externe Regeln erzwingen

  • Programmierregeln in Software-Projekten → „Pointer sind immer zu initialisieren“
  • Compiler(-parameter) nutzen → Warnungen weisen darauf hin, z.B. -Wunitialized

Aber wie sieht der Speicher aus?

• Simples Beispiel für Stack Smashing

#include <string.h>

int main(int argc, char* argv[]) {
    char buf[4];
    strcpy(buf, argv[0]);
    printf("%s", buf);
    return 0;
}

*** stack smashing detected ***: terminated
    Aborted (core dumped)

• Simples Beispiel für Stack Smashing ohne Eingabe

#include <stdio.h>

int main(int argc, char* argv[]) {
    char buf[4];
    buf[0] = 'H';
    buf[1] = 'e';
    buf[2] = 'l';
    buf[3] = 'l';
    buf[4] = 'o';
    buf[5] = '!';
    buf[6] = '\0';
    printf("%s\n", buf);
    return 0;
}

• Im letzten Kapitel bereits angesprochen:
  • malloc() signalisiert Fehler über Rückgabewert
  • Tritt ein Fehler auf, gibt malloc() NULL zurück
• Außerdem: „C teilt den Grund mit”
• Globale Variable namens errno
• errno schauen wir uns jetzt genauer an

• Im Header errno.h zu finden
• Tritt Fehler auf, wird errno gesetzt
• Beispiel: errno == EEXIST; → „File exists“
• Fehler„werte” sind Makros
• Liste von möglichen Werten für GCC hier verlinkt
• Konvertierung zu lesbarem Text: strerror(errno);
• Für Speichermangel: Makro ENOMEM (steht für Error: No Memory)

• Programmierer:in kann errno ignorieren

• Aber: Einzige Möglichkeit, Fehler zu detektieren

• Beispiel: malloc() ohne Fehlerbehandlung

  • Schreibzugriff auf unzulässige Adresse
  • Betriebssystem erkennt dies
  • BS schreitet ein → Absturz 💥

• Verwendung von errno wird ausführlich dokumentiert

  → siehe Dokumentation → Lest sie! 😎

• Programmiert bitte defensiv → behandelt möglichst viele Fehlerfälle

• Das Konzept erlaubt im Prinzip unbeschränkte Indirektion
• Zeiger auf Zeiger sind problemlos erlaubt

int i = 0;
int * i1 = &i;      // Zeiger auf int
int ** i2 = &i1;    // Zeiger auf Speicher (interpretiere als int *)
int *** i3 = &i2;   // Zeiger auf Speicher (interpretiere als int **)
/* ... */

• Zeiger mit mehrfacher Indirektion erfordern viel Aufmerksamkeit

  → sehr großes Fehlerpotential

• Tipp: Bei Zuweisungen/Zugriffen mentale Checkliste durchgehen

  1. „Welche Typen haben die Variablen?”

     • int **i, *j, k = 1;

  2. „Passen die Typen schon, wenn ich die so verwende?

     Oder muss ich noch passend referenzieren/dereferenzieren?”

     • j = &k; i = &j;

  3. „Welchen Wert brauche ich gerade? Was muss ich dafür tun?”

     • Beispiel: Zugriff auf zugrundeliegenden int k
     • *(*i);

• Zeiger werden auch in Arrays verwendet

• Genauer gesagt: Arrays sind Pointer mit zusätzlicher Dereferenzierung und Längeninformation

• Beispiel: char arr[4];

• Arraybezeichner arr ist Zeiger auf den Beginn des Speicherblocks

  (\(\hat{=}\) erster Eintrag des Arrays arr[0])

• Arrayindex gibt Offset von der Startadresse an

• Bei Umwandlung von Array zu Pointer entsteht Informationsverlust (Länge)

  → Wird auch Pointer Decay genannt (Herabstufung zu Zeiger)

• Offset-Veränderung um \(n\) entspricht Byte-Veränderung von

  \(n\) x sizeof(Datentyp)

#include <stdio.h>

int main() {
    double d = 1.0;
    double * ptr = &d;

    printf("%p\n", ptr);

    ptr += 1;               // ptr + 8 Bytes
    printf("%p\n", ptr);

    char * c = (char*)"c";
    printf("%ld\n", (c+1) - c);
}

• Folgende Notationen sind identisch:

#include <stdio.h>

int main() {
    int arr[4] = {1, 2, 3, 4};
    int *ptr = arr;

    int i = arr[2];           // Standard, bereits bekannt
    int j = *(arr + 2);       // Umwandlung des Compilers von arr[2]
    int k = *(&(arr[0]) + 2);
    int l = ptr[2];           // Arraynotation geht auch mit Zeigern
    int m = 2[arr];           // *(2+arr) == *(arr+2)

    printf("i: %d\nj: %d\nk: %d\nl: %d\nm: %d\n", i, j, k, l, m);
    return 0;
}

• 🚨Achtung: Zeigerarithmetik wird nicht überprüft

  → Berechnung von beliebigen Adressen möglich

int i = 1;              // Stackadresse: 0x20
char arr [3] = "ca";    // Stackadresse: 0x24
int *k = 0x20;          // *k == 1 (Valider Wert)
++k;                    // Zeigt auf 0x24 (*k ist nun fehlerhaft)

Pointer-Arithmetik nur sehr behutsam und sparsam benutzen

• Zunächst einmal: Gelten die gleichen Regeln wie für alle anderen Datentypen
• Kleine Unterschiede bei Notation
  • Initialisierung/Deklaration ist prinzipiell gleich
  • Bei Zugriff gibt es wie bei Array-Indizes eine eigene Schreibweise
  • Statt Punktoperator (.) wird Pfeiloperator (->) genutzt

  struct Foo { int i; };
  struct Foo f = { 1 };
  struct Foo * k = &f;
  k->i = 2;       // -> ist Kurzform ...
  
  (*k).i = 42;    // ... für dieses Konstrukt

#include <stdio.h>
#include <stdlib.h>
struct A { int i; struct A * ptr; };

int main() {
    struct A a = { 1, nullptr };
    struct A *b = (struct A *) malloc(sizeof(struct A));

    b->i = 2;
    b->ptr = nullptr;
    a.ptr = b;

    printf("A: %d\nB: %d\n", a.i, a.ptr->i); // Pfeil -> nur für Zeiger
    free(a.ptr);
    printf("A: %d\nB: %d\n", a.i, a.ptr->i); // UB: Use after free()
}

Pfeiloperator nur auf Zeigervariablen anwenden (beliebter Fehler)

• Bisher: Datenstrukturen dürfen sich selbst nicht enthalten

struct Foo { struct Bar b; };
struct Bar { struct Foo f; }; // Error

struct Foo { Foo * f; };

• Frage: Welche Größe wird ausgegeben?

#include <stdio.h>

struct Example {
    char foo[3]; // 3 Bytes
    int bar;     // 4 Bytes
    bool baz;    // 1 Byte
};

int main() {
    struct Example ex = { "ab", 4, true };
    printf("Size: %ld, Alignment: %ld\n", sizeof(ex), alignof(struct Example));
}

• Speicher ist typischerweise an festen Grenzen ausgerichtet

  • Lesen und Schreiben erfolgt typischerweise in mehrere Speicherzellen gleichzeitig
  • Ausrichtung (Alignment) macht dies möglichst effizient

• Einzelne Elemente kleiner als Alignment-Wert

  → Einfügen von „Polsterung“ (Padding Bytes)

• Alignment-Raster abfragen mit alignof()

• Was passiert hier?

int i = 1;
int * ptr1 = &i;
double * ptr2 = (double *) ptr1;

• Das letzte Beispiel zeigt: C hat Probleme!

• Einerseits: Typangabe bei Deklaration immer erforderlich

• Andererseits: Umgehung des Typsysstems sehr einfach möglich

  • Der Compiler lässt das zu; warnt höchstens
  • Deswegen: Programmier:in trägt Verantwortung für Korrektheit

• Wird häufig „stark typisiert, aber mit schwacher Umsetzung” bezeichnet

  (strongly typed, weakly enforced)

• C++ ist hier deutlich strenger, aber deswegen auch komplizierter

• Callbacks sind Funktionen als Aufrufparameter
• Werden anschließend (oder zu gegebener Zeit) aufgerufen (→ Name)
• Sehr nützlich: Erlauben Definition einer generischen Programmierschnittstelle
• In C sind alle Funktionen Zeiger!
• Beispiel:

int add (int x, int y);
int sub (int x, int y);

int call_func(int (*func)(int, int), int int1, int int2) {
    return func(int1, int2);
}

• Grundannahme: Nur das Programm modifziert Speicher
• Folge: Compiler darf Zugriffe entfernen und tut das!
  • Siehe Compiler-Optionen -O1 bis -O3
  • Bringt Performance
• Problem: Annahme gilt nicht für Hardware
  • Geräte ändern asynchron ihren Zustand
  • Zustandänderung über Register im Speicher lesbar

• Analog zu volatile gibt es Schlüsselwort const
• Markiert Variable als unveränderlich
• Variable mit const kann einmal* initialisiert werden, danach unveränderbar
• Bereits implizit bekannt und benutzt: String-Literale haben den Typ
  • Beispiel: "Hello World"; // Typ: const char *
• Compiler warnt bei Modifikation 😀

• Bei Zeigern ist bei Verwendung von const etwas Vorsicht geboten🚨

• Bisher: Verbergen des eigentlichen Speicherzugriffs - int j = 42;