WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Allocatoren und Speicherressourcen

Ein Allocator bestimmt, wie ein Container Speicher bezieht und freigibt. Mit std::pmr-Ressourcen lässt sich die Allokationsstrategie zur Laufzeit wählen, ohne den Containertyp zu ändern; dabei müssen die Lebensdauern der Objekte sorgfältig geordnet sein.

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

Syntax

using Vector = std::vector<T, Allocator>;
using AllocatorTraits = std::allocator_traits<Allocator>;
using PolymorphicAllocator = std::pmr::polymorphic_allocator<T>;
std::pmr::vector<T> values(std::pmr::polymorphic_allocator<T>{&resource});

Ein Allocator beschreibt ein Modell zur Speicherverwaltung. Bei std::vector<T, Allocator> ist sein Typ Bestandteil des Containertyps; standardmäßig wird std::allocator<T> verwendet. std::allocator_traits<Allocator> bietet eine einheitliche Schnittstelle für Allokation, Deallokation sowie das Konstruieren und Zerstören von Elementen. Speicher zu beziehen ist nicht dasselbe wie Elementkonstruktoren aufzurufen; normalerweise verwaltet der Container diese Trennung.

std::pmr::memory_resource bietet eine polymorphe Schnittstelle, die Blöcke anhand von Byteanzahl und Ausrichtung allokiert. std::pmr::polymorphic_allocator<T> übersetzt Anforderungen für T in diese Schnittstelle. std::pmr::vector<T> verwendet diesen Allocator: Zwei solche Vektoren können denselben Typ, aber unterschiedliche zur Laufzeit ausgewählte Ressourcen haben. Der Allocator übernimmt nicht das Eigentum an der Ressource.

std::pmr::monotonic_buffer_resource allokiert nacheinander Teile eines Puffers; einzelne Deallokationen geben keinen Speicher zurück. Ist der Speicher erschöpft, wird die übergeordnete Ressource verwendet. Im Beispiel bewirkt std::pmr::null_memory_resource(), dass diese Anforderung std::bad_alloc auslöst, statt zusätzlichen Speicher zu beziehen. reserve(3) vermeidet bei den folgenden drei push_back-Operationen eine Reallokation; die genaue gewählte Kapazität ist jedoch implementierungsabhängig.

Der Puffer muss länger leben als die Ressource, die ihn verwendet, und die Ressource länger als der Container. Die Deklarationsreihenfolge im Beispiel sorgt für die umgekehrte Zerstörungsreihenfolge: values, resource, buffer. Rufe release() nicht auf, solange der Container den allokierten Speicher noch benötigt; das Freigeben der Ressource ruft keine Destruktoren gespeicherter Elemente auf.

Dieser Eintrag bezieht sich auf C++23. Die angegebene URL führt zu einem fortlaufend bearbeiteten Entwurf, nicht zu einer unveränderlichen C++23-Ausgabe. Der gezeigte Code wurde unverändert in einer isolierten Umgebung ausgeführt; seine Standardausgabe stimmte exakt mit der angegebenen Ausgabe überein. Die Prüfung in der Produktionsumgebung ist davon getrennt: Weder dieser Test noch das Compiler-Flag im Repository belegen, dass das Beispiel dort funktioniert.

Beispiele

#include <array>
#include <cstddef>
#include <iostream>
#include <memory_resource>
#include <vector>

int main() {
    alignas(int) std::array<std::byte, 1024> buffer{};
    std::pmr::monotonic_buffer_resource resource{
        buffer.data(), buffer.size(), std::pmr::null_memory_resource()};
    std::pmr::vector<int> values{&resource};
    values.reserve(3);
    values.push_back(10);
    values.push_back(20);
    values.push_back(30);

    std::cout << values.size() << '\n';
    std::cout << values[0] + values[1] + values[2] << '\n';
}

Ergebnis

3
60

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