Der Wert an Speicheradresse 345686 – 0x0000002A – in hexadezimaler Schreibweise entspricht dabei der Zahl 42; da wir an die 3. Stelle im Array geschrieben haben (wir erinnern uns: Arrays sind 0-indiziert, der erste Index beginnt also bei 0, nicht bei 1), befindet sich der Wert entsprechend 8 Bytes (entspricht 2 Integer-Zahlen) hinter der Adresse, auf welche as verweist.

War doch eigentlich ganz einfach, oder? 2 wichtige Dinge sind aber noch zu beachten!

Speicher, der auf dem Heap reserviert wurde, muss auch irgendwann wieder freigegeben werden. Stack-Speicher wird ja automatisch freigegeben, wenn das Ende der aktuell ausgeführte Funktion erreicht wird; mit dem Heap funktioniert das nicht so einfach, da der Compiler nicht dafür sorgt, dass reservierter Heap-Speicher nach dem Ende des Bereiches, wo er benutzt wird, automatisch freigegeben wird (den Grund hierfür werden wir auch später sehen). Die Freigabe muss also manuell erfolgen, wenn man nicht irgendwann sämtlichen verfügbaren Speicher verbraucht haben möchte (zwar wird der Speicher bei Programmende freigegeben, aber dann ist es oft zu spät). Dies geschieht über das Schlüsselwort delete[], etwa einfach so:

void f( int n ) { int* as = new int[n]; as[2] = 42; delete[] as; }

Ein wichtiger Hinweis: auf dem Heap reservierter Speicher muss immer freigegeben werden! Wird das nicht gemacht, hat man ein sogenanntes Speicherleck; Speicherlecks sorgen für einen hohen Arbeitsspeicherverbrauch und sind unter allen Umständen zu vermeiden.

Und ein zweiter Hinweis: C++ erlaubt die Deklaration mehrerer Variablen in einer einzelnen Zeile. Im folgenden Beispiel werden zum Beispiel 2 Integer-Variablen m und n deklariert:

int m, n;

Bei der Deklaration von Variablen, die Speicheradressen aufnehmen, gibt es leider eine etwas unschöne Sache in C++ (eine Altlast aus C-Zeiten; wer die Begründung für dieses Verhalten kennt, möge sich bitte in den Kommentaren melden). Schauen wir uns den folgenden Code an:

int* as, bs;

Der unbedarfte C++-Neuling wird hier wahrscheinlich vermuten, 2 Variablen as und bs deklariert zu haben, die zur Speicherung von Arrays verwendet werden. Leider ist dem nicht so: der Stern * zur Markierung einer Adress-Variablen hängt am Namen der Variablen, nicht am zugehörigen Datentyp; as nimmt also wirklich eine Adresse auf, bs dagegen regulär eine ganze Zahl. Für 2 Adress-Variablen müssen wir das folgende schreiben:

int *as, *bs;

Ungewöhnlich, aber leider ist es so. Wo die Leerzeichen gesetzt werden, ist übrigens egal. Ich habe mir angewöhnt, bei Deklaration einer einzelnen Variablen den Stern an den Typ zu setzen, bei der Deklaration mehrerer Variablen den Stern an den Variablennamen – aber das kann jeder halten, wie er möchte.

Eine letzte Anmerkung: da mit dem Stern * deklarierte Variablen Speicheradressen aufnehmen und daher auf eine bestimmte Adresse im Speicher verweisen – also darauf zeigen, spricht man bei derartigen Variablen dementsprechend von Zeigern, beziehungsweise englisch von Pointern.

Im nächsten Artikel werden wir dann sehen, was man mit Pointern noch alles anstellen kann – bleibt also gespannt! Und diesmal dauert es hoffentlich nicht wieder so lang.

1 / 2 / 3

