operator new , operator new[]

Intenta asignar el número solicitado de bytes, y la solicitud de asignación puede fallar (incluso si el número solicitado de bytes es cero). Estas funciones de asignación son llamadas por new expressions para asignar memoria en la cual el nuevo objeto sería entonces inicializado. También pueden ser llamadas usando la sintaxis regular de llamada a función.

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

Consulte new expression para los criterios de selección de sobrecarga.

Parámetros

Valor de retorno

Excepciones

Reemplazos globales

Sobrecargas ( 1-8 ) son reemplazables . Los efectos de las versiones por defecto 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 es usual, y son llamadas por las correspondientes formas de colocación de las expresiones new .

Las formas de ubicación sin asignación de la biblioteca estándar de operator new ( 9,10 ) no pueden ser reemplazadas y solo pueden personalizarse si la expresión de ubicación new no utilizó la sintaxis :: new , proporcionando una ubicación específica de clase new ( 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 la clase

Tanto las funciones de asignación de objetos individuales como 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 las expresiones new para asignar memoria para objetos individuales y arreglos de esta clase, a menos que la expresión new utilice la forma :: new que omite la búsqueda en el ámbito de la clase. La palabra clave static es opcional para estas funciones: tanto si se utiliza como si no, la función de asignación es una función miembro estática.

La expresión new busca primero el nombre de la función de asignación apropiada en el ámbito de la clase, y después en el ámbito global. Nótese que, de acuerdo con 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 colocación"), también pueden definirse como miembros de clase ( 19-22 ) ). Cuando la expresión de colocación new con la firma correspondiente 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 se proporciona el new de colocación específico de la clase, se llama.

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