spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Was wir übrigens bislang verschwiegen haben: Es gibt noch das Datensegment. Dort leben globale und statische Variablen. Das ist weder Heap noch Stack.

Ich sagte auch nicht, dass es keine Register gibt oder dass keine involviert sind. Aber in Registern zu denken ist in Bezug auf C++ nicht immer sehr hilfreich.

Wenn wir schon Segmente aufzählen, gibt's auch noch das Code-Segment Wobei das mit Segmenten in modernen CPUs mit virtueller Speicherverwaltung so 'ne Sache ist. Das ist nicht mehr so klassisch wie zu DOS-Zeiten, selbst die Segment-Register sind zu Selektoren umfunktioniert.

An sich wird im C++-Standard auch gar nicht von 'Heap' und 'Stack' geredet, sondern nur von dynamische und automatische (und statische) Speicherallokationen. Am Ende machst du dir mit 'new' nen Objekt und erhältst durch nen Zeiger Zugriff auf dieses. Dabei wird zuerst ein freier Speicherblock gesucht und anschließend darin ein Objekt konstruiert. Mit 'Objekt' ist nicht notwendigerweise ein solches im Sinne einer Instanz einer mit 'class' (oder 'struct') definierten Klasse gemeint. Ein 'float' ist nach dem C++-Standard ein Objekt.

Der Vorteil ist nun, dass die Existenz eines solchen Objekts nicht an einen lokalen Geltungsbereich innerhalb einer Funktion gebunden ist, wie das bei automatisch Verwalteten Objekten auf dem Stack als lokale Variable der Fall ist. Du kannst es dann zerstören und den belegten Speicherbereich freigeben, wann du lustig bist. Beispielsweise Objekte in einem Spiel. Was es für Objekte sind und wieviele davon, ist vorher nicht bekannt. Somit müssen sie dynamisch angelegt werden.
Zudem ist der Stack ziemlich limitiert ist, was die maximale Größe angeht. Ein Array von mehreren Millionen ints (wofür man das auch immer brauchen sollte) ist demnach besser dynamisch angelegt.

Übrigens ist es ratsam, 'new' (und 'delete') nicht manuell zu verwenden. Neben dem versehentlichen Vergessen eines 'delete' sind auch andere Bugs möglich. Wenn du soweit bist, ließ dich mal in 'Smartpointer' ein.

pZeiger lebt innerhalb des Blocks. Verwendest du ihn danach, wirft der Compiler nen Fehler, es sei denn, es gibt irgendwo eine weitere Variable 'pZeiger'. Übrigens solltest du dir nullptr statt NULL angewöhnen.

Zitat von »TigerClaw25«

Eine Frage noch, wenn ich kein delete verwende, müsste ich außerhalb eines Blocks weiterhin auf die Adresse zugreifen können, funktioniert aber nicht:

	C-/C++-Quelltext
1 2 3 4 5 6	{ int *pZeiger=NULL; pZeiger = new int; *pZeiger=100; } cout << *pZeiger << endl;

Ist die Adresse nicht weiterhin mit dem Wert 100 besetzt?

Die 100 steht immer noch in dem Speicher an der Adresse. Beim Verlassen des Scope wirfst du aber die Adresse / den Pointer weg und verlierst damit die Möglichkeit den Wert wiederzufinden. Das ist als wenn du dein Auto irgendwo parkst und dann vergisst wo es steht.

Du kannst mal ausprobieren dir im Scope die Adresse des Pointer ausgeben zu lassen und außerhalb des Scopes die Adresse wieder über eine Benutzereingabe einzugeben und daraus wieder einen Pointer zu erzeugen. Wenn du es richtig machst kannst du so wieder an die 100 kommen.

Zitat von »Tobiking«

Die 100 steht immer noch in dem Speicher an der Adresse. Beim Verlassen des Scope wirfst du aber die Adresse / den Pointer weg und verlierst damit die Möglichkeit den Wert wiederzufinden. Das ist als wenn du dein Auto irgendwo parkst und dann vergisst wo es steht.

Genau das ist der wichtige Punkt. Der Zeiger ist selbst wieder eine lokale Variable welche auf dein Array zeigt. Dein Array ist hinterher noch vorhanden, die Adresse ist jedoch weg.

Zitat von »TigerClaw25«

Bisher dachte ich, dass die Zeiger an sich immer auf dem Heap sind, weil dadurch das Problem mit der Parameterübergabe von Funktionen bei großen Objekten umgangen wird, aber die Zuweisung einer Adresse an sich hat mit Heap/Stack nichts zutun, so viel hab ich bereits verstanden.

Ein Zeiger ist erst mal nur eine Variable. So wie ein int eine Ganzzahl oder ein char ein einzelnes Zeichen speichert, so speichert ein Zeiger eben eine Adresse. Stell dir das wie bei deinem Haus vor. Dein Haus hat eine Adresse, diese Adresse ist aber nicht dein Haus. Du kannst die Adresse auf ein Stück Papier schreiben und es mir schicken. Wenn ich das Stück Papier verbrenne so habe ich deine Adresse nicht mehr, dein Haus steht aber noch.
Jetzt ist es bei C++ ja so dass Objekte bei der Parameterübergabe kopiert werden.

Bei einem Zeiger ist es das gleiche Spiel. Übergibst du einer Funktion einen Zeiger, so wird der Zeiger kopiert. Dabei werden nicht die Daten auf die der Zeiger zeigt kopiert, sondern nur die Variable die deren Adresse speichert. Das ist oft viel kleiner. Hast du ein Array mit 1000 Zahlen, so übergibst du einfach die Startadresse und zusätzlich die Größe deines Arrays. Kopiert werden jetzt ein Zeiger und eine Variable mit der Größe anstatt die 1000 Zahlen kopieren zu müssen. Bei anderen großen Objekten kannst du das eben genau so machen.
Was die Parameterübergabe angeht, wie schon angesprochen gibt es da noch die Referenzen. Die machen das Leben etwas einfacher.

Klar wird da eine Adresse übergeben. Und zwar als Pointer-Variable über den Stack. Also wird die Adresse (in den Stack) geschrieben/kopiert.