Hängender Zeiger

Ein hängender Zeiger (englisch dangling pointer) bezeichnet in der Informatik einen Zeiger, der einen ungültigen Wert enthält und dadurch auf einen nicht vorhandenen oder nicht dem Zeiger zugeordneten dynamischen Speicherbereich (auch Heap genannt) verweist.[1]

Hintergrund

Hängende Zeiger kommen oft dadurch zustande, dass sie nicht initialisiert wurden (in dem Fall alternativ wilde Zeiger genannt) – aber auch dadurch, dass sie auf einen Speicherbereich verweisen, der bereits freigegeben wurde.[2] Hängende Zeiger können für den Programmlauf unvorhersehbare Auswirkungen haben und das Programm zum Absturz bringen.[3][4]

Während Userspace-Programme in der Regel bei einer Dereferenzierung eines Zeigers, der auf einen ungültigen Speicherbereich zeigt, beendet werden, kann ein solcher im Kernel bzw. dessen Modulen schlimmstenfalls das gesamte System beschädigen, ohne dass der Benutzer etwas bemerkt, bevor es zu spät ist, da keine Kontrollinstanz vorhanden ist, die z. B. das Überschreiben von fremdem Code verhindern könnte. Daher ist bei der Kernel- und Treiber-Entwicklung besonders auf die korrekte Verwendung zu achten.

Die Unvorhersehbarkeit rührt daher, dass ein Zugriff auf einen bereits freigegebenen Speicherbereich nicht zwangsläufig sofort einen Laufzeitfehler (Schutzverletzung) auslöst, da zwischen der Speicherfreigabe durch den Programmierer und der tatsächlichen Freigabe durch das Laufzeitsystem noch eine gewisse Zeit vergehen kann; ggf. ist der Speicherbereich inzwischen auch neu vergeben und ist dem Prozess tatsächlich wieder zugeteilt, aber in anderem semantischem Kontext. Findet auf (noch) erreichbaren (freigegebenen) Speicher ein Zugriff statt (Zeilen (*) im Beispiel), so löst er keinen Fehler aus. Da dies aber nicht reproduzierbar ist, sind diese sporadischen Fehler besonders schwer zu entdecken.

Beispiel

C++

#include <iostream>

using namespace std;

int main()
{
    int * pPointer = new int; // Pointer vom Typ integer angelegt und Speicher im Heap reservieren
    *pPointer = 10;           // 10 in den Heap schreiben, an die Speicheradresse, auf die der Pointer zeigt
    cout << pPointer;         // Zeigt die Speicheradresse im Heap an
    cout << *pPointer;        // Auf die Speicheradresse im Heap zugreifen, dort lesen und dann anzeigen ("10")
    delete pPointer;          // Speicher auf dem Heap freigeben
    cout << pPointer;         // Die Zeigervariable enthält noch immer die Speicheradresse, diese wird erneut angezeigt
                              // => pPointer ist nun ein Dangling Pointer
    cout << *pPointer;        // (*) Lesender Zugriff über Pointer auf freigegebenen Speicherbereich
                              // => das erzeugt (hoffentlich) einen Programmabbruch; wenn nicht, wird mit
                              // ungültigen Daten weitergearbeitet
    *pPointer = 20;           // (*) Schreibender Zugriff über Pointer auf freigegebenen Speicherbereich
                              // => noch schlimmer: das würde (bzw. kann) andere gültige Daten überschreiben
    pPointer = 0;             // => pPointer ist jetzt kein Dangling Pointer mehr, er ist nun ein Nullpointer
    return 0;
}

Es zeugt von gutem Programmierstil, nach einem delete den Pointer auf 0 zu setzen, auch wenn auf den Pointer nicht mehr zugegriffen wird.[5]

Siehe auch

Einzelnachweise
  1. 12. Dynamische Speicherverwaltung - 12.3. Hinweise für die Verwendung von malloc, calloc und free (Memento des Originals vom 26. August 2014 im Internet Archive)  Info: Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/public.beuth-hochschule.de Abgerufen am 22. August 2014.
  2. Zeiger. (Memento des Originals vom 22. November 2013 im Internet Archive)  Info: Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/www.informit.de In: C++ in 21 Tagen. ISBN 978-3-8272-5624-9. (Vagabundierende Zeiger) Abgerufen am 22. August 2014.
  3. Garbage-Collection in C++ - 2.1 Probleme bei der herkömmlichen Speicherverwaltung - Hängende Zeiger (Memento des Originals vom 26. August 2014 im Internet Archive)  Info: Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/www-old.cdc.informatik.tu-darmstadt.de Abgerufen am 22. August 2014.
  4. Security Insider - Webserver durch ungültige Zeiger zum Absturz gebracht Abgerufen am 23. August 2014.
  5. Zeiger. (Memento vom 22. November 2013 im Internet Archive) In: C++ in 21 Tagen. ISBN 978-3-8272-5624-9. (Listing 8.9: Einen vagabundierenden Zeiger erzeugen) Abgerufen am 19. Januar 2021.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.