Передача нулевого указателя на размещение нового

Размещение по умолчанию new Оператор объявлен в 18.6 [support.dynamic] ¶1 с ненулевой спецификацией исключения:

void* operator new (std::size_t size, void* ptr) noexcept;

Эта функция не делает ничего, кроме return ptr; поэтому разумно noexceptоднако в соответствии с 5.3.4 [expr.new] this15 это означает, что компилятор должен проверить, что он не возвращает null, прежде чем вызывать конструктор объекта:

-15-
[Замечания: если функция распределения не объявлена ​​со спецификацией исключения без отбрасывания (15.4), это указывает на сбой в распределении памяти, выбрасывая std::bad_alloc исключение (пункт 15, 18.6.2.1); в противном случае он возвращает ненулевой указатель. Если функция выделения объявлена ​​со спецификацией исключения без отбрасывания, она возвращает ноль, чтобы указать на неудачу в выделении памяти, и ненулевой указатель в противном случае. —Конечная записка] Если функция выделения возвращает ноль, инициализация не должна выполняться, функция освобождения не должна вызываться, а значение нового выражения должно быть нулевым.

Мне кажется, что (специально для размещения new, не в общем) эта нулевая проверка — неудачный удар по производительности, хотя и небольшой.

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

Поэтому мне было интересно, действительно ли для размещения требуется нулевая проверка new дело. Единственный способ, которым он может возвратить нуль, — это передать ему ноль. Хотя возможно и, по-видимому, законно, написать:

void* ptr = nullptr;
Obj* obj = new (ptr) Obj();
assert( obj == nullptr );

Я не могу понять, почему это было бы полезно, я полагаю, что было бы лучше, если бы программисту пришлось явно проверять нулевое значение перед использованием размещения new например

Obj* obj = ptr ? new (ptr) Obj() : nullptr;

Кто-нибудь когда-либо нуждался в размещении new правильно обрабатывать случай нулевого указателя? (т.е. без добавления явной проверки, что ptr является допустимым местом в памяти.)

Мне интересно, было бы разумно запретить передачу нулевого указателя на размещение по умолчанию new функции, и если нет, то есть ли какой-нибудь лучший способ избежать ненужной ветви, кроме попытки сообщить компилятору, что значение не равно нулю, например

void* ptr = getAddress();
(void) *(Obj*)ptr;   // inform the optimiser that dereferencing pointer is valid
Obj* obj = new (ptr) Obj();

Или же:

void* ptr = getAddress();
if (!ptr)
__builtin_unreachable();  // same, but not portable
Obj* obj = new (ptr) Obj();

Нотабене Этот вопрос намеренно помечен микро-оптимизации, я не предполагая, что вы обходите место перегрузки new для всех ваших типов, чтобы «улучшить» производительность. Этот эффект был замечен в очень специфическом критическом случае производительности и основан на профилировании и измерении.

Обновить: DR 1748 делает неопределенным поведение использовать нулевой указатель с новым размещением, поэтому компиляторам больше не требуется выполнять проверку.