operator new, operator new[]

void* operator new  ( std::size_t count );

void* operator new[]( std::size_t count );

void* operator new  ( std::size_t count, std::align_val_t al );

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

void* operator new  ( std::size_t count, const std::nothrow_t& tag );

void* operator new[]( std::size_t count, const std::nothrow_t& tag );

void* operator new  ( std::size_t count, std::align_val_t al,
                      const std::nothrow_t& tag ) noexcept;

void* operator new[]( std::size_t count, std::align_val_t al,
                      const std::nothrow_t& tag ) noexcept;

void* operator new  ( std::size_t count, void* ptr );

void* operator new[]( std::size_t count, void* ptr );

void* operator new  ( std::size_t count, /* args... */ );

void* operator new[]( std::size_t count, /* args... */ );

void* operator new  ( std::size_t count,
                      std::align_val_t al, /* args... */ );

void* operator new[]( std::size_t count,
                      std::align_val_t al, /* args... */ );

void* T::operator new  ( std::size_t count );

void* T::operator new[]( std::size_t count );

void* T::operator new  ( std::size_t count, std::align_val_t al );

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

void* T::operator new  ( std::size_t count, /* args... */ );

void* T::operator new[]( std::size_t count, /* args... */ );

void* T::operator new  ( std::size_t count,
                         std::align_val_t al, /* args... */ );

void* T::operator new[]( std::size_t count,
                         std::align_val_t al, /* args... */ );

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

Les 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 la surcharge.

Paramètres

Valeur de retour

Exceptions

Remplacements globaux

Les 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 à la portée globale 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'new expression de placement n'utilise pas la syntaxe ::new, en fournissant un placement spécifique à la classe new (19,20) avec une signature correspondante : void* T::operator new(std::size_t, void*) ou void* T::operator new[](std::size_t, void*).

Surcharges spécifiques à une classe

Les fonctions d'allocation pour un seul objet et pour un tableau peuvent être définies comme fonctions membres publiques statiques 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 utilise la forme ::new qui contourne la recherche dans la portée de la classe. Le mot-clé static est facultatif 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 correspondante à appeler, elle commence dans la portée de la classe avant d'examiner la portée globale, et si le placement spécifique à la classe new 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 une fonction operator new au niveau de la classe est une fonction template, elle doit avoir le type de retour de void*, le premier argument std::size_t, et elle 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