std::destroy
Von cppreference.com
| Definiert in Header <memory> |
||
| (1) | ||
template< class ForwardIt > void destroy( ForwardIt first, ForwardIt last ); |
(seit C++17) (bis C++20) |
|
| template< class ForwardIt > constexpr void destroy( ForwardIt first, ForwardIt last ); |
(seit C++20) | |
| template< class ExecutionPolicy, class ForwardIt > void destroy( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last ); |
(2) | (seit C++17) |
1) Zerstört die Objekte im Bereich
[first, last), als ob durchfor (; first != last; ++first) std::destroy_at(std::addressof(*first));
2) Gleiche Funktionalität wie (1), aber ausgeführt gemäß policy. Diese Überladung nimmt an der Überladungsauflösung nur teil, wenn alle folgenden Bedingungen erfüllt sind
|
std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> ist true. |
(bis C++20) |
|
std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> ist true. |
(seit C++20) |
Inhalt |
[bearbeiten] Parameter
| first, last | - | das Iterator-Paar, das den Bereich der zu zerstörenden Elemente definiert |
| policy | - | die Ausführungsrichtlinie, die verwendet werden soll |
| Typanforderungen | ||
-ForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen. | ||
-Kein Inkrementieren, Zuweisen, Vergleichen oder Dereferenzieren von gültigen Instanzen von ForwardIt darf Ausnahmen auslösen. | ||
[bearbeiten] Rückgabewert
(keine)
[bearbeiten] Komplexität
Linear zur Distanz zwischen first und last.
[bearbeiten] Ausnahmen
Die Überladung mit einem Template-Parameter namens ExecutionPolicy meldet Fehler wie folgt
- Wenn die Ausführung einer Funktion, die als Teil des Algorithmus aufgerufen wird, eine Ausnahme auslöst und
ExecutionPolicyeine der Standardrichtlinien ist, wird std::terminate aufgerufen. Für jede andereExecutionPolicyist das Verhalten implementierungsabhängig. - Wenn dem Algorithmus der Speicher zur Neuzuweisung fehlt, wird std::bad_alloc ausgelöst.
[bearbeiten] Mögliche Implementierung
template<class ForwardIt> constexpr // since C++20 void destroy(ForwardIt first, ForwardIt last) { for (; first != last; ++first) std::destroy_at(std::addressof(*first)); } |
[bearbeiten] Beispiel
Das folgende Beispiel zeigt, wie destroy verwendet wird, um eine zusammenhängende Sequenz von Elementen zu zerstören.
Führen Sie diesen Code aus
#include <iostream> #include <memory> #include <new> struct Tracer { int value; ~Tracer() { std::cout << value << " destructed\n"; } }; int main() { alignas(Tracer) unsigned char buffer[sizeof(Tracer) * 8]; for (int i = 0; i < 8; ++i) new(buffer + sizeof(Tracer) * i) Tracer{i}; //manually construct objects auto ptr = std::launder(reinterpret_cast<Tracer*>(buffer)); std::destroy(ptr, ptr + 8); }
Ausgabe
0 destructed 1 destructed 2 destructed 3 destructed 4 destructed 5 destructed 6 destructed 7 destructed
[bearbeiten] Siehe auch
| (C++17) |
zerstört eine Anzahl von Objekten in einem Bereich (Funktions-Template) |
| (C++17) |
zerstört ein Objekt an einer gegebenen Adresse (Funktions-Template) |
| (C++20) |
zerstört einen Bereich von Objekten (Algorithmus-Funktionsobjekt) |
