std::ranges::destroy
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <memory>
|
||
| Signatura de la llamada |
||
template< no-throw-input-iterator I, no-throw-sentinel-for<I> S > requires std::destructible<std::iter_value_t<I>> constexpr I destroy( I first, S last ) noexcept; |
(1) | (desde C++20) |
template< no-throw-input-range R > requires std::destructible<ranges::range_value_t<R>> constexpr ranges::borrowed_iterator_t<R> destroy( R&& r ) noexcept; |
(2) | (desde C++20) |
1) Destruye los objetos en el rango
[first, last), como si fuera
for (; first != last; ++first)
std::ranges::destroy_at(std::addressof(*first));
return first;
2) Igual que (1), pero usa
r como el rango de origen, como si usara ranges::begin(r) como first y ranges::end(r) como last.Las entidades similares a funciones descritas en esta página son niebloids, es decir:
- Las listas de argumentos de plantilla explícitas no se pueden especificar al llamar a cualquiera de ellas.
- Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
- Cuando alguna de ellas se encuentra mediante la búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, se inhibe la búsqueda dependiente de argumentos.
En la práctica, pueden implementarse como objetos función o con extensiones de compilador especiales.
Parámetros
| first, last | - | Par iterador-centinela que denota el rango de elementos a destruir. |
| r | - | El rango a destruir |
Valor de retorno
Un iterador que se compara igual a last.
Complejidad
Lineal en la distancia entre first y last.
Posible implementación
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{};
|
Ejemplo
El siguiente ejemplo demuestra cómo usar ranges::destroy para destruir una secuencia contigua de elementos.
Ejecuta este código
#include <memory>
#include <new>
#include <iostream>
struct Trazador {
int value;
~Trazador() { std::cout << value << " destruido\n"; }
};
int main()
{
alignas(Trazador) unsigned char buffer[sizeof(Trazador) * 8];
for (int i = 0; i < 8; ++i)
new(buffer + sizeof(Trazador) * i) Trazador{i}; // construir objetos manualmente
auto ptr = std::launder(reinterpret_cast<Trazador*>(buffer));
std::ranges::destroy(ptr, ptr + 8);
}
Salida:
0 destruido
1 destruido
2 destruido
3 destruido
4 destruido
5 destruido
6 destruido
7 destruido
Véase también
(C++20) |
Destruye un número de objetos en un rango. (niebloid) |
(C++20) |
Destruye un objeto en una dirección dada. (niebloid) |
(C++17) |
Destruye un rango de objetos. (plantilla de función) |