std::allocator<T>::allocate_at_least
| constexpr std::allocation_result<T*, std::size_t> allocate_at_least( std::size_t n ); |
(seit C++23) | |
Allokiert count * sizeof(T) Bytes nicht initialisierten Speichers, wobei count ein nicht spezifizierter ganzzahliger Wert ist, der nicht kleiner als n ist, indem ::operator new (möglicherweise mit einem zusätzlichen std::align_val_t Argument) aufgerufen wird, aber es ist nicht spezifiziert, wann und wie diese Funktion aufgerufen wird.
Anschließend erstellt diese Funktion ein Array vom Typ T[count] im Speicher und startet dessen Lebenszeit, aber nicht die Lebenszeit seiner Elemente.
Um diese Funktion in einem konstanten Ausdruck zu verwenden, muss der allokierte Speicher innerhalb der Auswertung desselben Ausdrucks freigegeben werden.
Die Verwendung dieser Funktion ist ill-formed, wenn T ein unvollständiger Typ ist.
Inhalt |
[edit] Parameter
| n | - | die untere Grenze der Anzahl von Objekten, für die Speicher allokiert werden soll |
[edit] Rückgabewert
std::allocation_result<T*>{p, count}, wobei p auf das erste Element eines Arrays von count Objekten vom Typ T zeigt, deren Elemente noch nicht konstruiert wurden.
[edit] Ausnahmen
Wirft std::bad_array_new_length, wenn std::numeric_limits<std::size_t>::max() / sizeof(T) < n, oder std::bad_alloc, wenn die Allokation fehlschlägt.
[edit] Hinweise
allocate_at_least wird hauptsächlich für fortlaufende Container bereitgestellt, z. B. std::vector und std::basic_string, um die Reallokation zu reduzieren, indem ihre Kapazität an die tatsächlich allokierte Größe angepasst wird, wenn möglich.
Die Formulierung "nicht spezifiziert, wann und wie" ermöglicht es, Heap-Allokationen, die von den Standardbibliothekscontainern vorgenommen werden, zu kombinieren oder wegzulassen, auch wenn solche Optimierungen für direkte Aufrufe von ::operator new nicht erlaubt sind. Beispielsweise wird dies von libc++ implementiert ([1] und [2]).
Nach dem Aufruf von allocate_at_least und vor der Konstruktion der Elemente ist die Zeigerarithmetik von T* innerhalb des allokierten Arrays gut definiert, aber das Verhalten ist undefiniert, wenn auf Elemente zugegriffen wird.
| Feature-Test-Makro | Wert | Std | Feature |
|---|---|---|---|
__cpp_lib_allocate_at_least |
202302L |
(C++23) | allocate_at_least usw. |
[edit] Beispiel
#include <memory> #include <print> int main() { const std::size_t count{69}; std::allocator<int> alloc; std::allocation_result res{alloc.allocate_at_least(count)}; std::print("count: {}\n" "res.ptr: {}\n" "res.count: {}\n", count, res.ptr, res.count); /* construct, use, then destroy elements */ alloc.deallocate(res.ptr, res.count); }
Mögliche Ausgabe
count: 69 res.ptr: 0x555a486a0960 res.count: 96
[edit] Siehe auch
| (C++23) |
speichert die Adresse und die tatsächliche Größe des von allocate_at_least allokierten Speichers(Klassen-Template) |
| [static] (C++23) |
allokiert Speicher, der mindestens so groß ist wie die angeforderte Größe über einen Allokator (public static member function of std::allocator_traits<Alloc>) |
