Dynamische Speicherverwaltung
Aus cppreference.com
< cpp
[Bearbeiten] Intelligente Zeiger
Intelligente Zeiger ermöglichen automatische, ausnahmensichere Ressourcenverwaltung.
| definiert in Header
<memory> | |
Zeigerkategorien | |
| (C++11) |
intelligenter Zeiger, der exklusiven Objektbesitz abbildet (Klassen-Template) |
| (C++11) |
intelligenter Zeiger, der geteilten Objektbesitz abbildet (Klassen-Template) |
| (C++11) |
intelligenter Zeiger, der eine schwache, d.h. nicht blockierende, Referenz auf einen std::shared_ptr verwaltet (Klassen-Template) |
| (veraltet) |
Zeiger, der exklusiven Objektbesitz abbildet (Klassen-Template) |
Hilfsklassen | |
| (C++11) |
bietet eine Ordnung anhand der Eigentümer für gemischte Mengen aus shared_ptr und weak_ptr an (Klassen-Template) |
| (C++11) |
ermöglicht einem Objekt einen shared_ptr auf sich selbst zu erstellen (Klassen-Template) |
| (C++11) |
Ausnahme beim versuchten Zugriffs auf einen weak_ptr, der auf ein schon zerstörtes Objekt verweist (Klasse) |
| (C++11) |
die voreingestellte Löschfunktion für unique_ptr (Klassen-Template) |
Adaptoren für intelligente Zeiger | |
| (C++23) |
arbeitet mit externen Setzern eines Zeigers zusammen und setzt einen intelligenten Zeiger beim Zerstören zurück. (Klassen-Template) |
| (C++23) |
erzeugt einen out_ptr_t mit dem zugehörigen intelligenten Zeiger und Argumente zum Zurücksetzen (Funktions-Template) |
| (C++23) |
arbeitet mit externen Setzern von Zeigern zusammen, bekommt den initialen Zeigerwert aus einem intelligenten Zeiger und setzt ihn beim Zerstören zurück. (Klassen-Template) |
| (C++23) |
erzeugt ein inout_ptr_t mit einem zugehörigen intelligenten Zeiger und Argument zum Zurücksetzen (Funktions-Template) |
[Bearbeiten] Allokatoren
Allokatoren sind Klassen-Templates, die die Strategien der Speicherverwaltung kapseln. Dadurch sind generischen Containern in der Lage, die Speicherverwaltung und die Verwaltung der Daten selbst zu entkoppeln.
| definiert in Header
<memory> | |
| der Standardallokator (Klassen-Template) | |
| (C++11) |
liefert Informationen über Allokatoren (Klassen-Template) |
| (C++23) |
speichert die Adresse und die wirkliche Größe des durch allocate_at_least belegten Speichers (Klassen-Template) |
| (C++23) |
belegt mindestens so viel Speicher wie vom Allokator angefordert (Funktions-Template) |
| (C++11) |
Type zur Auswahl der Konstruktorüberladungen mit Allokatorunterstützung (Klasse) |
| (C++11) |
eine Konstante, um Konstruktoren, die Allokatoren unterstützen, auswählen zu können (konstanten) |
| (C++11) |
prüft, ob der angegebene Typ allokatorgestützte Erzeugung unterstützt. (Klassen-Template) |
| erzeugt die passende Argumentenliste für die Art der Allokatorkonstruktion, wie sie vom gegebenen Type benötigt wird. (Funktions-Template) | |
| (C++20) |
erzeugt ein Objekt des gegebenen Typs durch Benutzung des gegebenen Allokators (Funktions-Template) |
| erzeugt ein Objekt mit dem vorgegebenen Typ an der vorgegebenen Speicheradresse unter Benutzung des gegebenen Allokators (Funktions-Template) | |
| definiert in Header
<scoped_allocator> | |
| (C++11) |
implementiert die Zuweisung über mehrere Ebenen für Container, die in mehrfachen Ebene unterteilt sind (Klassen-Template) |
| definiert in Header
<memory_resource> | |
| definiert in Namensraum
std::pmr | |
| (C++17) |
ein Allokator, der Laufzeitpolymorphie basierend auf der Speicherresource, die zur Konstruktion benutzt worden ist, unterstützt. (Klassen-Template) |
[Bearbeiten] Speicherressourcen
Speicherressourcen implementieren Speicheranforderungsstrategien, die von std::pmr::polymorphic_allocator benutzt werden können.
| definiert in Header
<memory_resource> | |
| definiert in Namensraum
std::pmr | |
| (C++17) |
eine abstrakte Interfaceklasse, die Speicherressourcen kapselt (Klasse) |
| (C++17) |
gibt eine statische, für das ganze Program gleiche, Speicherressource (std::pmr::memory_resource) zurück, die den globalen operator new und operator delete zum Allokieren und Freigeben von Speicher verwendet. (Funktion) |
| (C++17) |
gibt eine statische Speicherressource (std::pmr::memory_resource) zurück, die keinerlei Allokation vornimmt. (Funktion) |
| (C++17) |
gibt die voreingestellten Speicherressource std::pmr::memory_resource (Funktion) |
| (C++17) |
setzen der voreingestellten Speicherressource (std::pmr::memory_resource) (Funktion) |
| (C++17) |
ein Satz an Konstruktoroptionen für Poolressourcen (Klasse) |
| (C++17) |
eine zugriffsverwaltete Speicherressource (std::pmr::memory_resource) zur Verwaltung von Allokation in Speicherpools mit verschiedenen Blockgrößen (Klasse) |
| (C++17) |
eine Speicherressource (std::pmr::memory_resource) für die Verwaltung von Allokationen in Speicherpools mit verschieden großen Speicherblöcken. (Klasse) |
| (C++17) |
eine spezielle Speicherressource (std::pmr::memory_resource), die den Speicher erst frei gibt, wenn sie zerstört wird. (Klasse) |
[Bearbeiten] Nichtinitialisierter Speicher
Es werden einige Hilfsfunktionen zur Verfügung gestellt, die das Erzeugen und den Zugriff auf nichtinitialisierten Speicher ermöglichen.
| definiert in Header
<memory> | |
| ein Iterator, der es Standardalgorithmen erlaubt, Ergebnisse in nicht initialisierten Speicher zu speichern (Klassen-Template) | |
| gibt nicht initialisierten, temporären Speicher für die angegebene Zahl von Elementen zurück (Funktions-Template) | |