Dynamische Speicherzuweisung

Es gibt zwei Arten von Speicher, die zur Verfügung stehen: Stack und Heap. Der Stack-Speicher ist in der Größe begrenzt und eignet sich gut für kleine, kurzlebige Variablen, die über ihren Gültigkeitsbereich hinaus nicht benötigt werden. Wenn eine auf dem Stack gespeicherte Variable ihren Gültigkeitsbereich verlässt, wird sie automatisch zerstört.

stack_allocated


              12
            
// Creates an integer variable on the stack
int stack_int = 42;

Wenn Sie jedoch Speicher benötigen, der länger als sein Gültigkeitsbereich bestehen bleibt oder mehr Platz erfordert, wenden Sie sich an den Heap. Der Heap ist ein viel größerer Speicherpool, in dem Ihr Programm zur Laufzeit Speicher anfordern kann. Dies wird typischerweise mit dem new Schlüsselwort durchgeführt:

heap_allocated


              12
            
// create an integer on the heap
int* heap_int = new int;

Das knifflige an Heap-Speicher ist, dass er nicht automatisch freigegeben wird. Es liegt in der Verantwortung des Entwicklers, ihn freizugeben, wenn er fertig ist. Für jedes new muss es ein entsprechendes delete geben.

free_pointer


              12
            
// Explicitly deletes the integer on the heap
delete heap_int;

Speicherlecks

Wenn Sie Zeiger in Ihren Code einführen, betreten Sie den Bereich der manuellen Speicherverwaltung. Manuelle Speicherverwaltung erfordert, dass Sie den Speicher freigeben, wenn er nicht mehr benötigt wird. Dies kann zu häufigen Fallstricken führen: Speicherlecks und hängende Zeiger.

Speicherlecks treten typischerweise auf, wenn Sie vergessen, den Speicher freizugeben. Solcher Speicher bleibt reserviert, was dazu führt, dass Ihr Programm im Laufe der Zeit Speicher verliert.

memory_leak


              12345
            
running = true
while (running)
{
    int* p_int = new int;
}

Hängende Zeiger

Hängende Zeiger treten auf, wenn ein Zeiger weiterhin auf einen Speicher zeigt, der freigegeben wurde. Es ist, als hätte man eine Schatzkarte, die einen zu einem Ort führt (Speicheradresse), an dem der Schatz (Daten) bereits genommen (zerstört) wurde.

main


              12345678910111213
            
#include <iostream>

int main()
{
    int* ptr = new int; // dynamically allocate an integer

    *ptr = 42; // assign a value to the allocated memory
    std::cout << *ptr << std::endl; // This will output 42

    delete ptr; // deallocate the memory

    std::cout << *ptr << std::endl; // ptr is a dangling pointer!
}

Versuch, auf einen Zeiger zuzugreifen, nachdem delete darauf aufgerufen wurde, was den Speicher freigibt, auf den er zeigte. Nach der Löschung wird der Zeiger zu einem hängenden Zeiger, da er immer noch die Adresse eines Speichers enthält, der nicht mehr existiert.

Der Zugriff auf einen hängenden Zeiger kann zu unvorhersehbarem Verhalten oder sogar Abstürzen führen, da der Speicher, auf den er zeigt, nicht mehr gültig ist.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 2