operator new , operator new[]

Tente d'allouer le nombre demandé d'octets, et la demande d'allocation peut échouer (même si le nombre demandé d'octets est zéro). Ces fonctions d'allocation sont appelées par les new expressions pour allouer la mémoire dans laquelle le nouvel objet serait ensuite initialisé. Elles peuvent également être appelées en utilisant la syntaxe normale d'appel de fonction.

Surcharges ( 1-4 ) sont implicitement déclarées dans chaque unité de traduction même si l'en-tête <new> n'est pas inclus.

Voir new expression pour les critères de sélection de surcharge.

Paramètres

Valeur de retour

Exceptions

Remplacements globaux

Surcharges ( 1-8 ) sont remplaçables . Les effets des versions par défaut sont :

#include <cstdio>
#include <cstdlib>
#include <new>
// no inline, required by [replacement.functions]/3
void* operator new(std::size_t sz)
{
    std::printf("1) new(size_t), size = %zu\n", sz);
    if (sz == 0)
        ++sz; // avoid std::malloc(0) which may return nullptr on success
    if (void *ptr = std::malloc(sz))
        return ptr;
    throw std::bad_alloc{}; // required by [new.delete.single]/3
}
// no inline, required by [replacement.functions]/3
void* operator new[](std::size_t sz)
{
    std::printf("2) new[](size_t), size = %zu\n", sz);
    if (sz == 0)
        ++sz; // avoid std::malloc(0) which may return nullptr on success
    if (void *ptr = std::malloc(sz))
        return ptr;
    throw std::bad_alloc{}; // required by [new.delete.single]/3
}
void operator delete(void* ptr) noexcept
{
    std::puts("3) delete(void*)");
    std::free(ptr);
}
void operator delete(void* ptr, std::size_t size) noexcept
{
    std::printf("4) delete(void*, size_t), size = %zu\n", size);
    std::free(ptr);
}
void operator delete[](void* ptr) noexcept
{
    std::puts("5) delete[](void* ptr)");
    std::free(ptr);
}
void operator delete[](void* ptr, std::size_t size) noexcept
{
    std::printf("6) delete[](void*, size_t), size = %zu\n", size);
    std::free(ptr);
}
int main()
{
    int* p1 = new int;
    delete p1;
    int* p2 = new int[10]; // guaranteed to call the replacement in C++11
    delete[] p2;
}

// Compiled with GCC-5 in C++17 mode to obtain the following:
1) op new(size_t), size = 4
4) op delete(void*, size_t), size = 4
2) op new[](size_t), size = 40
5) op delete[](void* ptr)

Les surcharges de operator new et operator new[] avec des paramètres supplémentaires définis par l'utilisateur ("formes de placement", versions ( 11-14 ) ) peuvent être déclarées au niveau global comme d'habitude, et sont appelées par les formes de placement correspondantes des expressions new .

Les formes de placement non-allouantes de la bibliothèque standard de operator new ( 9,10 ) ne peuvent pas être remplacées et ne peuvent être personnalisées que si l'expression de placement new n'a pas utilisé la syntaxe :: new , en fournissant un placement spécifique à la classe new ( 19,20 ) avec la signature correspondante : void * T :: operator new ( std:: size_t , void * ) ou void * T :: operator new [ ] ( std:: size_t , void * ) .

Surcharges spécifiques à la classe

Les fonctions d'allocation pour un objet unique et pour un tableau peuvent être définies comme des fonctions membres statiques publiques d'une classe (versions ( 15-18 ) ). Si elles sont définies, ces fonctions d'allocation sont appelées par les expressions new pour allouer de la mémoire pour des objets uniques et des tableaux de cette classe, sauf si l'expression new a utilisé la forme :: new qui contourne la recherche dans la portée de la classe. Le mot-clé static est optionnel pour ces fonctions : qu'il soit utilisé ou non, la fonction d'allocation est une fonction membre statique.

L'expression new recherche d'abord le nom de la fonction d'allocation appropriée dans la portée de la classe, puis dans la portée globale. Notez que, conformément aux règles de recherche de nom , toute fonction d'allocation déclarée dans la portée de la classe masque toutes les fonctions d'allocation globales pour les expressions new qui tentent d'allouer des objets de cette classe.

#include <cstddef>
#include <iostream>
// class-specific allocation functions
struct X
{
    static void* operator new(std::size_t count)
    {
        std::cout << "custom new for size " << count << '\n';
        return ::operator new(count);
    }
    static void* operator new[](std::size_t count)
    {
        std::cout << "custom new[] for size " << count << '\n';
        return ::operator new[](count);
    }
};
int main()
{
    X* p1 = new X;
    delete p1;
    X* p2 = new X[10];
    delete[] p2;
}

custom new for size 1
custom new[] for size 10

Les surcharges de operator new et operator new[] avec des paramètres supplémentaires définis par l'utilisateur ("formes de placement"), peuvent également être définies comme membres de classe ( 19-22 ) ). Lorsque l'expression de placement new avec la signature correspondante recherche la fonction d'allocation à appeler, elle commence au niveau de la classe avant d'examiner la portée globale, et si le placement new spécifique à la classe est fourni, il est appelé.

#include <cstddef>
#include <iostream>
#include <stdexcept>
struct X
{
    X() { throw std::runtime_error(""); }
    // custom placement new
    static void* operator new(std::size_t count, bool b)
    {
        std::cout << "custom placement new called, b = " << b << '\n';
        return ::operator new(count);
    }
    // custom placement delete
    static void operator delete(void* ptr, bool b)
    {
        std::cout << "custom placement delete called, b = " << b << '\n';
        ::operator delete(ptr);
    }
};
int main()
{
    try
    {
        [[maybe_unused]] X* p1 = new (true) X;
    }
    catch (const std::exception&)
    {}
}

custom placement new called, b = 1
custom placement delete called, b = 1

Si l'opérateur operator new au niveau de la classe est une fonction template, il doit avoir le type de retour void * , le premier argument std::size_t , et il doit avoir deux paramètres ou plus. En d'autres termes, seules les formes de placement peuvent être des templates.

Notes

Bien que le placement non-allouant new ( 9,10 ) ne puisse pas être remplacé, une fonction avec la même signature peut être définie au niveau de la classe comme décrit ci-dessus. De plus, les surcharges globales qui ressemblent au placement new mais prennent un type de pointeur non-void comme second argument sont autorisées, donc le code qui veut garantir que le vrai placement new est appelé (par ex. std::allocator::construct ), doit utiliser :: new et aussi convertir le pointeur en void * .

Si le comportement d'une fonction de désallocation ne satisfait pas les contraintes par défaut, le comportement est indéfini.

Il n'est pas spécifié si les versions de bibliothèque de operator new effectuent des appels à std::malloc ou à std::aligned_alloc (depuis C++17) .

Pour charger un fichier volumineux, le mappage de fichiers via des fonctions spécifiques au système d'exploitation, par exemple, mmap sur POSIX ou CreateFileMapping ( A / W ) avec MapViewOfFile sur Windows, est préférable à l'allocation d'un tampon pour la lecture de fichiers.

1. ↑ Formellement, cette macro se développe en 202306L si toutes les versions par défaut des fonctions d'allocation globales remplaçables satisfont aux exigences d'une implémentation hébergée.

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.

Références

Voir aussi