Nous continuons la série "C ++, creuser en profondeur." Le but de cette série est d'en dire le plus possible sur les différentes caractéristiques du langage, peut-être assez particulières. Cet article concerne la surcharge des opérateurs new/delete. Il s'agit du troisième article de la série, le premier dédié aux fonctions et modèles de surcharge, situé ici , le deuxième dédié aux opérateurs de surcharge, situé ici . Cet article conclut une série de trois articles sur la surcharge en C ++.

Table des matières

Table des matières

  1. new/delete
    1.1.
    1.2.
    1.3.
  2. new/delete
    2.1.
    2.2.
      2.2.1. new/delete
      2.2.2. new/delete
      2.2.3.
      2.2.4.
      2.2.5. operator delete()
  3. new/delete
  4.
  5. -

1. Formes standard des opérateurs nouveaux / supprimés

C ++ prend en charge plusieurs options d'opérateur new/delete. Ils peuvent être divisés en standard de base, standard supplémentaire et personnalisé. Cette section et la section 2 traitent des formulaires standard; les formulaires personnalisés seront abordés dans la section 3.

1.1. Formulaires standard de base

Les principales formes standard d'opérateurs new/deleteutilisées pour créer et supprimer un objet et un tableau du type sont Tles suivantes:

new T(/*   */)
new T[/*   */]
delete ptr;
delete[] ptr;

Leur travail peut être décrit comme suit. Lorsque l'opérateur est appelé new, la mémoire est d'abord allouée à l'objet. Si la sélection réussit, le constructeur est appelé. Si le constructeur lève une exception, la mémoire allouée est libérée. Lorsque l'opérateur est appelé, deletetout se passe dans l'ordre inverse: d'abord, le destructeur est appelé, puis la mémoire est libérée. Le destructeur ne doit pas lever d'exceptions.

