Оператор new

Создаёт и инициализирует объекты с динамическим сроком жизни, то есть объекты, чья продолжительность существования не обязательно ограничена областью видимости, в которой они были созданы.

Синтаксис

Объяснение

Оператор new пытается выделить память, а затем пытается создать и инициализировать либо один безымянный объект, либо безымянный массив объектов в выделенной памяти. Оператор new возвращает указатель-значение-только на созданный объект или, если был создан массив объектов, указатель на начальный элемент массива.

Синтаксис (1) или (3) требуется, если тип включает скобки:

new int(*[10])();    // error: parsed as (new int) (*[10]) ()
new (int (*[10])()); // okay: allocates an array of 10 pointers to functions

Кроме того, тип анализируется жадно: он будет включать каждый токен, который может быть частью декларатора:

new int + 1; // okay: parsed as (new int) + 1, increments a pointer returned by new int
new int * 1; // error: parsed as (new int*) (1)

Инициализатор инициализатор не является необязательным, если

• тип является массивом неизвестной размерности,

double* p = new double[]{1, 2, 3}; // creates an array of type double[3]
auto p = new auto('c');            // creates a single object of type char. p is a char*
 
auto q = new std::integral auto(1);         // OK: q is an int*
auto q = new std::floating_point auto(true) // ERROR: type constraint not satisfied
 
auto r = new std::pair(1, true); // OK: r is a std::pair<int, bool>*
auto r = new std::vector;        // ERROR: element type can't be deduced

Динамические массивы

Если тип является типом массива, все измерения, кроме первого, должны быть указаны как положительные целые константные выражения(до C++14)конвертируемые константные выражения типа std::size_t(с C++14), но (только при использовании синтаксисов без скобок (2) и (4)) первое измерение может быть выражением целочисленного типа, типа перечисления или типа класса с одной функцией неявного преобразования в целочисленный или тип перечисления(до C++14)любым выражением, преобразуемым к std::size_t(с C++14). Это единственный способ непосредственно создать массив с размером, определяемым во время выполнения, такие массивы часто называют динамическими массивами:

int n = 42;
double a[n][5]; // error
auto p1 = new  double[n][5];  // OK
auto p2 = new  double[5][n];  // error: only the first dimension may be non-constant
auto p3 = new (double[n][5]); // error: syntax (1) cannot be used for dynamic arrays

Первое измерение нуля допустимо, и функция выделения памяти вызывается.

Выделение памяти

Оператор new выделяет память, вызывая соответствующую функцию выделения. Если тип является типом без массива, имя функции — operator new. Если тип является типом массива, имя функции — operator new[].

Как описано в функции выделения, программа C++ может предоставить глобальные и специфичные для класса замены для этих функций. Если оператор new начинается с необязательного :: оператора, как в ::new T или ::new T[n], специфичные для класса замены будут проигнорированы (функция ищется в глобальной области видимости). В противном случае, если T является типом класса, поиск начинается в области видимости класса T.

При вызове функции выделения оператор new передает количество затребованных байтов в качестве первого аргумента типа std::size_t, которое равно точно sizeof(T) для типов без массива T.

Выделение памяти массива может использовать неопределённые накладные расходы, которые могут варьироваться от одного вызова new к другому, если только выбранная функция выделения не является стандартной, не требующей выделения. Указатель, возвращаемый выражением new, будет смещён на это значение относительно указателя, возвращённого функцией выделения. Многие реализации используют накладные расходы массива для хранения количества объектов в массиве, которое используется выражением delete[] для вызова соответствующего количества деструкторов. Кроме того, если выражение new используется для выделения массива char, unsigned char, или std::byte(с C++17), может потребоваться дополнительная память от функции выделения, если необходимо, чтобы гарантировать правильное выравнивание объектов всех типов не больше, чем запрошенный размер массива, если позже один из них будет помещён в выделенный массив.

Размещающее new

Если предоставлены placement-args, они передаются функции выделения в качестве дополнительных аргументов. Такие функции выделения известны как "размещающее new", по аналогии со стандартной функцией выделения void* operator new(std::size_t, void*), которая просто возвращает свой второй аргумент без изменений. Это используется для создания объектов в выделенном хранилище:

// within any block scope...
{
    // Statically allocate the storage with automatic storage duration
    // which is large enough for any object of type “T”.
    alignas(T) unsigned char buf[sizeof(T)];
 
    T* tptr = new(buf) T; // Construct a “T” object, placing it directly into your 
                          // pre-allocated storage at memory address “buf”.
 
    tptr->~T();           // You must **manually** call the object's destructor
                          // if its side effects is depended by the program.
}                         // Leaving this block scope automatically deallocates “buf”.

Примечание: эта функциональность инкапсулирована в методы класса Allocator.

new T;      // calls operator new(sizeof(T))
            // (C++17) or operator new(sizeof(T), std::align_val_t(alignof(T))))
new T[5];   // calls operator new[](sizeof(T)*5 + overhead)
            // (C++17) or operator new(sizeof(T)*5+overhead, std::align_val_t(alignof(T))))
new(2,f) T; // calls operator new(sizeof(T), 2, f)
            // (C++17) or operator new(sizeof(T), std::align_val_t(alignof(T)), 2, f)

Если функция выделения, не выбрасывающая исключения (например, выбранная new(std::nothrow) T) возвращает нулевой указатель из-за ошибки выделения, то выражение new возвращается немедленно, оно не пытается инициализировать объект или вызвать функцию освобождения памяти. Если в качестве аргумента передаётся нулевой указатель для выражения размещающего new, не требующего выделения, что заставляет выбранную стандартную нетребующую выделения размещающую функцию выделения возвращать нулевой указатель, поведение не определено.

