CKTIS / C++
Stack und Heap: automatische Speicherdauer und dynamische Allokation
C++23 legt Speicherdauer und Regeln für die Objektlebensdauer fest, nicht den physischen Speicherort. Ein automatisches Objekt kann einen `std::string` enthalten, der Zeichenspeicher dynamisch allokiert.
Version: ISO C++23; implementation support may vary
Syntax
struct Record { std::string text; };
std::unique_ptr<Record> owner;
{
Record local{"abc"};
owner = std::make_unique<Record>();
} // local is destroyed; the Record owned by owner remains alive
owner.reset(); // destroys the owned Record and releases its storage„Stack und Heap“ ist eine Kurzform für eine übliche Implementierung, keine von C++23 garantierte Speicheraufteilung. Die Speicherdauer bezeichnet die minimale potenzielle Verfügbarkeit des Speichers eines Objekts; sie ist nicht mit dessen Lebensdauer gleichzusetzen. Eine gewöhnliche Blockvariable ohne static, thread_local oder extern hat automatische Speicherdauer. Wurde ihr Objekt konstruiert, wird es beim Verlassen des Blocks zerstört, auch beim Abwickeln des Aufrufstapels aufgrund einer Ausnahme.
std::make_unique<Record>() erzeugt ein separates Record-Objekt mit dynamischer Speicherdauer. Das lokale owner kann selbst automatische Speicherdauer haben, während das verwaltete Objekt den Block überdauern kann, in dem es erzeugt wurde. Bei der Zerstörung von owner zerstört dessen Standard-Deleter das noch verwaltete Objekt und gibt seinen Speicher frei. Das ist RAII: Das Besitzerobjekt verwaltet die Ressource. Gib keinen Zeiger und keine Referenz auf ein lokales Objekt zurück, das bei der Rückkehr aus der Funktion zerstört wird.
Das Mitglied text ist ein std::string-Teilobjekt mit derselben Speicherdauer wie das umgebende Record-Objekt. Der Speicher für die Zeichen ist davon zu unterscheiden: Der String verwendet bei Bedarf seinen Allokator. Eine Implementierung kann kurze Zeichenfolgen direkt im String-Objekt speichern (SSO), doch C++23 garantiert weder diese Optimierung noch einen Schwellenwert. Ein automatisches Record-Objekt schließt dynamische Allokationen daher nicht aus.
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 = "hello";
std::cout << "local: " << local.text.size() << '\n';
}
std::cout << "owned: " << owner->text.size() << '\n';
}
Ergebnis
local: 3 owned: 5
`local` wird beim Verlassen des inneren Blocks zerstört. Die zweite Zeile lässt sich dennoch ausgeben, weil `owner` das andere `Record`-Objekt bis zum Ende von `main` besitzt. Die Ausgabe zeigt weder den physischen Speicherort noch die Zahl der Allokationen.
Zugehörige Lektionen
- C++ · Lektion 22 · Fortgeschritten · Version: 3