Operator new函數

operator new

void* operator new (std::size_t size) throw (std::bad_alloc);
void* operator new (std::size_t size, const std::nothrow_t& nothrow_constant) throw();
void* operator new (std::size_t size, void* ptr) throw();

Allocate storage space

The first version allocates size bytes of storage space, aligned to represent an object of that size, and returns a non-null pointer to the first byte of this block. On failure, it throws abad_alloc exception.

第一個版本分配size個字節的存儲空間，返回值指向分配空間的第一個字節。如果分配失敗，拋出一個bad_alloc異常。

The second version is the nothrow version. It does the same as the first version, except that on failure it returns a null pointer instead of throwing an exception.

第二個版本是一個nothrow版本。基本操作與第一個版本相同，除了當分配失敗時，它返回一個空指針而不是拋出異常。

The third version is the placement version, that does not allocate memory - it simply returnsptr. Notice though that the constructor for the object (if any) will still be called by the operator expression.

第三個版本是placement new版本，它不分配內存--它只返回ptr。注意：對象的構造器仍然會被調用。

Global dynamic storage operator functions are special in the standard library:

• All three versions of operator new are declared in the global namespace, not in thestd namespace.
• The first and second versions are implicitly declared in every translation unit of a C++ program: The header<new> does not need to be included for them to be present.
• The first and second versions are also replaceable: A program may provide its own definition, that replaces the default one, to produce the result described above.

If set_new_handler has been used to define anew_handler function, this new_handler function is called by the standard default definition of operator new if it cannot allocate the requested storage by its own.

operator new can be called explicitly as a regular function, but in C++,new is an operator with a very specific behavior: An expression with thenew operator, first calls function operator new with the size of its type specifier as first argument, and if this is successful, it then automatically initializes or constructs the object (if needed). Finally, the expression evaluates as a pointer to the appropriate type.

operator new函數可以作爲一個正常的函數進行顯式調用，但是在C++裏，new是一個非常特別的操作符，對於一個new操作表達式，首先調用函數operator new，並且利用對應類型的size大小初始化第一個參數，如果成功，那麼它會自動調用對象的構造函數，然後表達式返回適當類型的指針。

注：

在C++中，new操作符可以被重載接收多於一個參數：第一個傳遞給operator new的參數總是元素類型的分配的內存大小，但是其它的參數可以通過括號進行傳遞，舉例來說：

int * p = new (x) int;

這個表達式將會調用

operator new (sizeof(int),x);

Parameters

size

Size in bytes of the requested memory block.
size_t is an integral type.

nothrow_constant

The constant nothrow.
This parameter is only used to distinguish it from the first version with an overloaded version. When thenothrow constant is passed as second parameter tooperator new, operator new returns a null-pointer on failure instead of throwing abad_alloc exception.
nothrow_t is the type of constantnothrow.

ptr

A pointer to a memory block where the object is to be constructed

Return value

For the first and second versions, a pointer to the newly allocated storage space.

For the third version, ptr is returned.

// operator new example
#include <iostream>
#include <new>
using namespace std;

struct myclass {myclass() {cout <<"myclass constructed\n";}};

int main () {

   int * p1 = new int;
// same as:
// int * p1 = (int*) operator new (sizeof(int));

   int * p2 = new (nothrow) int;
// same as:
// int * p2 = (int*) operator new (sizeof(int),nothrow);

   myclass * p3 = (myclass*) operator new (sizeof(myclass));
// (!) not the same as:
// myclass * p3 = new myclass;
// (constructor not called by function call, even for non-POD types)

   new (p3) myclass;   // calls constructor
// same as:
// operator new (sizeof(myclass),p3)

   return 0;
}