Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Automatyczny czas trwania pamięci a alokacja dynamiczna

Odróżnij czas trwania pamięci obiektu od czasu życia samego obiektu i od dodatkowych alokacji, które może wykonywać jego składowa `std::string`.

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

Składnia

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.

W C++23 czas trwania pamięci określa, jak długo pamięć obiektu może pozostawać dostępna, a czas życia mówi, kiedy sam obiekt istnieje. Zwykła zmienna zadeklarowana w bloku, bez static, thread_local ani extern, ma automatyczny czas trwania pamięci. Przy wyjściu z bloku, także podczas odwijania stosu po wyjątku, skonstruowany obiekt klasowy jest niszczony. To reguła języka, nie wymóg umieszczenia obiektu na fizycznym stosie.

std::make_unique<Record>() tworzy Record za pomocą wyrażenia new i zwraca std::unique_ptr<Record>, który jest jego wyłącznym właścicielem. W przykładzie owner sam ma automatyczny czas trwania pamięci, natomiast obiekt Record, którym zarządza, ma dynamiczny czas trwania pamięci i przetrwa wyjście z wewnętrznego bloku. Wywołanie owner.reset() niszczy ten obiekt i zwalnia jego pamięć; pusty owner nadal istnieje. Nie używaj wskaźnika ani referencji do zniszczonego obiektu, aby uzyskać do niego dostęp.

Składowa Record::text ma taki sam czas trwania pamięci jak zawierający ją Record. Pamięć na znaki to osobna sprawa: std::string może w razie potrzeby przydzielić ją za pomocą alokatora. Optymalizacja krótkich napisów (SSO) może pozwalać na zapis znaków wewnątrz obiektu, ale C++23 nie wymaga ani stosowania SSO, ani określonego progu długości.

„Stos a sterta” to potoczny skrót, nie gwarancja fizycznego rozmieszczenia. Wybieraj bezpośredni obiekt lokalny, gdy jego czas życia naturalnie kończy się wraz z blokiem, i std::unique_ptr, gdy osobny, dynamicznie utworzony obiekt wymaga wyłącznego właściciela.

Przykłady

#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';
}

Wynik

3 1000
1000
empty

Przy udanej alokacji i poprawnym wyjściu program wypisuje długości obu napisów, ponownie długość napisu w obiekcie zarządzanym po wyjściu z bloku, a po `reset()` napis `empty`. Wynik nie wskazuje adresów ani liczby alokacji.

Powiązane lekcje

  • C++ · Lekcja 22 · Zaawansowany · Wersja: 3

Źródła