Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Stos a sterta: automatyczny czas trwania pamięci i alokacja dynamiczna

C++23 określa czas trwania pamięci i reguły życia obiektów, a nie ich fizyczne położenie. Lokalny obiekt może zawierać `std::string`, który dynamicznie przydziela pamięć na znaki.

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

Składnia

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

„Stos a sterta” to skrót odnoszący się do typowej implementacji, a nie do gwarantowanego przez C++23 rozmieszczenia obiektów. Czas trwania pamięci określa minimalny potencjalny okres dostępności pamięci obiektu; nie jest tym samym co czas życia obiektu. Zwykła zmienna zadeklarowana w bloku bez static, thread_local ani extern ma automatyczny czas trwania pamięci. Jeśli jej obiekt został skonstruowany, zostaje zniszczony przy opuszczaniu bloku, także podczas rozwijania stosu wskutek wyjątku.

std::make_unique<Record>() tworzy odrębny obiekt Record o dynamicznym czasie trwania pamięci. Lokalny owner może sam mieć automatyczny czas trwania pamięci, a zarządzany obiekt może przeżyć blok, w którym powstał. Po zniszczeniu owner domyślny deleter niszczy nadal posiadany obiekt i zwalnia jego pamięć. To przykład RAII: zasobem zarządza obiekt właściciela. Nie zwracaj wskaźnika ani referencji do lokalnego obiektu, który zostanie zniszczony przy powrocie z funkcji.

Pole text jest podobiektem std::string o takim samym czasie trwania pamięci jak zawierający je Record. Pamięć na znaki to osobna kwestia: napis w razie potrzeby korzysta z alokatora. Implementacja może przechowywać krótkie napisy wewnątrz obiektu napisu (SSO), ale C++23 nie wymaga tej optymalizacji ani nie podaje jej progu. Automatyczny czas trwania pamięci Record nie oznacza więc braku dynamicznych alokacji.

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 = "hello";
        std::cout << "local: " << local.text.size() << '\n';
    }
    std::cout << "owned: " << owner->text.size() << '\n';
}

Wynik

local: 3
owned: 5

`local` zostaje zniszczony przy wyjściu z wewnętrznego bloku. Drugi wiersz nadal można wypisać, ponieważ `owner` posiada drugi `Record` aż do końca `main`. Wynik nie wskazuje rozmieszczenia pamięci ani liczby alokacji.

Powiązane lekcje

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

Źródła