WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Automatische Speicherdauer und dynamische Speicherallokation

Unterscheide Speicherdauer und Lebensdauer eines Objekts von separaten Speicheranforderungen seiner Member, etwa für die Zeichen eines `std::string`.

Version: ISO C++23; implementation support may vary

Syntax

T local{args...};                                      // Direct declaration; automatic in an ordinary block.
std::unique_ptr<T> owner = std::make_unique<T>(args...); // The local owner and its dynamically created T are separate objects.
owner.reset();                                         // Destroy the owned T; owner remains alive and becomes empty.

In C++23 beschreibt die Speicherdauer, wie lange der Speicher für ein Objekt verfügbar bleiben kann. Die Lebensdauer beschreibt, wann das Objekt selbst existiert. Eine gewöhnliche Blockvariable ohne static, thread_local oder extern hat automatische Speicherdauer. Ein konstruiertes Klassenobjekt wird beim Verlassen des Blocks zerstört, auch beim Abwickeln des Aufrufstapels infolge einer Ausnahme. Die Sprachregel schreibt keine Ablage auf einem physischen Stack vor.

std::make_unique<Record>() erzeugt mit einem new-Ausdruck ein Record-Objekt und gibt einen std::unique_ptr<Record> zurück, der es exklusiv besitzt. Im Beispiel hat owner selbst automatische Speicherdauer. Das von ihm verwaltete Record-Objekt hat dagegen dynamische Speicherdauer und überdauert den inneren Block. owner.reset() zerstört dieses Objekt und gibt dessen Speicher frei; der nun leere owner bleibt bestehen. Greife nicht über einen Zeiger oder eine Referenz auf ein zerstörtes Objekt zu.

Der Member Record::text hat dieselbe Speicherdauer wie das umgebende Record-Objekt. Der Speicher für die Zeichen ist davon zu trennen: std::string kann ihn bei Bedarf über seinen Allokator anfordern. Die Small-String-Optimierung (SSO) kann Zeichen im Stringobjekt selbst unterbringen. C++23 schreibt weder SSO noch eine bestimmte Längengrenze vor.

„Stack oder Heap“ ist eine umgangssprachliche Kurzform, keine Garantie für die physische Platzierung. Nutze ein direkt deklariertes lokales Objekt, wenn seine Lebensdauer mit dem Block enden soll, und std::unique_ptr, wenn ein separates, dynamisch erzeugtes Objekt exklusiven Besitz benötigt.

Beispiele

#include <iostream>
#include <memory>
#include <string>

struct Record {
    std::string text;
};

int main() {
    std::unique_ptr<Record> owner;
    {
        Record local{"abc"};
        owner = std::make_unique<Record>();
        owner->text.assign(1000, 'x');
        std::cout << local.text.size() << ' ' << owner->text.size() << '\n';
    }
    std::cout << owner->text.size() << '\n';
    owner.reset();
    std::cout << (owner ? "owns a record" : "empty") << '\n';
}

Ergebnis

3 1000
1000
empty

Wenn Allokation und Ausgabe gelingen, erscheinen beide Stringlängen, nach dem inneren Block erneut die Länge des verwalteten Strings und nach `reset()` schließlich `empty`. Die Ausgabe zeigt weder Adressen noch die Anzahl der Allokationen.

Zugehörige Lektionen

  • C++ · Lektion 22 · Fortgeschritten · Version: 3

Quellen