std::ranges::destroy_at

Si T no es un tipo array, llama al destructor del objeto al que apunta p, como si fuera por p->~T(). De lo contrario, destruye recursivamente los elementos de *p en orden, como si se llamara a std::destroy(std::begin(*p), std::end(*p)).

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

(Ninguno)

[editar] Posible implementación

struct destroy_at_fn {
  template<std::destructible T>
  constexpr void operator()(T *p) const noexcept
  {
    if constexpr (std::is_array_v<T>)
      for (auto &elem : *p)
        operator()(std::addressof(elem));
    else
      p->~T();
  }
};
 
inline constexpr destroy_at_fn destroy_at{};

[editar] Notas

destroy_at deduce el tipo de objeto que se va a destruir y, por lo tanto, evita escribirlo explícitamente en la llamada al destructor.

Cuando se llama a destroy_at en la evaluación de alguna expresión constante e, el argumento p debe apuntar a un objeto cuyo tiempo de vida comenzó dentro de la evaluación de e.

[editar] Ejemplo

El siguiente ejemplo demuestra cómo usar ranges::destroy_at 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));
 
    for (int i = 0; i < 8; ++i)
        std::ranges::destroy_at(ptr + i);
}

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

[editar] Véase también