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... */ );

Intenta asignar el número de bytes solicitado, y la solicitud de asignación puede fallar (incluso si el número de bytes solicitado es cero). Estas funciones de asignación son llamadas por las new expresiones new para asignar memoria en la que luego se inicializará el nuevo objeto. También pueden ser llamadas usando la sintaxis de llamada a función regular.

Las sobrecargas (1-4) se declaran implícitamente en cada unidad de traducción incluso si el encabezado <new> no está incluido.

Consulte la new expresión new para los criterios de selección de sobrecarga.

Parámetros

Valor de retorno

Excepciones

Reemplazos globales

Las sobrecargas (1-8) son reemplazables. Los efectos de las versiones predeterminadas son:

#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)

Las sobrecargas de operator new y operator new[] con parámetros adicionales definidos por el usuario ("formas de colocación", versiones (11-14)) pueden declararse en el ámbito global como de costumbre, y son llamadas por las formas de colocación coincidentes de las expresiones new.

Las formas de colocación no asignadoras de la biblioteca estándar de operator new (9,10) no pueden ser reemplazadas y solo pueden personalizarse si la expresión de colocación new no utilizó la sintaxis ::new, proporcionando una colocación new específica de clase (19,20) con firma coincidente: void* T::operator new(std::size_t, void*) o void* T::operator new[](std::size_t, void*).

Sobrecargas específicas de clase

Tanto las funciones de asignación de un solo objeto como las de asignación de arreglos pueden definirse como funciones miembro estáticas públicas de una clase (versiones (15-18)). Si se definen, estas funciones de asignación son llamadas por expresiones new para asignar memoria para objetos individuales y arreglos de esta clase, a menos que la expresión new haya usado la forma ::new que omite la búsqueda en el ámbito de la clase. La palabra clave static es opcional para estas funciones: ya sea que se use o no, la función de asignación es una función miembro estática.

La expresión new busca el nombre de la función de asignación apropiada primero en el ámbito de la clase, y luego en el ámbito global. Nótese que, según las reglas de búsqueda de nombres, cualquier función de asignación declarada en el ámbito de la clase oculta todas las funciones de asignación globales para las expresiones new que intentan asignar objetos de esta clase.

#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

Las sobrecargas de operator new y operator new[] con parámetros adicionales definidos por el usuario ("formas de ubicación"), también pueden definirse como miembros de clase (19-22)). Cuando la expresión de ubicación new con la firma coincidente busca la función de asignación correspondiente para llamar, comienza en el ámbito de la clase antes de examinar el ámbito global, y si la ubicación específica de clase new se proporciona, es llamada.

#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 operator new a nivel de clase es una función plantilla, debe tener el tipo de retorno de void*, el primer argumento std::size_t, y debe tener dos o más parámetros. En otras palabras, solo las formas de ubicación pueden ser plantillas.

Notas

Aunque el placement no asignador new ( 9,10 ) no puede ser reemplazado, una función con la misma firma puede definirse en el ámbito de la clase como se describió anteriormente. Además, se permiten sobrecargas globales que parecen placement new pero toman un tipo de puntero no void como segundo argumento, por lo que el código que quiere asegurar que se llame al verdadero placement new (ej. std::allocator::construct ), debe usar :: new y también convertir el puntero a void * .

Si el comportamiento de una función de desasignación no satisface las restricciones predeterminadas, el comportamiento es indefinido.

No está especificado si las versiones de biblioteca de operator new realizan llamadas a std::malloc o std::aligned_alloc (desde C++17) .

Para cargar un archivo grande, el mapeo de archivos mediante funciones específicas del sistema operativo, por ejemplo, mmap en POSIX o CreateFileMapping ( A / W ) junto con MapViewOfFile en Windows, es preferible a asignar un búfer para la lectura de archivos.

1. ↑ Formalmente, esta macro se expande a 202306L si todas las versiones por defecto de las funciones de asignación global reemplazables cumplen con los requisitos de una implementación hospedada.

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Referencias

Véase también