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

요청된 바이트 수를 할당하려 시도하며, 할당 요청은 실패할 수 있습니다(요청된 바이트 수가 0인 경우에도). 이 할당 함수들은 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*)를 제공하여 사용자 정의할 수 있습니다.

클래스별 오버로드

단일 객체 및 배열 할당 함수는 모두 클래스의 public static 멤버 함수로 정의될 수 있습니다(버전 (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이어야 하며, 두 개 이상의 매개변수가 있어야 합니다. 즉, 배치 형식만 템플릿이 될 수 있습니다.

참고 사항

비할당 배치 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++ 표준에 소급 적용되었습니다.

참고문헌

참고 항목