CKTIS / C++
Stack en heap: automatische opslagduur en dynamische allocatie
C++23 legt de opslagduur en de regels voor de levensduur van objecten vast, niet hun fysieke locatie. Een automatisch object kan een `std::string` bevatten die dynamisch geheugen voor tekens reserveert.
Versie: 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 en heap’ is een gebruikelijke verkorte aanduiding voor een implementatiekeuze, niet voor een fysieke indeling die C++23 garandeert. De opslagduur beschrijft de minimale potentiële periode waarin de opslag van een object beschikbaar blijft; dat is niet hetzelfde als de levensduur van het object. Een gewone blokvariabele zonder static, thread_local of extern heeft automatische opslagduur. Als het object is geconstrueerd, wordt het bij het verlaten van het blok vernietigd, ook bij het afwikkelen van de aanroepstack na een uitzondering.
std::make_unique<Record>() maakt een afzonderlijke Record met dynamische opslagduur. De lokale variabele owner kan zelf automatische opslagduur hebben, terwijl het beheerde object langer kan bestaan dan het blok waarin het werd gemaakt. Bij vernietiging van owner vernietigt de standaarddeleter het object dat nog in zijn bezit is en geeft de opslag vrij. Dit is RAII: het eigenaarobject beheert de resource. Geef geen pointer of referentie terug naar een lokaal object dat bij terugkeer uit de functie wordt vernietigd.
Het lid text is een std::string-subobject met dezelfde opslagduur als de omvattende Record. De opslag voor de tekens staat daar los van: de string gebruikt zo nodig zijn allocator. Een implementatie kan korte strings in het stringobject zelf opslaan (SSO), maar C++23 garandeert die optimalisatie niet en geeft er geen grenswaarde voor. Een automatische Record sluit dynamische allocaties dus niet uit.
Voorbeelden
#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';
}
Resultaat
local: 3 owned: 5
`local` wordt vernietigd bij het verlaten van het binnenste blok. De tweede regel kan toch worden afgedrukt, omdat `owner` de andere `Record` tot het einde van `main` bezit. De uitvoer toont niet de fysieke locatie of het aantal allocaties.
Gerelateerde lessen
- C++ · Les 22 · Gevorderd · Versie: 3