Lorsque l'opérateurnew[]utilisée pour créer un tableau d'objets, la mémoire est d'abord allouée à l'ensemble du tableau. Si la sélection réussit, le constructeur par défaut (ou un autre constructeur, s'il y a un initialiseur) est appelé pour chaque élément du tableau à partir de zéro. Si un constructeur lève une exception, alors pour tous les éléments créés du tableau, le destructeur est appelé dans l'ordre inverse de l'appel du constructeur, la mémoire allouée est libérée. Pour supprimer un tableau, vous devez appeler l'opérateur delete[]et pour tous les éléments du tableau, le destructeur est appelé dans l'ordre inverse du constructeur, puis la mémoire allouée est libérée.

Attention! Il est nécessaire d'appeler la bonne forme de l'opérateurdeleteselon si un seul objet ou un tableau est supprimé. Cette règle doit être strictement respectée, sinon vous pouvez obtenir un comportement indéfini, c'est-à-dire que tout peut arriver: fuites de mémoire, crash, etc. Voir [Meyers1] pour plus de détails.

Dans la description ci-dessus, une clarification est nécessaire. Pour les soi-disant types triviaux (types intégrés, structures de style C), le constructeur par défaut ne peut pas être appelé et le destructeur ne fait en aucun cas quoi que ce soit.

Les fonctions d'allocation de mémoire standard, lorsqu'il n'est pas possible de satisfaire la demande, lèvent une exception de type std::bad_alloc. Mais cette exception peut être interceptée, pour cela, vous devez installer un intercepteur global à l'aide d'un appel de fonction set_new_handler(), pour plus de détails, voir [Meyers1].

Toute forme d'opérateurdeleteappliquer en toute sécurité au pointeur nul.

Lors de la création d'un tableau avec un opérateur, la new[]taille peut être définie sur zéro.

Les deux formes de l'opérateur newpermettent d'utiliser des initialiseurs dans les accolades.

new int{42}
new int[8]{1,2,3,4}

1.2. Formulaires standard supplémentaires

Lors de la connexion du fichier d'en-tête <new>, 4 formulaires d'opérateur standard supplémentaires sont disponibles new:

new(ptr) T(/*  */);
new(ptr) T[/*   */];
new(std::nothrow) T(/*   */);
new(std::nothrow) T[/*   */];

Les deux premiers d'entre eux sont appelés newplacement sans allocation new. Un argument ptrest un pointeur vers une région de mémoire suffisamment grande pour contenir une instance ou un tableau. De plus, la zone de mémoire doit avoir un alignement approprié. Cette version de l'opérateur newn'alloue pas de mémoire, elle fournit uniquement un appel au constructeur. Ainsi, cette option vous permet de séparer les phases d'allocation de mémoire et d'initialisation des objets. Cette fonctionnalité est activement utilisée dans les conteneurs standard. L'opérateur deletepour les objets ainsi créés ne peut bien entendu pas être appelé. Pour supprimer un objet, vous devez appeler directement le destructeur, puis libérer la mémoire d'une manière qui dépend de la méthode d'allocation de mémoire.

Les deux autres options sont appelées l'opérateur ne lançant pas d'exceptions new(nothrow new) et diffèrent en ce que s'il est impossible de satisfaire la demande, elles renvoient nullptr, mais ne lèvent pas d'exception de type std::bad_alloc. La suppression d'un objet se produit à l'aide de l'opérateur principal delete. Ces options sont considérées comme obsolètes et non recommandées.

1.3. Allocation de mémoire et fonctions libres

Les opérateurs standard new/deleteutilisent les fonctions d'allocation et de désallocation suivantes:

void* operator new(std::size_t size);
void operator delete(void* ptr);
void* operator new[](std::size_t size);
void operator delete[](void* ptr);
void* operator new(std::size_t size, void* ptr);
void* operator new[](std::size_t size, void* ptr);
void* operator new(std::size_t size, const std::nothrow_t& nth);
void* operator new[](std::size_t size, const std::nothrow_t& nth);

Ces fonctions sont définies dans l'espace de noms global. Les fonctions d'allocation de mémoire pour les instructions host newne font rien et retournent simplement ptr.

C ++ 17 a pris en charge d'autres formes d'allocation de mémoire et de désallocation, indiquant l'alignement. En voici quelques uns:

void* operator new (std::size_t size, std::align_val_t al);
void* operator new[](std::size_t size, std::align_val_t al);

Ces formulaires ne sont pas directement accessibles à l'utilisateur, ils sont utilisés par le compilateur pour des objets dont les exigences d'alignement sont supérieures __STDCPP_DEFAULT_NEW_ALIGNMENT__, donc le principal problème est que l'utilisateur ne les cache pas accidentellement (voir section 2.2.1). Rappelons qu'en C ++ 11, il est devenu possible de définir explicitement l'alignement des types d'utilisateurs.

struct alignas(32) X { /* ... */ };

2. Surcharger les formulaires standard des opérateurs nouveaux / supprimer

La surcharge des formes standard d'opérateurs new/deleteconsiste à définir des fonctions définies par l'utilisateur pour allouer et libérer de la mémoire dont les signatures coïncident avec celles standard. Ces fonctions peuvent être définies dans l'espace de noms global ou dans une classe, mais pas dans un espace de noms autre que global. La fonction d'allocation de mémoire pour une instruction hôte standard newne peut pas être définie dans l'espace de noms global. Après une telle définition, les opérateurs correspondants new/deleteles utiliseront, pas les opérateurs standard.

2.1. Surcharge dans l'espace de noms global

Supposons, par exemple, dans un module dans un espace de noms global que des fonctions définies par l'utilisateur soient définies:

void* operator new(std::size_t size)
{
// ...
}

void operator delete(void* ptr)
{
// ...
}

Dans ce cas, il y aura en fait un remplacement (remplacement) des fonctions standard pour allouer et libérer de la mémoire pour tous les appels d'opérateur new/deletepour toutes les classes (y compris les classes standard) dans le module entier. Cela peut conduire au chaos complet. Notez que le mécanisme de substitution décrit est un mécanisme spécial implémenté uniquement pour ce cas, et non un mécanisme C ++ général. Dans ce cas, lors de l'implémentation des fonctions utilisateur d'allocation et de libération de mémoire, il devient impossible d'appeler les fonctions standard correspondantes, elles sont complètement masquées (l'opérateur ::n'aide pas), et lorsque vous essayez de les appeler, un appel récursif à la fonction utilisateur se produit.

Fonction définie par l'espace de noms global

void* operator new(std::size_t size, const std::nothrow_t& nth)
{
// ...
}

Il remplacera également le standard, mais il y aura moins de problèmes potentiels, car l'opérateur qui ne lance pas d'exceptions newest rarement utilisé. Mais le formulaire standard n'est pas non plus disponible.

La même situation avec des fonctions pour les tableaux.

La surcharge des instructions new/deletedans l'espace de noms global est fortement déconseillée.

2.2. Surcharge de classe

La surcharge des opérateurs new/deletedans une classe est dépourvue des inconvénients décrits ci-dessus. La surcharge n'est efficace que lors de la création et de la suppression d'instances de la classe correspondante, quel que soit le contexte d'appel des opérateurs new/delete. Lorsque vous implémentez des fonctions définies par l'utilisateur pour allouer et libérer de la mémoire à l'aide de l'opérateur, ::vous pouvez accéder aux fonctions standard correspondantes. Prenons un exemple.

class X
{
// ...
public:
    void* operator new(std::size_t size)
    {
        std::cout << "X new\n";
        return ::operator new(size);
    }

    void operator delete(void* ptr)
    {
        std::cout << "X delete\n";
        ::operator delete(ptr);
    }

    void* operator new[](std::size_t size)
    {
        std::cout << "X new[]\n";
        return ::operator new[](size);
    }

    void operator delete[](void* ptr)
    {
        std::cout << "X delete[]\n";
        ::operator delete[](ptr);
    }
};

Dans cet exemple, le suivi est simplement ajouté aux opérations standard. Maintenant, en termes new X()et new X[N]utiliser ces fonctions pour allouer et libérer de la mémoire.

Ces fonctions sont formellement statiques et peuvent être déclarées comme static. Mais pour l'essentiel, ce sont des instances, avec l'appel de fonction operator new(), la création de l'instance commence et l'appel de fonction operator delete()termine sa suppression. Ces fonctions ne sont jamais appelées pour d'autres tâches. De plus, comme cela sera montré ci-dessous, la fonction operator delete()est essentiellement virtuelle. Il est donc plus correct de les déclarer sans static.

2.2.1. Accès aux formulaires standard des opérateurs nouveaux / supprimés

Les opérateurs new/deletepeuvent être utilisés avec un opérateur de résolution d'étendue supplémentaire, par exemple ::new(p) X(). Dans ce cas, la fonction operator new()définie dans la classe sera ignorée et la norme correspondante sera utilisée. De la même manière, vous pouvez utiliser l'opérateur delete.

2.2.2. Masquage d'autres formes d'opérateurs nouveaux / supprimés

Si maintenant, pour la classe, Xnous essayons d'utiliser des exceptions de lancement ou de non-lancement new, nous obtenons une erreur. Le fait est que la fonction operator new(std::size_t size)masquera d'autres formes operator new(). Le problème peut être résolu de deux manières. Dans le premier, vous devez ajouter les options appropriées à la classe (ces options devraient simplement déléguer le fonctionnement de la fonction standard). Dans le second, vous devez utiliser un opérateur newavec un opérateur de résolution de portée, par exemple ::new(p) X().

2.2.3. Conteneurs standard

Si nous essayons de placer les instances Xdans un conteneur standard, par exemple std::vector<X>, nous verrons que nos fonctions ne sont pas utilisées pour allouer et libérer de la mémoire. Le fait est que tous les conteneurs standard ont leur propre mécanisme d'allocation et de libération de mémoire (une classe d'allocateur spéciale, qui est un paramètre de modèle du conteneur), et ils utilisent un opérateur de placement pour initialiser les éléments new.

