WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Speicher: Besitz, Kopien und Objektlebensdauer

Unterscheide Speicherplatz, das darin lebende Objekt und die Verantwortung für eine Ressource. Lerne automatische und dynamische Speicherdauer, Kopiersemantik, Placement-new, explizite Zerstörung und die Grenzen von Strict Aliasing kennen.

Version: C++23; repository compiler flag, production runtime not attested

Syntax

T copy = original; T* alias = &original; T* p = ::new (static_cast<void*>(storage)) T{args}; p->~T();

Speicher bietet Platz für Daten; die Lebensdauer betrifft das Objekt darin. Sie beginnt meist, sobald ausreichend großer, passend ausgerichteter Speicher bereitsteht und die Initialisierung abgeschlossen ist. Bei Klassenobjekten endet sie mit Beginn des Destruktoraufrufs. Auch Freigabe oder Wiederverwendung des Speichers kann sie beenden. Eine gültige Adresse allein erlaubt keinen Objektzugriff.

Speicherdauer bestimmt, wie lange Speicher verfügbar ist. Normale lokale Variablen haben automatische Speicherdauer bis zum Blockende. Mit allokierendem new erzeugte Objekte haben dynamische Speicherdauer und können den Block überdauern. Ein lokaler std::unique_ptr kann automatische, sein Objekt dynamische Speicherdauer haben. „Stack“ und „Heap“ sind typische Implementierungsmodelle, keine Definitionen.

Besitz heißt, für die Freigabe zuständig zu sein. Nutze RAII: Der Destruktor des Besitzers räumt auf. std::unique_ptr ist verschiebbar, nicht kopierbar. Kopieren eines rohen Zeigers kopiert nur die Adresse, weder Objekt noch Löschverantwortung. Standardmäßig werden Klassenmember kopiert; ein Zeigermember zeigt weiter auf dasselbe Objekt. Kopien sind nicht zwingend tief; zwei unabhängige Besitzer derselben Adresse riskieren doppeltes Löschen.

Placement-new. In ::new (storage) T{args} beschränkt das führende :: die Suche nach der Allokationsfunktion auf den globalen Gültigkeitsbereich, erzwingt aber nicht die Wahl der Standardüberladung mit void*. Eine globale Überladung, die besser zum Typ von storage passt, kann Speicher allokieren. Das Beispiel verwendet die Form ::new (static_cast<void*>(storage)) T{args} mit Item. Dabei wird die nicht allokierende Standardüberladung ausgewählt und das Objekt im bereitgestellten Speicher konstruiert. Die Umwandlung in void* allein garantiert diese Auswahl nicht für jedes T. Hat T eine größere Ausrichtungsanforderung als die Standardausrichtung für new (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__), wird beim ersten Durchlauf der Überladungsauflösung vor dem Placement-Argument ein Argument vom Typ std::align_val_t berücksichtigt. Eine passende globale Überladung operator new(std::size_t, std::align_val_t, void*) kann dann anstelle der nicht allokierenden Standardüberladung ausgewählt werden. Der Speicher muss ausreichend groß und passend ausgerichtet sein. p->~T() zerstört das Objekt explizit, gibt aber keinen Speicher frei. Kein delete für Objekte in lokalen Puffern. Zerstöre nichts zweimal: Nach expliziter Zerstörung einer normalen lokalen Variablen mit nichttrivialem Destruktor muss vor der automatischen Zerstörung korrekt ein Objekt des ursprünglichen Typs entstehen.

Strict Aliasing beschränkt die Typen zum Lesen oder Ändern eines Objektwerts. reinterpret_cast erlaubt keinen Zugriff über inkompatible Typen. char, unsigned char und std::byte erlauben Zugriff auf die Repräsentation, ersetzen aber keine Lebensdauerregeln. Das Beispiel nutzt eine C++23-kompatible Teilmenge; die Standard-URL führt zum laufenden Entwurf, nicht zur festen C++23-Ausgabe.

In diesem Eintrag behandelte Referenzbezeichner: Object lifetime, placement new, explicit destruction and strict aliasing, Automatic and dynamic storage duration.

Beispiele

#include <cstddef>
#include <iostream>
#include <memory>
#include <new>

struct Item {
    int value;
    ~Item() {}
};

int main() {
    Item original{7};
    Item copy = original;
    Item* alias = &original;
    alias->value = 9;

    auto owner = std::make_unique<Item>();
    owner->value = 11;

    alignas(Item) std::byte storage[sizeof(Item)];
    Item* placed = ::new (static_cast<void*>(storage)) Item{13};

    std::cout << original.value << ' ' << copy.value << ' '
              << owner->value << ' ' << placed->value << '\n';

    placed->~Item();
}

Ergebnis

9 7 11 13

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen