new operator

new-expr ::= [::] new [placement] new-type-id [new-initializer] | 
    [::] new [placement] ( type-id ) [new-initializer]
placement ::= ( expr-list )
new-type-id ::= type-specifier-seq [new-declarator]
new-declarator ::= ptr-operator [new-declarator] | direct-new-declarator
direct-new-declarator ::= "[" expression "]" | 
    direct-new-declarator "[" constant-expr "]"
new-initializer ::= ( [expr-list] )
ptr-operator ::= * [cv-qualifier-seq] | & | [::] nested-name :: * [cv-qualifier-seq]

The new expression allocates memory and constructs an object. It has many forms, the simplest being a simple type name (e.g., new int). The new-type-id can be a sequence of type specifiers and qualifiers, with pointer operators, a reference operator, and an array size (e.g., new int*[n][42], which allocates a two-dimensional array of pointers to int with n rows and 42 columns). The first dimension can be an integral expression; the second and subsequent dimensions must be constant expressions. If the type contains parentheses, such as function pointers, you should enclose it in parentheses to avoid ambiguity.

The new expression calls an allocator function to allocate the necessary memory, then initializes the memory. The new-initializer is an optional list of expressions in parentheses. If no new-initializer is present, the new object is initialized to its default value: POD objects are uninitialized, and other objects are initialized with their default constructors. If the new-initializer consists of just empty parentheses, POD objects are initialized to 0, and other objects are initialized with their default constructors. The new-initializer can be the value of a scalar or a list of expressions to pass to a suitable constructor.

The allocator function is operator new or operator new[], which can be overloaded (as described in Chapter 5). Two global placement operator new functions are provided by the standard library (see the <new> header); you can define additional functions if you wish.

The allocator function takes a size_t as its first parameter, which is the number of bytes of memory to allocate. It returns a pointer to the memory. The placement syntax is a list of expressions in parentheses. The expression list is passed to the allocator functions after the size argument. The compiler chooses which overloaded operator new according to the usual rules of overload resolution (Chapter 5).

Example

void* operator new(std::size_t nbytes)
{
  void* result = std::malloc(nbytes);
  debug(result);
  if (result == 0)
    throw std::bad_alloc("no more memory");
  return result;
}
int* p = new int;
int* array = new int[10];
int* placement = new(p) int;
...
delete p;
delete[] array;

See Also

declarator, delete, expression, type, Chapter 3, Chapter 5, <new>