Почему в С++ 17 нет std::construct_at?

std::destroy_at обеспечивает два объективных улучшения по сравнению с прямым вызовом деструктора:

1. Это уменьшает избыточность:

    T *ptr = new T;
    //Insert 1000 lines of code here.
    ptr->~T(); //What type was that again?
   

   Конечно, мы все предпочли бы просто обернуть его в unique_ptr и покончить с этим, но если это не может произойти по какой-то причине, вставка T является элементом избыточности. Если мы изменим тип на U, нам придется изменить вызов деструктора, иначе все сломается. Использование std::destroy_at(ptr) устраняет необходимость изменять одно и то же в двух местах.

   СУХОЙ это хорошо.

2. Это легко:

    auto ptr = allocates_an_object(...);
    //Insert code here
    ptr->~???; //What type is that again?
   

   Если мы вывели тип указателя, то удалить его становится довольно сложно. Вы не можете сделать ptr->~decltype(ptr)(); так как анализатор С++ так не работает. Мало того, decltype выводит тип как указатель, поэтому вам нужно будет удалить косвенное указание указателя из выведенного типа. Приводит вас к:

    auto ptr = allocates_an_object(...);
    //Insert code here
    using delete_type = std::remove_pointer_t<decltype(ptr)>;
    ptr->~delete_type();
   

   И кто хочет напечатать это?

Напротив, ваше гипотетическое std::construct_at не обеспечивает целевых улучшений по сравнению с new. Вы должны указать тип, который вы создаете в обоих случаях. Параметры конструктору должны быть предоставлены в обоих случаях. Указатель на память должен быть предоставлен в обоих случаях.

Так что нет нужды решать ваш гипотетический std::construct_at.

И он объективно менее эффективен, чем новое размещение. Ты можешь это сделать:

auto ptr1 = new(mem1) T;
auto ptr2 = new(mem2) T{};

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

Ваш гипотетический std::construct_at не может позволить вам выбрать тот, который вы хотите. Он может иметь код, который выполняет инициализацию по умолчанию, если вы не укажете никаких параметров, но тогда он не сможет предоставить версию для инициализации значения. И он может инициализировать значение без параметров, но тогда вы не сможете инициализировать объект по умолчанию.

Обратите внимание, что C++20 добавил std::construct_at. Но это было сделано по причинам, отличным от согласованности. Они предназначены для поддержки выделения и построения памяти во время компиляции.

Вы можете вызвать заменяемые глобальные операторы new в постоянном выражении (если вы фактически не заменили его). Но Placement-new не является заменяемой функцией, поэтому вы не можете вызвать ее там.

Предыдущие версии предложения о распределении constexpr полагались на std::allocator_traits<std::allocator<T>>::construct/destruct. Позже они перешли к std::construct_at в качестве функции построения constexpr, на которую будет ссылаться construct.

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

Такая штука есть, но названа не так, как можно было бы ожидать:

• uninitialized_copy копирует диапазон объектов в неинициализированную область памяти.

• uninitialized_copy_n (C++11) копирует ряд объектов в неинициализированную область памяти (шаблон функции).

• uninitialized_fill копирует объект в неинициализированную область памяти, определяемую диапазоном (шаблон функции)

• uninitialized_fill_n копирует объект в неинициализированную область памяти, определяемую началом и количеством (шаблон функции)
• uninitialized_move (C++17) перемещает диапазон объектов в неинициализированную область памяти (шаблон функции).
• uninitialized_move_n (C++17) перемещает ряд объектов в неинициализированную область памяти (шаблон функции).
• uninitialized_default_construct (C++17) создает объекты с инициализацией по умолчанию в неинициализированной области памяти, определяемой диапазоном (шаблон функции).
• uninitialized_default_construct_n (C++17) создает объекты с помощью инициализации по умолчанию в неинициализированной области памяти, определяемой началом и количеством (шаблон функции)
• uninitialized_value_construct (C++17) создает объекты путем инициализации значения в неинициализированной области памяти, определяемой диапазоном (шаблон функции).
• uninitialized_value_construct_n (C++17) создает объекты путем инициализации значения в неинициализированной области памяти, определяемой началом и количеством

std::construct_at был добавлен в C++20. Документ, который сделал это, называется Больше контейнеров constexpr. Предположительно, это не имело достаточных преимуществ по сравнению с новым размещением в С++ 17, но С++ 20 меняет ситуацию.

Существует std::allocator_traits::construct. Раньше в std::allocator был еще один, но он был удален, обоснование в документ комитета по стандартам D0174R0.

Я думаю, что должна быть стандартная конструкция-функция. На самом деле в libc++ он есть в качестве детали реализации в файле stl_construct.h.

namespace std{
...
  template<typename _T1, typename... _Args>
    inline void
    _Construct(_T1* __p, _Args&&... __args)
    { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
...
}

Я думаю, что это что-то полезное, потому что это позволяет сделать «размещение нового» друга. Это отличная точка настройки для типа, предназначенного только для перемещения, которому требуется uninitialized_copy в куче по умолчанию (например, из элемента std::initializer_list).

У меня есть собственная библиотека контейнеров, которая повторно реализует detail::uninitialized_copy (диапазона) для использования пользовательского detail::construct:

namespace detail{
    template<typename T, typename... As>
    inline void construct(T* p, As&&... as){
        ::new(static_cast<void*>(p)) T(std::forward<As>(as)...);
    }
}

Который объявлен другом класса только для перемещения, чтобы разрешить копирование только в контексте размещения нового.

template<class T>
class my_move_only_class{
    my_move_only_class(my_move_only_class const&) = default;
    friend template<class TT, class...As> friend void detail::construct(TT*, As&&...);
public:
    my_move_only_class(my_move_only_class&&) = default;
    ...
};

construct, похоже, не дает никакого синтаксического сахара. К тому же это менее эффективно, чем размещение new. Привязка к ссылочным аргументам вызывает временную материализацию и дополнительную конструкцию перемещения/копирования:

struct heavy{
   unsigned char[4096];
   heavy(const heavy&);
};
heavy make_heavy(); // Return a pr-value
auto loc = ::operator new(sizeof(heavy));
// Equivalently: unsigned char loc[sizeof(heavy)];

auto p = construct<heavy>(loc,make_heavy()); // The pr-value returned by
         // make_heavy is bound to the second argument,
         // and then this arugment is copied in the body of construct.

auto p2 = new(loc) auto(make_heavy()); // Heavy is directly constructed at loc
       //... and this is simpler to write!

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

С другой стороны, construct_at в библиотеке может дополнять словарь стандартной библиотеки.