KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

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