new expressions (C++ only)

The new operator provides dynamic storage allocation.

new operator syntax

If you prefix new with the scope resolution operator (::), the global operator new() is used. If you specify an argument_list, the overloaded new operator that corresponds to that argument_list is used. The type is an existing built-in or user-defined type. A new_type is a type that has not already been defined and can include type specifiers and declarators.

An allocation expression containing the new operator is used to find storage in free store for the object being created. The new expression returns a pointer to the object created and can be used to initialize the object. If the object is an array, a pointer to the initial element is returned.

You cannot use the new operator to allocate function types, void, or incomplete class types because these are not object types. However, you can allocate pointers to functions with the new operator. You cannot create a reference with the new operator.

char * c = new char[0];

In this case, a pointer to a unique object is returned.

An object created with operator new() or operator new[]() exists until the operator delete() or operator delete[]() is called to deallocate the object's memory. A delete operator or a destructor will not be implicitly called for an object created with a new that has not been explicitly deallocated before the end of the program.

If parentheses are used within a new type, parentheses should also surround the new type to prevent syntax errors.

In the following example, storage is allocated for an array of pointers to functions:

void f();
void g();

int main(void)
{
   void (**p)(), (**q)();
   // declare p and q as pointers to pointers to void functions
   p = new (void (*[3])());
   // p now points to an array of pointers to functions
   q = new void(*[3])(); // error
   // error - bound as 'q = (new void) (*[3])();'
   p[0] = f;  // p[0] to point to function f
   q[2] = g;  // q[2] to point to function g
   p[0]();    // call f()
   q[2]();    // call g()
   return (0);
}

However, the second use of new causes an erroneous binding of q = (new void) (*[3])().

The type of the object being created cannot contain class declarations, enumeration declarations, or const or volatile types. It can contain pointers to const or volatile objects.

For example, const char* is allowed, but char* const is not.