演算子 new、演算子 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... */ );

要求されたバイト数の確保を試みます。確保要求は（要求されたバイト数がゼロであっても）失敗する可能性があります。これらの確保関数は new 式によって呼び出され、新しいオブジェクトが初期化されるメモリを確保します。通常の関数呼び出し構文を使用して呼び出すこともできます。

オーバーロード (1-4) は、<new> ヘッダがインクルードされていなくても、各翻訳単位で暗黙的に宣言されます。

オーバーロード選択の基準については、new 式 を参照してください。

パラメータ

戻り値

例外

グローバル置換

多重定義 (1-8) は置換可能です。デフォルトのバージョンの効果は以下の通りです:

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

operator new と operator new[] の、追加のユーザー定義パラメータを持つ多重定義（「配置形式」、バージョン (11-14)）は通常通りグローバルスコープで宣言でき、対応する 配置形式 の new 式によって呼び出されます。

標準ライブラリの非割り当て配置形式の operator new (9,10) は置換できず、配置 new 式が ::new 構文を使用しない場合にのみ、一致するシグネチャを持つクラス固有の配置 new (19,20) を提供することでカスタマイズできます: void* T::operator new(std::size_t, void*) または void* T::operator new[](std::size_t, void*)。

クラス固有のオーバーロード

単一オブジェクトおよび配列の確保関数は、どちらもクラスのパブリックスタティックメンバ関数として定義できます（バージョン (15-18)）。これらが定義されている場合、これらの確保関数は、new 式によって呼び出され、このクラスの単一オブジェクトおよび配列のメモリを確保します。ただし、new 式がクラススコープでの名前探索をバイパスする形式 ::new を使用している場合は除きます。これらの関数ではキーワード static はオプションです。使用の有無にかかわらず、確保関数は静的メンバ関数です。

new 式は、最初にクラススコープ内で、次にグローバルスコープ内で適切な確保関数の名前を探します。なお、名前探索ルール に従い、クラススコープで宣言された確保関数は、このクラスのオブジェクトを確保しようとする new 式に対して、すべてのグローバル確保関数を隠蔽することに注意してください。

#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

operator new および operator new[] の追加のユーザー定義パラメータを持つオーバーロード（「配置形式」）も、クラスメンバとして定義できます（(19-22)）。一致するシグネチャを持つ配置 new 式が呼び出すべき対応する確保関数を探すとき、グローバルスコープを調べる前にクラススコープから探索を開始し、クラス固有の配置 new が提供されている場合、それが呼び出されます。

#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

クラスレベルの operator new がテンプレート関数である場合、戻り値の型は void* でなければならず、最初の引数は std::size_t であり、2つ以上のパラメータを持たなければなりません。言い換えると、テンプレートにできるのは配置形式のみです。

注記

非割り当て配置 new ( 9,10 ) が置き換え不能であっても、前述のようにクラススコープで同じシグネチャを持つ関数を定義することができます。さらに、配置 new のように見えるが第二引数として非voidポインタ型を取るグローバルなオーバーロードが許可されているため、真の配置 new が呼び出されることを保証したいコード（例: std::allocator::construct ）は、 :: new を使用し、さらにポインタを void * にキャストする必要があります。

解放関数の動作がデフォルトの制約を満たさない場合、その動作は未定義です。

ライブラリバージョンの operator new が std::malloc または std::aligned_alloc (C++17以降) を呼び出すかどうかは未規定です。

大容量ファイルの読み込みには、ファイル読み込み用のバッファを割り当てるよりも、OS固有の機能によるファイルマッピング、例えば mmap on POSIX または CreateFileMapping ( A / W ) と MapViewOfFile on Windows を使用する方が望ましいです。

1. ↑ 形式的には、このマクロは 202306L に展開されます。これは、置換可能なグローバル割り当て関数のデフォルトバージョンがすべて、ホスト環境実装の要件を満たしている場合です。

不具合報告

以下の動作変更の欠陥報告書は、以前に公開されたC++規格に対して遡及的に適用されました。

参考文献

関連項目