Namespaces
Variants

std:: destroy_at

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
Défini dans l'en-tête <memory>
template < class T >
void destroy_at ( T * p ) ;
(depuis C++17)
(constexpr depuis C++20)

Si T n'est pas un type tableau, appelle le destructeur de l'objet pointé par p , comme par p - > ~T ( ) .

Si T est un type tableau, le programme est mal formé (jusqu'en C++20) détruit récursivement les éléments de * p dans l'ordre, comme en appelant std:: destroy ( std:: begin ( * p ) , std:: end ( * p ) ) (depuis C++20) .

Table des matières

Paramètres

p - un pointeur vers l'objet à détruire

Implémentation possible 

template<class T>
constexpr void destroy_at(T* p) 
{
    if constexpr (std::is_array_v<T>)
        for (auto& elem : *p)
            (destroy_at)(std::addressof(elem));
    else
        p->~T(); 
}
// Version C++17 :
// template<class T> void destroy_at(T* p) { p->~T(); }

Notes

destroy_at déduit le type de l'objet à détruire et évite ainsi de l'écrire explicitement dans l'appel du destructeur.

Lorsque destroy_at est appelé dans l'évaluation d'une expression constante e , l'argument p doit pointer vers un objet dont la durée de vie a commencé durant l'évaluation de e .

(depuis C++20)

Exemple

L'exemple suivant démontre comment utiliser destroy_at pour détruire une séquence contiguë d'éléments.

Exécuter ce code 
#include <iostream>
#include <memory>
#include <new>
struct Tracer
{
    int value;
    ~Tracer() { std::cout << value << " destructed\n"; }
};
int main()
{
    alignas(Tracer) unsigned char buffer[sizeof(Tracer) * 8];
    for (int i = 0; i != 8; ++i)
        new(buffer + sizeof(Tracer) * i) Tracer{i}; // manually construct objects
    auto ptr = std::launder(reinterpret_cast<Tracer*>(buffer));
    for (int i = 0; i != 8; ++i)
        std::destroy_at(ptr + i);
}

Sortie : 

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

Voir aussi

(C++17)
détruit une plage d'objets
(modèle de fonction)
(C++17)
détruit un nombre d'objets dans une plage
(modèle de fonction)
(C++20)
crée un objet à une adresse donnée
(modèle de fonction)
(C++20)
détruit un objet à une adresse donnée
(objet fonction algorithme)