Stack vs. Heap Speicher

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy. Lektion 12 von 104.

C++-Programme verwenden zwei wichtige Speicherbereiche: den stack und den heap. Zu verstehen, wo deine Objekte leben, ist entscheidend, um effizienten und fehlerfreien Code zu schreiben.

Der Stack ist ein schneller, automatisch verwalteter Speicher. Variablen, die innerhalb von Funktionen deklariert werden, leben hier und werden automatisch zerstört, wenn sie ihren Gültigkeitsbereich verlassen.

void example() {
    int x = 10;           // Stack-Allokation
    Player player;        // Stack-Allokation - wird automatisch zerstört
}   // x und player werden hier zerstört

Der heap ist größere, aber langsamere memory, die du manuell verwaltest. Objekte auf dem heap bleiben bestehen, bis du sie ausdrücklich delete.

void example() {
    Player* player = new Player();  // Heap-Allokation
    // player existiert, bis er gelöscht wird
    delete player;                   // Manuelle Bereinigung erforderlich
}

Wichtige Unterschiede:

Stack	Heap
Schnelle allocation	Langsamere allocation
Begrenzte Größe	Große Kapazität
Automatische cleanup	Manual cleanup erforderlich
Objekte fester Größe	Objekte dynamischer Größe

Verwende stack allocation für kleine, kurzlebige Objekte. Verwende heap allocation, wenn Objekte ihren Gültigkeitsbereich überdauern müssen oder wenn ihre Größe zur Laufzeit bestimmt wird.

Das Vergessen, Heap-Speicher zu löschen, verursacht memory leaks, eine häufige Fehlerquelle in C++-Programmen.

Aufgabe

Einfach

Sehen wir uns den Unterschied zwischen Stack- und Heap-Speicher an, indem wir eine einfache Counter-Klasse erstellen, die verfolgt, wie Objekte erstellt und destroyed werden.

Du erstellst zwei Dateien, um deinen Code zu organisieren:

Counter.h: Definiere eine Counter-Klasse mit einem privaten name-Attribut (String). Füge einen constructor hinzu, der einen Namen entgegennimmt und "Creating: <name>" ausgibt, sowie einen destructor, der "Destroying: <name>" ausgibt. Füge eine getName()-method hinzu, die den Namen des counters zurückgibt.
main.cpp: Demonstriere sowohl Stack- als auch heap allocation. Lies einen Namen aus dem input ein und:
- Erstelle einen Stack-zugewiesenen Counter mit diesem Namen
- Erstelle einen heap-zugewiesenen Counter mit dem Namen "HeapCounter"
- Gib beide counter-Namen im format "Stack: <name>" und "Heap: <name>" aus
- Führe delete für den heap-zugewiesenen counter aus, um ein memory leak zu prevent

Beobachte, wie die Meldungen des constructors und destructors in unterschiedlicher Reihenfolge erscheinen, abhängig davon, wann du jedes Objekt erstellst und löschst. Das Stack-Objekt wird automatisch destroyed, wenn main() endet, während das Heap-Objekt ausdrücklich gelöscht werden muss.

include deine Header-Datei in main.cpp mit #include "Counter.h".

Probier es selbst

#include <iostream>
#include <string>
#include "Counter.h"

using namespace std;

int main() {
    // Namen von der Eingabe lesen
    string inputName;
    cin >> inputName;

    // TODO: Erstelle einen stack-allokierten Counter unter Verwendung von inputName

    // TODO: Erstelle einen heap-allokierten Counter mit dem Namen "HeapCounter"

    // TODO: Print stack counter name in format "Stack: <name>"

    // TODO: Gib den Namen des Heap-Counters im Format "Heap: <name>" aus

    // TODO: Lösche den heap-allokierten Counter, um ein Speicherleck zu verhindern

    return 0;
}