std::ranges::destroy_at
| Definido en el archivo de encabezado <memory>
|
||
| Signatura de la llamada |
||
template< std::destructible T > constexpr void destroy_at( T* p ) noexcept; |
(desde C++20) | |
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.
Parámetros
| p | - | Un puntero al objeto a destruir. |
Valor de retorno
(Ninguno)
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{};
|
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.
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);
}
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 rango de objetos. (niebloid) |
(C++20) |
Destruye un número de objetos en un rango. (niebloid) |
(C++20) |
Crea un objeto en una dirección dada (niebloid) |
(C++17) |
Destruye un objeto en una dirección dada. (plantilla de función) |