std::destroy_n - cppreference.com

De cppreference.com

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

Definido en el archivo de encabezado `<memory>`
	(1)
`template< class ForwardIt, class Size > ForwardIt destroy_n( ForwardIt first, Size n );`			(desde C++17) (hasta C++20)
`template< class ForwardIt, class Size > constexpr ForwardIt destroy_n( ForwardIt first, Size n );`			(desde C++20)
`template< class ExecutionPolicy, class ForwardIt, class Size > ForwardIt destroy_n( ExecutionPolicy&& policy, ForwardIt first, Size n );`		(2)	(desde C++17)

1) Destruye los n objetos en el rango que empieza en first, como si fuera por

for (; n > 0; (void) ++first, --n)
  std::destroy_at(std::addressof(*first));

2) Lo mismo que (1), pero ejecutado de acuerdo a policy. Esta sobrecarga no participa en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.

Parámetros

first	-	El comienzo del rango de elementos a destruir.
n	-	El número de elementos a destruir.
policy	-	La política de ejecución a usar. Véase política de ejecución para más detalles.
Requisitos de tipo
-`ForwardIt` debe satisfacer los requisitos de ForwardIterator.
-Ni el incremento, la asignación, la comparación o la indirección a través de instancias válidas de `ForwardIt` pueden lanzar excepciones.

Valor de retorno

El fin del rango de objetos que se han destruido (es decir, std::next(first, n)).

Complejidad

Lineal en n.

Excepciones

La sobrecarga con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reporta errores tales que:

Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

Posible implementación

template<class ForwardIt, class Size>
constexpr // since C++20
ForwardIt destroy_n( ForwardIt first, Size n )
{
  for (; n > 0; (void) ++first, --n)
    std::destroy_at(std::addressof(*first));
  return first;
}

Ejemplo

El siguiente ejemplo demuestra cómo usar 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::destroy_n(ptr, 8);
}

Salida:

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