std::align
| Definiert in Header <memory> |
||
| void* align( std::size_t Ausrichtung, std::size_t Größe, |
(seit C++11) | |
Gibt einen Zeiger zurück, der durch die angegebene Ausrichtung für Größe Bytes ausgerichtet ist, basierend auf einem Zeiger ptr auf einen Puffer der Größe Platz. Der Platz-Argument wird um die für die Ausrichtung verwendeten Bytes reduziert. Die erste ausgerichtete Adresse wird zurückgegeben.
Die Funktion modifiziert den Zeiger nur, wenn es möglich ist, die gewünschte Anzahl von Bytes mit der gegebenen Ausrichtung in den Puffer einzupassen. Wenn der Puffer zu klein ist, tut die Funktion nichts und gibt nullptr zurück.
Das Verhalten ist undefiniert, wenn Ausrichtung keine Potenz von zwei ist.
Inhalt |
[edit] Parameter
| alignment | - | die gewünschte Ausrichtung |
| size | - | die Größe des auszurichtenden Speichers |
| ptr | - | Zeiger auf zusammenhängenden Speicher (einen Puffer) von mindestens Platz Bytes |
| Leerzeichen | - | die Größe des Puffers, in dem operiert werden soll |
[edit] Rückgabewert
Der angepasste Wert von ptr oder ein Nullzeigerwert, wenn der bereitgestellte Platz zu klein ist.
[edit] Beispiel
Demonstriert die Verwendung von std::align, um Objekte unterschiedlichen Typs im Speicher zu platzieren.
#include <iostream> #include <memory> #include <new> template<std::size_t N> struct MyAllocator { std::byte data[N]; std::size_t sz{N}; void* p; MyAllocator() : p(data) {} // Note: only well-defined for implicit-lifetime types template<typename T> T* implicit_aligned_alloc(std::size_t a = alignof(T)) { if (std::align(a, sizeof(T), p, sz)) { T* result = std::launder(reinterpret_cast<T*>(p)); p = static_cast<std::byte*>(p) + sizeof(T); sz -= sizeof(T); return result; } return nullptr; } }; int main() { MyAllocator<64> a; std::cout << "allocated a.data at " << (void*)a.data << " (" << sizeof a.data << " bytes)\n"; // Allocate a char if (char* p = a.implicit_aligned_alloc<char>()) { *p = 'a'; std::cout << "allocated a char at " << (void*)p << '\n'; } // Allocate an int if (int* p = a.implicit_aligned_alloc<int>()) { *p = 1; std::cout << "allocated an int at " << (void*)p << '\n'; } // Allocate an int, aligned at a 32-byte boundary if (int* p = a.implicit_aligned_alloc<int>(32)) { *p = 2; std::cout << "allocated an int at " << (void*)p << " (32-byte alignment)\n"; } }
Mögliche Ausgabe
allocated a.data at 0x7ffc654e8530 (64 bytes) allocated a char at 0x7ffc654e8530 allocated an int at 0x7ffc654e8534 allocated an int at 0x7ffc654e8540 (32-byte alignment)
[edit] Fehlerberichte
Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | angewendet auf | Verhalten wie veröffentlicht | Korrigiertes Verhalten |
|---|---|---|---|
| LWG 2377 | C++11 | Ausrichtung musste ein fundamentaler oder unterstützter erweiterter Ausrichtungswert sein |
muss nur eine Potenz von zwei sein |
[edit] Siehe auch
alignof (C++11) |
fragt nach Ausrichtungsanforderungen eines Typs (Operator) |
alignas (C++11) |
gibt an, dass der Speicher für die Variable um einen bestimmten Betrag ausgerichtet werden soll (Spezifizierer) |
| (seit C++11)(veraltet in C++23) |
definiert den Typ, der als uninitialisierter Speicher für Typen gegebener Größe geeignet ist (Klassenvorlage) |
| (C++20) |
informiert den Compiler, dass ein Zeiger ausgerichtet ist (Funktions-Template) |