Kommentare (8)

  1. #1 Sascha
    Juli 18, 2013

    Daran sieht man wieder, dass Mehrfachdeklarationen in einer Zeile immer problematisch sein können.
    Lieber ein paar Zeilen mehr, dafür aber sauber deklarierte Variablen.

  2. #2 Frank Wappler
    https://lang--lang.ist's.her...
    Juli 18, 2013

    Marcus Frenkel schrieb (Juli 17, 2013):
    > […] dass der Compiler veranlasst, ein Array der Länge n (die erst zur Laufzeit bekannt ist) auf dem Heap anzulegen, oder, um genauer zu sein: im Heap wird ein Speicherbereich der Länge n * 4 Bytes (ein int-Wert benötigt 4 Bytes Speicher) reserviert.

    > nehmen wir für n zusätzlich einen Eingabewert von 5 an

    > Nehmen wir an, dass der new-Ausdruck den gewünschten Speicher (für 5 Integer-Werte) auf dem Heap ab der Adresse 345678 reserviert hat; Der Stack sieht dann folgendermaßen aus: […]

    Cliffhanger:
    Was wäre, falls ein zweiter Speicherbereich (z.B. der Länge “k * 4 Bytes”) zu reservieren und zu nutzen sein soll, bevor der beschriebene “eine Speicherbereich der Länge n * 4 Bytes, ab Adresse 345678” wieder freigegeben wird?

    Wird vom Compiler ein weiterer “Adresse-Wert ausdrücklich angewiesen?
    Oder weist der Compiler (per Programm) lediglich an, dass und wie ein weiterer “Adresse-Wert erst zur Laufzeit errechnet und in den Stack geschrieben wird?

  3. #3 Marcus Frenkel
    Juli 18, 2013

    @Frank Wappler
    So ungefähr. Durch das new-Schlüsselwort wird dynamisch zur Laufzeit Speicher reserviert; *wo* das gemacht wird, hängt mehr oder weniger vom Betriebssystem ab, das wird noch nicht während der Kompilierungszeit bestimmt. Das Betriebssystem verwaltet die freien Speicherbereiche und sorgt dafür, dass der neue Speicher an einer passenden Stelle reserviert wird. Zur Zeit der Kompilierung sind also die Adressen der dynamisch reservierten Speicherbereiche noch nicht bekannt, immer erst zur Laufzeit – und potentiell liefert jedes “new” eine neue Adresse (falls nicht vorher etwas per “delete” freigegeben wurde natürlich).

  4. #4 rolak
    Juli 18, 2013

    new-Schlüsselwort

    ‘Schlüsselwort’ (also analog zu ‘class’) halte ich für unangemessen – ist doch ‘new’ nur ein leichter zu schreibender Deckel für die Speicherreservierung, zB getmem(_type_, _count_, _init_), eher so etwas wie ein überladenes Makro.

    *wo* das gemacht wird, hängt mehr oder weniger vom Betriebssystem ab, das wird noch nicht während der Kompilierungszeit bestimmt

    Falls es um den Ort des Speichers geht: Nein bis Jein, siehe unten – falls um den Prozeß der Reservierung geht: Nein, das ist schon eine ordinäre RTL-Prozedur, die sich darum kümmert.

    Das Betriebssystem verwaltet die freien Speicherbereiche und sorgt dafür, dass der neue Speicher an einer passenden Stelle reserviert wird.

    Falls nicht von vorneherein die maximale Heapgröße feststeht und beim Programmstart akquiriert wird, ist es ein zweistufiger Prozeß. Im bisher vom Programm beschlagnahmten Speicher für den Heap lebt eine Datenstruktur (Liste, Heap, …), die von new() und delete() gepflegt wird. Sollte der Platz für den Erfolg eines new() nicht ausreichen und sowohl Compiler als auch OS dies zulassen, kann durch Anfrage beim OS evtl das Programm seinen Heap vergößern (und selbstverständlich im gegenteiligen Falle verkleinern), doch generell verwaltet das Programm mittels des Compilers RTL seinen Heap selber.

    Wegen der Verwaltungsdaten paßt auch das Heapabbild des posts nicht ganz: Wenn 345678 die Adresse des ersten passenden freien Blocks ist, erhält as den Wert 345678+x, wobei das x je nach Verwaltungsaufwand verschieden ist.

    dass der Compiler veranlasst, ein Array .. auf dem Heap anzulegen

    Vielleicht wäre es sinnvoll, entwirrenderweise umzuformulieren in etwas wie

    dass der Compiler Code generiert, der zur Laufzeit Speicher für ein Array .. auf dem Heap reserviert

    Abgesehen von der Verwaltung des Variablenplatzes ergibt ein “int ivar = const” den Code

    mov ivar,const

    während “int *ivar = new _type_ [n]” irgendwas ergeben dürfte wie

    mov eax,n
    imul eax, SizeOf(_type_)
    push eax
    call _getmem
    inc esp,4
    mov ivar,eax

  5. #5 michael
    Juli 19, 2013

    Ein im Programmcode bewirkt schon etwas mehr als reine Speicherbereitstellung.

    von: https://www.cplusplus.com/reference/new/operator%20new%5B%5D/

    operator new[] can be called explicitly as a regular function, but in C++, new[] is an operator with a very specific behavior: An expression with the new operator on an array type, first calls function operator new (i.e., this function) with the size of its array type specifier as first argument (plus any array overhead storage to keep track of the size, if any), and if this is successful, it then automatically initializes or constructs every object in the array (if needed). Finally, the expression evaluates as a pointer to the appropriate type pointing to the first element of the array

  6. #6 rolak
    Juli 20, 2013

    Es ist schwer zu sehen, worauf sich Dein Korrektur-Kommentar womit bezieht, michael, doch für die im blogpost genannten Beispiele (Variationen über ‘int’) gibt es afaik keine Initialisierung. Und meine Wenigkeit geruhte, diese allgemein als Pseudoargument einzuführen.

  7. #7 Havok
    August 25, 2013

    Wann geht’s weiter? :-]

  8. #8 Marcus Frenkel
    August 25, 2013

    Bald! 😉
    Der nächste Artikel ist in Arbeit. In letzter Zeit dauert es immer etwas länger – ich bitte das zu entschuldigen. 😉