Welche Regeln für die Typumwandlung von Zeigern verschiedener Typen gibt es in C, welche Gefahren birgt die Umwandlung von void* in andere Typen und zurück, und wie kann man Fehler im Umgang mit dem Speicher bei der Umwandlung von Zeigern vermeiden?

Antwort

Die Typumwandlung von Zeigern ist eine häufige Operation in C, die es ermöglicht, allgemeine Schnittstellen zu verwenden, beispielsweise durch Arbeit mit void* oder die Implementierung universeller Datentypen. Allerdings geht die Typumwandlung von Zeigern mit bestimmten Risiken einher und unterliegt strengen Standards.

• void* in C speichert eine Adresse, kennt aber den Typ des Inhalts, auf den verwiesen wird, nicht. Jeder andere Zeiger (z.B. int*, char*, struct mytype*) kann explizit (oder implizit) in void* umgewandelt werden und umgekehrt, ohne Informationsverlust (es sei denn, es kommt zu einer „Verengung“).
• Wenn Sie jedoch einen Zeiger von einem Typ zu einem anderen (nicht zu void*) umwandeln, müssen Sie sicher sein, dass an dieser Adresse tatsächlich ein Wert des kompatiblen Typs vorhanden ist.
• Es ist gefährlich, mit Adressen zu arbeiten, die für einen Typ reserviert sind, aber durch einen „fremden“ Zeiger erhalten wurden: Es kann zu Problemen mit der Ausrichtung (alignment), undefiniertem Verhalten oder sogar zu Abstürzen kommen.

Beispiel

void process(void *data) {
    int *arr = (int*)data;
    // verwenden Sie arr als ein int-Array
}

int main() {
    double x = 10;
    process(&x); // GEFÄHRLICH: double* wird zu int* umgewandelt, UB
}

Fangfrage

„Kann jeder Zeiger sicher zu void* und zurück ohne Verluste umgewandelt werden?“

Viele antworten „ja“ – denn der C-Standard garantiert die Umwandlung jeden Objektzeigers in void* und zurück ohne Verluste. Aber wichtig ist zu beachten: Wenn Sie einen Nicht-Objekt-Zeiger (z.B. einen Funktionszeiger) in void* umwandeln oder unterschiedliche Architekturen mischen (die Größen von Zeigern unterscheiden sich für Funktionen und Daten), erhalten Sie undefiniertes Verhalten.

void foo() {}
void *p = (void*)foo; // UB! Ein Funktionszeiger kann nicht so umgewandelt werden

Beispiele für tatsächliche Fehler aufgrund mangelnden Wissens über die Feinheiten des Themas

---

Geschichte

In einem Projekt mit einer plattformübergreifenden Datenerfassungssubsystem wurde ein Handler eingesetzt, der einen Zeiger auf eine Struktur in void* umwandelte und dann zurück in den ursprünglichen Typ. Beim Wechsel zu einer Architektur, in der int* und double* unterschiedliche Ausrichtungen hatten, führte der Versuch, void* in den falschen Typ umzuwandeln, zu einem „bus error“ (Absturz).

---

Geschichte

In einem Embedded-Projekt implementierte ein Programmierer einen Ringpuffer mit einer universellen Schnittstelle auf void*, vergaß jedoch die strengen Anforderungen an die Ausrichtung (reservierte Speicher für ein char-Array, übergab als int*). Auf einigen Plattformen wurden die Daten für die Hardware „unverständlich“ – es traten Lese-Fehler und instabile Operationen auf.

---

Geschichte

In einer dynamischen Sammlung wurden Adressen als void* gespeichert, aber es wurde vergessen, dass ein Funktionszeiger nicht in void* umgewandelt werden kann. Der Versuch, einen Ereignishandler (Callback) über ein solches Feld zu speichern und weiterzugeben, führte auf einigen Plattformen zu Abstürzen, und es war äußerst schwierig, den Fehler zu erkennen.