std::ranges::destroy - cppreference.com

De cppreference.com

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.

#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: