std::ranges::destroy_n

Destruye los n objetos en el rango que comienza en first, equivalente a

return std::ranges::destroy(std::counted_iterator(first, n), std::default_sentinel).base();

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.

[editar] Parámetros

[editar] Valor de retorno

El final del rango de objetos que se ha destruido.

[editar] Complejidad

Lineal en n.

[editar] Posible implementación

struct destroy_n_fn {
  template<no-throw-input-iterator I>
    requires std::destructible<std::iter_value_t<I>>
  constexpr I operator()(I first, std::iter_difference_t<I> n) const noexcept
  {
    for (; n != 0; (void)++first, --n)
      std::ranges::destroy_at(std::addressof(*first));
    return first;
  }
};
 
inline constexpr destroy_n_fn destroy_n{};

[editar] Ejemplo

El siguiente ejemplo demuestra cómo usar ranges::destroy_n para destruir una secuencia contigua de elementos.

#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_n(ptr, 8);
}

0 destruido
1 destruido
2 destruido
3 destruido
4 destruido
5 destruido
6 destruido
7 destruido

[editar] Véase también