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) | |
gibt den nicht initialisierten, temporären Speicher (get_temporary_buffer) frei (Funktions-Template) | |
[Bearbeiten] Algorithmen auf nichtinitialisiertem Speicher
| definiert in Header
<memory> | |
| kopiert eine Folge von Objekten in einen nicht initialisierten Bereich des Speichers (Funktions-Template) | |
| (C++11) |
kopiert eine Folge von n Objekten in einen nicht initialisierten Bereich des Speichers (Funktions-Template) |
| füllt den nicht initialisierten Speicher mit Kopien eines Objektes (Funktions-Template) | |
| füllt den nicht initialisierten Speicher mit n Kopien eines Objektes (Funktions-Template) | |
| (C++17) |
verschiebt eine Folge von Objekten in nicht initialisierten Speicher (Funktions-Template) |
| (C++17) |
verschiebt eine Folge von n Objekten in nicht initialisierten Speicher (Funktions-Template) |
| erzeugt eine Folge von Objekten durch default-initialization in nicht initialisierten Speicherbereich (Funktions-Template) | |
| erzeugt eine Folge von n Objekten durch default-initialization in nicht initialisierten Speicher mit gegebener Adresse (Funktions-Template) | |
| erzeugt eine Folge von Objekten durch value-initialization in nicht initialisierten Speicherbereich (Funktions-Template) | |
| erzeugt eine Anzahl n von Objekten durch value-initialization in nicht initialisierten Speicher mit gegebener Adresse (Funktions-Template) | |
| (C++17) |
zerstört ein Objekt an der gegebenen Adresse (Funktions-Template) |
| (C++17) |
zerstört eine Folge von Objekten (Funktions-Template) |
| (C++17) |
zerstört eine Folge von n Objekten (Funktions-Template) |
| (C++20) |
erzeugt ein Objekt an der angegebenen Adresse (Funktions-Template) |
[Bearbeiten] Bedingte Algorithmen auf nichtinitialisiertem Speicher (C++20)
C++20 bietet bedingte Algorithmen auf nicht-initialisiertem Speicher, die Bereiche oder Iterator-Sentinel Paare als Argumente akzeptieren.
| definiert in Header
<memory> | |
| definiert in Namensraum
std::ranges | |
| spezifiziert, daß einige Operationen für Iteratoren, Sentinels and Folgen keine Ausnahmen werfen. (exposition-only concept) | |
| (C++20) |
kopiert eine Folge von Objekten in nicht initialisierten Speicher (niebloid) |
| (C++20) |
kopiert eine Folge von n Objekten in nicht initialisierten Speicher (niebloid) |
| (C++20) |
füllt einen nicht initialisierten Speicherbereich durch Kopien eines Objektes auf (niebloid) |
| (C++20) |
füllt nicht initialisierten Speicher durch eine Folge von n Kopien eines Objektes (niebloid) |
| (C++20) |
verschiebt eine Folge von Objektren in nicht initialisierten Speicher (niebloid) |
| (C++20) |
verschiebt eine Folge n Objekten in nicht initialisierten Speicher (niebloid) |
| erzeugt eine Folge von Objekten durch default-initialization in nicht initialisierten Speicherbereich (niebloid) | |
| erzeugt eine Folge von n Objekten durch default-initialization in nicht initialisierten Speicher mit gegebener Adresse (niebloid) | |
| erzeugt eine Folge von Objekten durch value-initialization in nicht initialisierten Speicherbereich (niebloid) | |
| erzeugt eine Folge von n Objekten durch value-initialization in nicht initialisierten Speicher mit gegebener Adresse (niebloid) | |
| (C++20) |
zerstört ein Objekt an der angegebenen Adresse (niebloid) |
| (C++20) |
zerstört eine Folge von Objekten (niebloid) |
| (C++20) |
zerstört eine Folge von n Objekten (niebloid) |
| (C++20) |
erzeugt ein Objekt an der angegebenen Adresse (niebloid) |
[Bearbeiten] Unterstützung für Garbage Collectors
| definiert in Header
<memory> | |
| (C++11) |
erklärt, daß ein Objekt nicht recycelt werden kann (Funktion) |
| (C++11) |
gibt an, dass ein Objekt wiederverwertet werden kann (Funktions-Template) |
| (C++11) |
gibt an, daß ein Speicherbereich keine rückführbaren Zeigern enthält (Funktion) |
| (C++11) |
hebt die Wirkung von std::declare_no_pointers auf (Funktion) |
| (C++11) |
listet die Sicherheitsmodelle von Zeigern auf (Klasse) |
| (C++11) |
liefert den Zeiger auf das aktuelle Sicherheitsmodell (Funktion) |
[Bearbeiten] Verschiedenes
| definiert in Header
<memory> | |
| (C++11) |
liefert Informationen über zeigerähnliche Typen (Klassen-Template) |
| (C++20) |
erzeugt einen nativen Zeiger aus einem Type, der sich wie ein Zeiger verhält (Funktions-Template) |
| (C++11) |
ermittelt die tatsächlichen Adresse eines Objekts, selbst wenn der Dereferenzierungsoperator überladen ist (Funktions-Template) |
| (C++11) |
richtet einen Zeiger in einem Puffer aus (Funktion) |
| (C++20) |
zeigt dem Kompiler an, daß ein Zeiger ausgerichtet ist. (Funktions-Template) |
[Bearbeiten] Low level memory management
Enthält beispielsweise operator new, operator delete, std::set_new_handler
[Bearbeiten] Speicherverwaltung im C-Stil
Enthält beispielsweise std::malloc, std::free
[Bearbeiten] Maschinennahe Speicherverwaltung
Enthält beispielsweise operator new , operator delete , std::set_new_handler
