operator new , operator new[]

Versucht, die angeforderte Anzahl von Bytes zu allokieren, und die Allokationsanfrage kann fehlschlagen (selbst wenn die angeforderte Anzahl von Bytes null ist). Diese Allokationsfunktionen werden von new -Ausdrücken aufgerufen, um Speicher zu allokieren, in dem dann neue Objekte initialisiert würden. Sie können auch über die reguläre Funktionsaufruf-Syntax aufgerufen werden.

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

Siehe new expression für die Kriterien zur Auswahl der Überladung.

Parameter

Rückgabewert

Exceptions

Globale Ersetzungen

Overloads ( 1-8 ) sind austauschbar . Die Effekte 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 ("Placement-Formen", Versionen ( 11-14 ) ) können wie üblich im globalen Gültigkeitsbereich deklariert werden und werden durch die entsprechenden Placement-Formen von new -Ausdrücken aufgerufen.

Die nicht-allozierenden Platzierungsformen des 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 hat, indem ein klassen-spezifischer 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-Allokierungsfunktionen können als öffentliche statische Memberfunktionen einer Klasse definiert werden (Versionen ( 15-18 ) ). Falls definiert, werden diese Allokierungsfunktionen durch new -Ausdrücke aufgerufen, um Speicher für Einzelobjekte und Arrays dieser Klasse zu allokieren, es sei denn, der new -Ausdruck verwendete die Form :: new , welche die klassenbezogene Suche umgeht. Das Schlüsselwort static ist für diese Funktionen optional: Unabhängig davon, ob es verwendet wird oder nicht, ist die Allokierungsfunktion eine statische Memberfunktion.

Der new -Ausdruck sucht zunächst im Klassenbereich nach dem Namen der entsprechenden Allokationsfunktion und danach im globalen Bereich. Beachten Sie, dass gemäß den Namenssucheregeln alle im Klassenbereich deklarierten Allokationsfunktionen alle globalen Allokationsfunktionen für die new -Ausdrücke verbergen, die versuchen, Objekte dieser Klasse zu allokieren.

#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 auch als Klassenmember definiert werden ( 19-22 ) ). Wenn der Platzierungs- new -Ausdruck mit der passenden Signatur nach der entsprechenden Allokationsfunktion sucht, beginnt er im Klassenbereich, bevor der globale Bereich untersucht wird, und wenn das klassen-spezifische Platzierungs- new bereitgestellt wird, wird es 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 der klassenbezogene operator new eine Template-Funktion ist, muss er den Rückgabetyp void * haben, das erste Argument std::size_t , und er muss zwei oder mehr Parameter besitzen. Mit anderen Worten: Nur Placement-Formen können Templates 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