new and delete (C++)

Except for a form called the "placement new", the new operator denotes a request for memory allocation on a process's heap. If sufficient memory is available, new initialises the memory, calling object constructors if necessary, and returns the address to the newly allocated and initialised memory.[2][3] A new request, in its simplest form, looks as follows:

p = new T;

where p is a previously declared pointer of type T (or some other type to which a T pointer can be assigned, such as a superclass of T). The default constructor for T, if any, is called to construct a T instance in the allocated memory buffer.

If not enough memory is available in the free store for an object of type T, the new request indicates failure by throwing an exception of type std::bad_alloc. This removes the need to explicitly check the result of an allocation.

The deallocation counterpart of new is delete, which first calls the destructor (if any) on its argument and then returns the memory allocated by new back to the free store. Every call to new must be matched by a call to delete; failure to do so causes a memory leak.[1]

new syntax has several variants that allow finer control over memory allocation and object construction. A function call-like syntax is used to call a different constructor than the default one and pass it arguments, e.g.,

p = new T(argument);

calls a single-argument T constructor instead of the default constructor when initializing the newly allocated buffer.

A different variant allocates and initialises arrays of objects rather than single objects:

p = new T [N];

This requests a memory buffer from the free store that is large enough to hold a contiguous array of N objects of type T, and calls the default constructor on each element of the array.

Memory allocated with the new[] must be deallocated with the delete[] operator, rather than delete. Using the inappropriate form results in undefined behavior. C++ compilers are not required to generate a diagnostic message for using the wrong form.

The C++11 standard specifies an additional syntax,

p = new T[N] {initializer1, ..., initializerN};

that initializes each p[i] to initializeri+1.

#include <cstdlib>
#include <cstddef>

class Singleton {
public:
  static void* operator new(std::size_t size) {
    if (!instance) {
      instance = std::malloc(size);
    }
    refcount++;
    return instance;
  }

  static void operator delete(void*) noexcept {
    if (--refcount == 0) {
      std::free(instance);
      instance = nullptr;
    }
  }

private:
  static void* instance = nullptr;
  static std::size_t refcount = 0;
};

Since standard C++ subsumes the C standard library, the C dynamic memory allocation routines malloc, calloc, realloc and free are also available to C++ programmers. The use of these routines is discouraged for most uses, since they do not perform object initialization and destruction.[5] new and delete were, in fact, introduced in the first version of C++ (then called "C with Classes") to avoid the necessity of manual object initialization.[4]

In contrast to the C routines, which allow growing or shrinking an allocated array with realloc, it is not possible to change the size of a memory buffer allocated by new[]. The C++ standard library instead provides a dynamic array (collection) that can be extended or reduced in its std::vector template class.

The C++ standard does not specify any relation between new/delete and the C memory allocation routines, but new and delete are typically implemented as wrappers around malloc and free.[6] Mixing the two families of operations, e.g., free'ing new'ly allocated memory or delete'ing malloc'd memory, causes undefined behavior and in practice can lead to various catastrophic results such as failure to release locks and thus deadlock.[7]

• Allocator (C++)
• Exception handling
• Memory pool
• Pointer (computer programming)
• Resource Acquisition Is Initialization (RAII)
• Smart pointers