std::ranges::destroy
Von cppreference.com
| Definiert in Header <memory> |
||
| Aufruf-Signatur |
||
| template< no-throw-input-iterator I, no-throw-sentinel-for<I> S > requires std::destructible<std::iter_value_t<I>> |
(1) | (seit C++20) |
| template< no-throw-input-range R > requires std::destructible<ranges::range_value_t<R>> |
(2) | (seit C++20) |
1) Zerstört die Objekte im Bereich
[first, last), als ob durchfor (; first != last; ++first) std::ranges::destroy_at(std::addressof(*first)); return first;
2) Dasselbe wie (1), aber verwendet r als Quellbereich, als ob ranges::begin(r) als first und ranges::end(r) als last verwendet würden.
Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als niebloids bekannt), d.h.
- Können explizite Template-Argumentlisten bei keinem von ihnen angegeben werden.
- Keiner von ihnen ist für Argument-abhängige Suche sichtbar.
- Wenn einer von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird die Argument-abhängige Suche unterdrückt.
Inhalt |
[bearbeiten] Parameter
| first, last | - | das Iterator-Sentinel-Paar, das den Bereich der zu zerstörenden Elemente definiert |
| r | - | der Bereich, der zerstört werden soll |
[bearbeiten] Rückgabewert
Ein Iterator, der gleich last ist.
[bearbeiten] Komplexität
Linear zur Distanz zwischen first und last.
[bearbeiten] Mögliche Implementierung
struct destroy_fn { template<no-throw-input-iterator I, no-throw-sentinel-for<I> S> requires std::destructible<std::iter_value_t<I>> constexpr I operator()(I first, S last) const noexcept { for (; first != last; ++first) std::ranges::destroy_at(std::addressof(*first)); return first; } template<no-throw-input-range R> requires std::destructible<std::ranges::range_value_t<R>> constexpr std::ranges::borrowed_iterator_t<R> operator()(R&& r) const noexcept { return operator()(std::ranges::begin(r), std::ranges::end(r)); } }; inline constexpr destroy_fn destroy{}; |
[bearbeiten] Beispiel
Das folgende Beispiel zeigt, wie ranges::destroy zum Zerstören einer zusammenhängenden Sequenz von Elementen verwendet wird.
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::ranges::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++20) |
zerstört eine Anzahl von Objekten in einem Bereich (Algorithmus-Funktionsobjekt) |
| (C++20) |
zerstört ein Objekt an einer gegebenen Adresse (Algorithmus-Funktionsobjekt) |
| (C++17) |
zerstört einen Bereich von Objekten (Funktions-Template) |
