CKTIS / C++
Automatische opslagduur tegenover dynamische allocatie
Maak onderscheid tussen de opslagduur en levensduur van een object en de afzonderlijke allocaties van zijn leden, bijvoorbeeld voor de tekens van een `std::string`.
Versie: 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 geeft opslagduur aan hoelang de opslag voor een object beschikbaar kan blijven; de levensduur geeft aan wanneer het object zelf bestaat. Een gewone blokvariabele zonder static, thread_local of extern heeft automatische opslagduur. Een geconstrueerd klasseobject wordt vernietigd bij het verlaten van het blok, ook wanneer de aanroepstack door een uitzondering wordt afgewikkeld. De taalregel schrijft niet voor dat het object op een fysieke stack staat.
std::make_unique<Record>() maakt met een new-expressie een Record aan en retourneert een std::unique_ptr<Record> die exclusief eigenaar is. In het voorbeeld heeft owner zelf automatische opslagduur, maar de Record waarvan hij eigenaar is, heeft dynamische opslagduur en blijft na het binnenste blok bestaan. owner.reset() vernietigt die Record en geeft de opslag ervan vrij; de nu lege owner blijft bestaan. Gebruik geen pointer of referentie om een vernietigd object te benaderen.
Het lid Record::text heeft dezelfde opslagduur als de omvattende Record. De opslag voor de tekens staat daar los van: std::string kan die zo nodig via zijn allocator verkrijgen. Een small-string-optimalisatie (SSO) kan tekens in het stringobject zelf opslaan, maar C++23 schrijft noch SSO, noch een specifieke lengtegrens voor.
‘Stack tegenover heap’ is informele taal, geen garantie over de fysieke plaatsing. Kies een direct gedeclareerd lokaal object als de levensduur met het blok moet eindigen, en std::unique_ptr als een afzonderlijk, dynamisch gemaakt object een exclusieve eigenaar nodig heeft.
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.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';
}Resultaat
3 1000 1000 empty
Als de allocatie en uitvoer lukken, toont het programma beide tekenreekslengtes, na het binnenste blok opnieuw de lengte van de tekenreeks in het beheerde object, en ten slotte `empty` na `reset()`. De uitvoer toont geen adressen en telt geen allocaties.
Gerelateerde lessen
- C++ · Les 22 · Gevorderd · Versie: 3
Bronnen
- N4950 — Working Draft, Standard for Programming Language C++ (C++23)
- Automatic storage duration [basic.stc.auto]
- Storage duration — General [basic.stc.general]
- Lifetime [basic.life]
- Declaration statement [stmt.dcl]
- New [expr.new]
- unique_ptr creation [unique.ptr.create]
- unique_ptr modifiers for single objects [unique.ptr.single.modifiers]
- basic_string general requirements [string.require]