2.2.4. Héritage

Les fonctions d'allocation et de libération de mémoire sont héritées. Si ces fonctions sont définies dans la classe de base, mais pas dans la classe dérivée, les opérateurs seront surchargés pour la classe dérivée new/deleteet les fonctions définies et allouées dans la classe de base seront utilisées pour allouer et libérer de la mémoire.

Considérons maintenant une hiérarchie de classes polymorphe, où chaque classe surcharge les opérateurs new/delete. Maintenant, laissez l'instance de la classe dérivée supprimée à l'aide de l'opérateur deletevia un pointeur vers la classe de base. Si le destructeur de la classe de base est virtuel, la norme garantit que le destructeur de cette classe dérivée est appelé. Dans ce cas operator delete(), l' appel de fonction défini pour cette classe dérivée est également garanti . Ainsi, la fonction est en operator delete()réalité virtuelle.

2.2.5. Forme alternative de la fonction delete () de l'opérateur

Dans une classe (surtout quand l'héritage est utilisé), il est parfois pratique d'utiliser une forme alternative de la fonction pour libérer de la mémoire:

void operator delete(void* p, std::size_t size);
void operator delete[](void* p, std::size_t size);

Le paramètre sizedéfinit la taille de l'élément (même dans la version du tableau). Ce formulaire vous permet d'utiliser différentes fonctions pour allouer et libérer de la mémoire, selon la classe dérivée spécifique.

3. Opérateurs utilisateurs nouveaux / supprimés

C ++ peut prendre en charge les formulaires d'opérateur personnalisés de la newforme suivante:

new(/*  */) T(/*   */)
new(/*  */) T[/*   */]

Pour que ces formulaires soient pris en charge, il est nécessaire de déterminer les fonctions appropriées pour l'allocation et la libération de mémoire:

void* operator new(std::size_t size, /* .  */);
void* operator new[](std::size_t size, /* .  */);
void operator delete(void* p, /* .  */);
void operator delete[](void* p, /* .  */);

La liste des paramètres supplémentaires des fonctions d'allocation de mémoire ne doit pas être vide et ne doit pas consister en une void*ou const std::nothrow_t&, qui est, leur signature ne doit pas coïncider avec l' un des standards. Liste des paramètres supplémentaires dans operator new()et operator delete()doit correspondre. Les arguments transmis à l'opérateur newdoivent correspondre à des paramètres supplémentaires des fonctions d'allocation de mémoire. Une fonction personnalisée operator delete()peut également être dans le formulaire avec un paramètre de taille facultatif.

Ces fonctions peuvent être définies dans l'espace de noms global ou dans une classe, mais pas dans un espace de noms autre que global. S'ils sont définis dans l'espace de noms global, ils ne remplacent pas, mais surchargent, les fonctions standard d'allocation et de libération de mémoire, leur utilisation est donc prévisible et sûre, et les fonctions standard sont toujours disponibles. S'ils sont définis dans la classe, ils masquent les formulaires standard, mais l'accès aux formulaires standard peut être obtenu en utilisant l'opérateur ::, cela est décrit en détail dans la section 2.2.

Les formulaires d' opérateur définis par l' utilisateur newsont appelés newemplacements définis par l'utilisateur new. Ils ne doivent pas être confondus avec l'opérateur de placement standard (sans allocation) newdécrit à la section 1.2.

Le formulaire opérateur correspondant deleten'existe pas. Il newexiste deux façons de supprimer un objet créé à l'aide d'un opérateur défini par l'utilisateur . Si une fonction définie par l'utilisateur operator new()délègue une opération d'allocation de mémoire à des fonctions d'allocation de mémoire standard, un opérateur standard peut être utilisé delete. Sinon, vous devrez appeler explicitement le destructeur, puis la fonction définie par l'utilisateur operator delete(). Le compilateur appelle la fonction définie par l'utilisateur dans operator delete()un seul cas: lorsque le newconstructeur lève une exception pendant le fonctionnement de l'opérateur défini par l'utilisateur .

Voici un exemple (de portée globale).

void* operator new(std::size_t size, int a, const char* b)
{
    std::cout << "new " << a << " + " << b << "\n";
    return ::operator new(size);
}
void operator delete(void* p, int a, const char* b)
{
    std::cout << "delete " << a << " + " << b << "\n";
    ::operator delete(p);
}

class X {/* ... */};
X* p = new(42, "meow") X(); // : new 42 + meow
delete p; //   ::operator delete()

4. Définition des fonctions d'allocation de mémoire

Dans ces exemples, les fonctions utilisateur operator new()et les operator delete()opérations déléguées correspondant aux fonctions standard. Parfois, cette option est utile, mais le but principal de la surcharge new/deleteest de créer un nouveau mécanisme d'allocation / libération de mémoire. La tâche n'est pas simple et avant d'entreprendre, il faut bien réfléchir à tout. Scott Meyers [Meyers1] discute des motifs possibles pour prendre une telle décision (bien sûr, le principal est l'efficacité). Il discute également des principaux problèmes techniques liés à la mise en œuvre correcte des fonctions définies par l'utilisateur pour l'allocation et la libération de mémoire (en utilisant la fonctionset_new_handler(), synchronisation multi-thread, alignement). Guntheroth fournit un exemple de mise en œuvre de fonctions d'allocation de mémoire et de désallocation définies par l'utilisateur relativement simples. Avant de créer votre propre version, vous devez rechercher des solutions prêtes à l'emploi, par exemple, vous pouvez apporter la bibliothèque Pool du projet Boost.

5. Classes d'allocateurs de conteneurs standard

Comme mentionné ci-dessus, les conteneurs standard utilisent des classes d'allocation spéciales pour allouer et libérer de la mémoire. Ces classes sont des paramètres de modèle de conteneurs et l'utilisateur peut définir sa version d'une telle classe. Les motifs d'une telle solution sont à peu près les mêmes que pour les opérateurs de surcharge new/delete. [Guntheroth] décrit comment créer de telles classes.

Bibliographie

[Guntheroth]
Gunteroth, Kurt. Optimisation des programmes en C ++. Méthodes éprouvées pour augmenter la productivité.: Per. de l'anglais - SPb.: Alpha-book LLC, 2017.
[Meyers1]
Meyers, Scott. Utilisation efficace de C ++. 55 façons sûres d'améliorer la structure et le code de vos programmes.: Per. de l'anglais - M .: DMK Press, 2014.

Surcharge en C ++. Partie III. Surcharge des instructions new / delete