Инициализация

Объект, созданный выражением new, инициализируется в соответствии со следующими правилами.

Если type не является типом массива, одиночный объект создаётся в выделенном блоке памяти:

• Если new-initializer отсутствует, объект инициализируется по умолчанию.
• Если new-initializer представляет собой список выражений в скобках, объект инициализируется непосредственно.

Если type является типом массива, инициализируется массив объектов:

• Если new-initializer отсутствует, каждый элемент инициализируется по умолчанию.
• Даже если первая размерность равна нулю, семантические ограничения инициализации по умолчанию гипотетического элемента всё равно должны быть соблюдены.
• Если new-initializer представляет собой пару скобок, каждый элемент инициализируется значением по умолчанию.
• Даже если первая размерность равна нулю, семантические ограничения инициализации значением по умолчанию гипотетического элемента всё равно должны быть соблюдены.

Ошибка инициализации

Если инициализация завершается сбросом исключения (например, из конструктора), программа ищет соответствующую функцию освобождения памяти, затем:

• Если подходящая функция освобождения найдена, функция освобождения вызывается для освобождения памяти, в которой был создан объект. После этого исключение продолжает распространяться в контексте выражения new.
• Если подходящая функция освобождения не найдена, распространение исключения не приводит к освобождению памяти объекта. Это уместно только если функция выделения не выделяет память, иначе это может привести к утечке памяти.

Область поиска соответствующей функции освобождения определяется следующим образом:

• Если выражение new не начинается с ::, и тип выделенного объекта является либо типом класса T или массивом типа класса T, поиск выполняется в пространстве имен класса T.
• В противном случае, или если ничего не найдено в пространстве имен класса T, имя функции освобождения ищется в глобальном пространстве имён.

Для функции выделения, не требующей размещения, используется обычный поиск функции освобождения для поиска соответствующей функции освобождения (см. выражение delete).

Для размещающей функции выделения, соответствующая функция освобождения должна иметь то же количество параметров, и каждый тип параметра, кроме первого, должен быть идентичен соответствующему типу параметра функции выделения (после преобразования типов параметров).

• Если поиск находит единственную соответствующую функцию освобождения, эта функция будет вызвана; в противном случае функция освобождения не будет вызвана.
• Если поиск находит функцию освобождения, не требующую размещения, и эта функция, рассматриваемая как размещающая функция освобождения, была бы выбрана в качестве совпадения для функции выделения, программа некорректна.

В любом случае, соответствующая функция освобождения (если она есть) должна быть не удалённой и(с C++11) доступной из точки, где появляется выражение new.

struct S
{
    // Placement allocation function:
    static void* operator new(std::size_t, std::size_t);
 
    // Non-placement deallocation function:
    static void operator delete(void*, std::size_t);
};
 
S* p = new (0) S; // error: non-placement deallocation function matches
                  //        placement allocation function

Если функция освобождения вызывается в выражении new (из-за ошибки инициализации), аргументы, передаваемые этой функции, определяются следующим образом:

• Первый аргумент — значение (типа void*) возвращённое вызовом функции выделения.
• Другие аргументы (только для размещающих функций освобождения) — placement-args, переданные размещающей функции выделения.

Если реализация разрешена вводить временный объект или создавать копию любого аргумента в рамках вызова функции выделения, не определено, используется ли тот же объект в вызове как функции выделения, так и функции освобождения.

Утечки памяти

Объекты, созданные выражениями new (объекты со временем хранения во время выполнения), существуют до тех пор, пока указатель, возвращённый выражением new, не будет использован в соответствующем выражении delete. Если исходное значение указателя потеряно, объект становится недоступным и не может быть освобождён: возникает утечка памяти.

Это может произойти, если указатель присваивается:

int* p = new int(7); // dynamically allocated int with value 7
p = nullptr; // memory leak

или если указатель выходит из области видимости:

void f()
{
    int* p = new int(7);
} // memory leak

или из-за исключения:

void f()
{
    int* p = new int(7);
    g();      // may throw
    delete p; // okay if no exception
} // memory leak if g() throws

Для упрощения управления динамически выделенными объектами, результат выражения new часто хранится в умном указателе: std::auto_ptr (до C++17)std::unique_ptr, или std::shared_ptr(с C++11). Эти указатели гарантируют, что выражение delete выполняется в ситуациях, показанных выше.

Ключевые слова

new

Примечания

Itanium C++ ABI требует, чтобы накладные расходы на выделение массива были равны нулю, если тип элементов создаваемого массива тривиально разрушаем. То же самое относится к MSVC.

Некоторые реализации (например, MSVC до VS 2019 v16.7) требуют ненулевых накладных расходов на выделение массива при использовании non-allocating placement array new, если тип элемента не тривиально разрушаем, что больше не соответствует стандарту с момента задачи CWG 2382.

Выражение non-allocating placement array new, создающее массив unsigned char, или std::byte(с C++17) может использоваться для неявного создания объектов в заданном регионе памяти: оно завершает жизненный цикл объектов, перекрывающихся с массивом, и затем неявно создаёт объекты с неявным жизненным циклом в массиве.

std::vector предлагает аналогичную функциональность для одномерных динамических массивов.

Отчеты о дефектах

Следующие отчеты о дефектах, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

См. также

• конструктор
• исключение копирования
• конструктор по умолчанию
• delete
• деструктор
• инициализация
  • инициализация агрегатов
  • инициализация по умолчанию
  • прямая инициализация
  • инициализация списком
  • инициализация значением