operator new — Global operator new
void* operator new(std::size_t size) throw(std::bad_alloc); void* operator new(std::size_t size, const std::nothrow_t&) throw( ); void* operator new[](std::size_t size) throw(std::bad_alloc); void* operator new[](std::size_t size, const std::nothrow_t&) throw( ); void* operator new(std::size_t size, void* ptr) throw( ); void* operator new[](std::size_t size, void* ptr) throw( );
The global operator
new
function allocates memory and
returns a pointer to the newly allocated memory. The memory must
later be released by a corresponding delete
expression or an explicit call to
operator
delete
.
The first version of new
allocates at least size
bytes of
memory, suitably aligned to store any type, and returns a pointer to
the memory. If the request cannot be fulfilled, it throws bad_alloc
.
The second version is like the first, but it returns a null
pointer instead of throwing bad_alloc
if sufficient memory cannot be
allocated.
The third version is like the first, but it allocates memory
for storing an array of objects. It might allocate more than
size
bytes to permit the library
to store additional bookkeeping information. You must use the array
form of delete[]
to free this
memory.
The fourth version is like the third, but it returns a null
pointer instead of throwing bad_alloc
if sufficient memory cannot be
allocated.
To allocate memory, the operator
new
functions first try to allocate
size
bytes. If they cannot, they
call the handler function set by the most recent call to set_new_handler
. Then they try again to
allocate size
bytes. This loop
repeats until the request is fulfilled or the handler function fails
to return. The nothrow
versions
of the function return 0
if the
most recent call to set_new_handler
was a null pointer or if
the new handler function throws bad_alloc
.
The final two versions do nothing except return ptr
. These forms permit placement new
expressions to specify a memory
location where an object will be constructed.
Unlike other identifiers in the standard library, operator
new
is global and is not in the std
namespace. Also, unlike with other
functions in the standard library, you can provide your own
implementation of operator
new
, which replaces the standard
implementation. You cannot, however, replace the last two versions
of new
with your own
implementation.