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

Versucht, die angeforderte Anzahl von Bytes zu allozieren, und die Allokationsanforderung kann fehlschlagen (auch wenn die angeforderte Anzahl von Bytes null ist). Diese Allokationsfunktionen werden von new-Ausdrücken aufgerufen, um Speicher zu allozieren, in dem dann ein neues Objekt initialisiert wird. Sie können auch mit normaler Funktionsaufrufsyntax aufgerufen werden.

aufgerufen werden. Die Überladungen (1-4) werden in jeder Übersetzungseinheit implizit deklariert, auch wenn der <new>-Header nicht eingebunden ist.

Siehe new-New-Ausdruck für die Kriterien zur Auswahl der Überladung.

Parameter

Rückgabewert

Exceptions

Globale Ersetzungen

Die Überladungen (1-8) sind ersetzbar. Die Wirkungen der Standardversionen sind:

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

Überladungen von operator new und operator new[] mit zusätzlichen benutzerdefinierten Parametern („Platzierungsformen“, Versionen (11-14)) können wie üblich im globalen Gültigkeitsbereich deklariert werden und werden von den passenden Platzierungsformen von new-Ausdrücken aufgerufen.

Die nicht-belegenden Platzierungsformen von operator new (9,10) der Standardbibliothek können nicht ersetzt werden und können nur angepasst werden, wenn der Platzierungs-new-Ausdruck nicht die ::new-Syntax verwendet, indem eine klassen-spezifische Platzierungs-new (19,20) mit passender Signatur bereitgestellt wird: void* T::operator new(std::size_t, void*) oder void* T::operator new[](std::size_t, void*).

Klassenspezifische Überladungen

Sowohl Einzelobjekt- als auch Array-Allokationsfunktionen können als öffentliche statische Memberfunktionen einer Klasse definiert werden (Versionen (15-18)). Falls definiert, werden diese Allokationsfunktionen von new-Ausdrücken aufgerufen, um Speicher für Einzelobjekte und Arrays dieser Klasse zu allozieren, es sei denn, der new-Ausdruck verwendet die Form ::new, die die Sichtbarkeit im Klassenbereich umgeht. Das Schlüsselwort static ist für diese Funktionen optional: unabhängig davon, ob es verwendet wird oder nicht, ist die Allokationsfunktion eine statische Memberfunktion.

Der new-Ausdruck sucht den Namen der passenden Allokationsfunktion zuerst im Klassenbereich und danach im globalen Bereich. Beachten Sie, dass gemäß den Namenssuchregeln alle im Klassenbereich deklarierten Allokationsfunktionen alle globalen Allokationsfunktionen für die new-Ausdrücke verdecken, die versuchen, Objekte dieser Klasse zu allozieren.

#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

Überladungen von operator new und operator new[] mit zusätzlichen benutzerdefinierten Parametern ("Platzierungsformen") können ebenfalls als Klassenmitglieder definiert werden (19-22)). Wenn der Platzierungs-new-Ausdruck mit der passenden Signatur nach der entsprechenden Allokationsfunktion sucht, beginnt er im Klassenbereich, bevor er den globalen Bereich untersucht, und wenn die klassenspezifische Platzierungs-new bereitgestellt wird, wird sie aufgerufen.

#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

Wenn die klassenweite operator new eine Vorlagenfunktion ist, muss sie den Rückgabetyp void*, das erste Argument std::size_t haben und zwei oder mehr Parameter besitzen. Mit anderen Worten, nur Platzierungsformen können Vorlagen sein.

Hinweise

Obwohl das nicht-allozierende Placement- new ( 9,10 ) nicht ersetzt werden kann, kann eine Funktion mit derselben Signatur wie oben beschrieben im Klassenbereich definiert werden. Zusätzlich sind globale Überladungen erlaubt, die wie Placement- new aussehen, aber einen Nicht-Void-Zeigertyp als zweiten Parameter nehmen. Daher muss Code, der sicherstellen möchte, dass das echte Placement- new aufgerufen wird (z.B. std::allocator::construct ), :: new verwenden und den Zeiger auch auf void * casten.

Wenn das Verhalten einer Freigabefunktion die Standardbeschränkungen nicht erfüllt, ist das Verhalten undefiniert.

Es ist nicht spezifiziert, ob Bibliotheksversionen von operator new Aufrufe an std::malloc oder std::aligned_alloc (seit C++17) durchführen.

Zum Laden einer großen Datei ist Dateimapping über betriebssystemspezifische Funktionen, z.B. mmap unter POSIX oder CreateFileMapping ( A / W ) zusammen mit MapViewOfFile unter Windows, der Zuweisung eines Puffers für Dateilesen vorzuziehen.

1. ↑ Formal erweitert sich dieses Makro zu 202306L wenn alle Standardversionen der ersetzbaren globalen Allokationsfunktionen die Anforderungen einer gehosteten Implementierung erfüllen.

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Referenzen

Siehe auch