std::get_temporary_buffer
| Definiert in Header <memory> |
||
| template< class T > std::pair<T*, std::ptrdiff_t> |
(bis C++11) | |
| template< class T > std::pair<T*, std::ptrdiff_t> |
(seit C++11) (veraltet in C++17) (in C++20 entfernt) |
|
Wenn count negativ oder Null ist, tut die Funktion nichts.
Andernfalls wird versucht, nicht initialisierten zusammenhängenden Speicher für count aufeinanderfolgende Objekte des Typs T zu allokieren. Die Anforderung ist nicht bindend, und die Implementierung kann stattdessen Speicher für eine beliebige andere Anzahl von (einschließlich Null) aufeinanderfolgenden Objekten des Typs T allokieren.
|
Es ist implementierungsabhängig, ob über-ausgerichtete Typen unterstützt werden. |
(seit C++11) |
Inhalt |
[edit] Parameter
| zählt | - | die gewünschte Anzahl von Objekten |
[edit] Rückgabewert
Ein std::pair, dessen Element first ein Zeiger auf den Anfang des allokierten Speichers ist und dessen Element second die Anzahl der Objekte ist, die in den tatsächlich allokierten Speicher passen.
Wenn count <= 0 ist oder der allokierte Speicher nicht ausreicht, um ein einzelnes Element vom Typ T zu speichern, ist das Element first des Ergebnisses ein Nullzeiger und das Element second ist Null.
[edit] Hinweise
Diese API wurde ursprünglich mit der Absicht entworfen, eine effizientere Implementierung als die allgemeine operator new bereitzustellen, aber es wurde keine solche Implementierung erstellt und die API wurde als veraltet markiert und entfernt.
[edit] Beispiel
#include <algorithm> #include <iostream> #include <iterator> #include <memory> #include <string> int main() { const std::string s[] = {"string", "1", "test", "..."}; const auto p = std::get_temporary_buffer<std::string>(4); // requires that p.first is passed to return_temporary_buffer // (beware of early exit points and exceptions), or better use: std::unique_ptr<std::string, void(*)(std::string*)> on_exit(p.first, [](std::string* p) { std::cout << "returning temporary buffer...\n"; std::return_temporary_buffer(p); }); std::copy(s, s + p.second, std::raw_storage_iterator<std::string*, std::string>(p.first)); // has same effect as: std::uninitialized_copy(s, s + p.second, p.first); // requires that each string in p is individually destroyed // (beware of early exit points and exceptions) std::copy(p.first, p.first + p.second, std::ostream_iterator<std::string>{std::cout, "\n"}); std::for_each(p.first, p.first + p.second, [](std::string& e) { e.~basic_string<char>(); }); // same as: std::destroy(p.first, p.first + p.second); // manually reclaim memory if unique_ptr-like technique is not used: // std::return_temporary_buffer(p.first); }
Ausgabe
string 1 test ... returning temporary buffer...
[edit] Defect reports
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 425 | C++98 | das Verhalten, wenn count <= 0 war, war unklar | wurde klargestellt |
| LWG 2072 | C++98 | es war nicht erlaubt, unzureichenden Speicher zu allokieren | erlaubt |
[edit] Siehe auch
| (veraltet in C++17)(entfernt in C++20) |
gibt uninitialisierten Speicher frei (Funktions-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>) |
