Namespaces
Variants

std:: default_delete

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 > struct default_delete ;
(1) (depuis C++11)
template < class T > struct default_delete < T [ ] > ;
(2) (depuis C++11)

std::default_delete est la politique de destruction par défaut utilisée par std::unique_ptr lorsqu'aucun suppresseur n'est spécifié. Les spécialisations de default_delete sont des classes vides dans les implémentations typiques, et sont utilisées dans l' optimisation de classe de base vide .

1) Le default_delete non spécialisé utilise delete pour désallouer la mémoire d'un objet unique.
2) Une spécialisation partielle pour les types de tableau qui utilise delete [ ] est également fournie.

Table des matières

Fonctions membres

(constructor)
construit un objet default_delete
(fonction membre publique)
operator()
supprime l'objet ou le tableau
(fonction membre publique)

std::default_delete:: default_delete

constexpr default_delete ( ) noexcept = default ;
(1)
Spécialisations du modèle principal
template < class U >
default_delete ( const default_delete < U > & d ) noexcept ;
(2) (depuis C++11)
(constexpr depuis C++23)
Spécialisations de tableau
template < class U >
default_delete ( const default_delete < U [ ] > & d ) noexcept ;
(3) (depuis C++11)
(constexpr depuis C++23)
1) Construit un objet std::default_delete .
2) Construit un objet std::default_delete<T> à partir d'un autre objet std::default_delete .
Cette surcharge participe à la résolution de surcharge uniquement si U* est implicitement convertible en T* .
3) Construit un objet std::default_delete<T[]> à partir d'un autre objet std::default_delete<U[]> .
Cette surcharge participe à la résolution de surcharge uniquement si U(*)[] est implicitement convertible en T(*)[] .

Paramètres

d - un suppresseur à copier

Notes

Le constructeur de conversion template de std::default_delete permet la conversion implicite de std:: unique_ptr < Derived > vers std:: unique_ptr < Base > .

std::default_delete:: operator()

Spécialisations du modèle primaire
void operator ( ) ( T * ptr ) const ;
(1) (depuis C++11)
(constexpr depuis C++23)
Spécialisations de tableau
template < class U >
void operator ( ) ( U * ptr ) const ;
(2) (depuis C++11)
(constexpr depuis C++23)
1) Appelle delete sur ptr .
2) Appelle delete [ ] sur ptr .
Cette surcharge participe à la résolution de surcharge seulement si U(*)[] est implicitement convertible en T(*)[] .
Si U est un type incomplet, le programme est mal formé.

Paramètres

ptr - un objet ou tableau à supprimer

Exceptions

Aucune garantie d'exception.

Invocation sur des Types Incomplets

Au moment dans le code où l' operator ( ) est appelé, le type doit être complet. Dans certaines implémentations, un static_assert est utilisé pour s'assurer que c'est le cas. La raison de cette exigence est que l'appel de delete sur un type incomplet est un comportement indéfini en C++ si le type de classe complet a un destructeur non trivial ou une fonction de désallocation, car le compilateur n'a aucun moyen de savoir si de telles fonctions existent et doivent être invoquées.

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_constexpr_memory 202202L (C++23) constexpr constructeur et operator ( )

Exemple

Exécuter ce code 
#include <algorithm>
#include <memory>
#include <vector>
int main()
{
//  {
//      std::shared_ptr<int> shared_bad(new int[10]);
//  } // le destructeur appelle delete, comportement indéfini
    {
        std::shared_ptr<int> shared_good(new int[10], std::default_delete<int[]>());
    } // OK : le destructeur appelle delete[]
    {
        std::unique_ptr<int> ptr(new int(5));
    } // unique_ptr<int> utilise default_delete<int>
    {
        std::unique_ptr<int[]> ptr(new int[10]);
    } // unique_ptr<int[]> utilise default_delete<int[]>
    // default_delete peut être utilisé partout où un foncteur delete est nécessaire
    std::vector<int*> v;
    for (int n = 0; n < 100; ++n)
        v.push_back(new int(n));
    std::for_each(v.begin(), v.end(), std::default_delete<int>());
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 2118 C++11 les fonctions membres des spécialisations de tableau rejetaient les conversions de qualification acceptent

Voir aussi

(C++11)
pointeur intelligent avec sémantique de propriété exclusive d'objet
(modèle de classe)