Namespaces
Variants

std::uninitialized_default_construct

С ru.cppreference.net
 
 
Библиотека алгоритмов
Ограниченные алгоритмы и алгоритмы над диапазонами (C++20)
Ограниченные алгоритмы, например ranges::copy, ranges::sort, ...
Операции последовательности, не изменяющие её    
Пакетные операции
(C++17)
Операции поиска
Операции последовательности, изменяющие её
Операции копирования
(C++11)
(C++11)
Операции обмена
Операции преобразования
Операции генерации
Операции удаления
Операции изменения порядка
(до C++17)(C++11)
(C++20)(C++20)
Операции выборки
(C++17)

Сортировка и связанные операции
Операции разделения
(C++11)    

Операции сортировки
Операции бинарного поиска
(на разделённых диапазонах)
Операции над множествами (на отсортированных диапазонах)
Операции слияния (на отсортированных диапазонах)
Операции с кучей
Операции минимума/максимума
(C++11)
(C++17)
Операции лексикографического сравнения
Операции перестановки


Стратегии выполнения (C++17)
(только для демонстрации*)(C++26)

Численные операции
(C++11)
(C++17)
(C++17)    

Специализированные <memory> алгоритмы

Специализированные <random> алгоритмы
Библиотека C









 
Специализированные <memory> алгоритмы
 
Определён в заголовке <memory>
template< class NoThrowForwardIt >
void uninitialized_default_construct( NoThrowForwardIt first,
                                      NoThrowForwardIt last );
(1) (начиная с C++17)
(constexpr начиная с C++26)
template< class ExecutionPolicy, class NoThrowForwardIt >
void uninitialized_default_construct( ExecutionPolicy&& policy,
                                      NoThrowForwardIt first,
                                      NoThrowForwardIt last );
(2) (начиная с C++17)
1) Создаёт элементы в целевом диапазоне [first, last) посредством инициализации по умолчанию как если бы

for (; first != last; ++first)
    ::new (voidify(*first))
        typename std::iterator_traits<NoThrowForwardIt>::value_type;

Если во время инициализации выбрасывается исключение, уже созданные объекты уничтожаются в неопределённом порядке.
2) То же, что и (1), но выполняется в соответствии с policy.
Эта перегрузка участвует в разрешении перегрузок только если значение следующего выражения равно true:

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

(до C++20)

std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

(начиная с C++20)

Параметры

first, last - пара итераторов, определяющих диапазон элементов для инициализации
policy - политика выполнения для использования
Требования к типам
-
NoThrowForwardIt должен удовлетворять требованиям LegacyForwardIterator .
-
Ни инкремент, ни присваивание, ни сравнение, ни разыменование корректных экземпляров NoThrowForwardIt не должны выбрасывать исключения.

Исключения

2) Во время процесса выполнения:
  • Если временные ресурсы памяти, необходимые для распараллеливания, недоступны, std::bad_alloc выбрасывается.
  • Если необработанное исключение выбрасывается при доступе к объектам через аргумент алгоритма, поведение определяется политикой выполнения (для стандартных политик вызывается std::terminate).

Примечания

Проверка возможности макрос Значение Стандарт Возможность
__cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr для специализированных <memory>алгоритмов, (1)

Возможная реализация

template<class NoThrowForwardIt>
constexpr void uninitialized_default_construct(NoThrowForwardIt first,
                                               NoThrowForwardIt last)
{
    using Value = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = first;
    try
    {
        for (; current != last; ++current)
        {
            ::new (static_cast<void*>(std::addressof(*current))) Value;
        }
    }
    catch (...)
    {
        std::destroy(first, current);
        throw;
    }
}

Пример

#include <cstring>
#include <iostream>
#include <memory>
#include <string>
struct S
{
    std::string m{"Default value"};
};
int main()
{
    constexpr int n{3};
    alignas(alignof(S)) unsigned char mem[n * sizeof(S)];
    try
    {
        auto first{reinterpret_cast<S*>(mem)};
        auto last{first + n};
        std::uninitialized_default_construct(first, last);
        for (auto it{first}; it != last; ++it)
            std::cout << it->m << '\n';
        std::destroy(first, last);
    }
    catch (...)
    {
        std::cout << "Exception!\n";
    }
    // Для скалярных типов uninitialized_default_construct
    // обычно не заполняет нулями указанную неинициализированную область памяти.
    int v[]{1, 2, 3, 4};
    const int original[]{1, 2, 3, 4};
    std::uninitialized_default_construct(std::begin(v), std::end(v));
    // Возможно неопределенное поведение, ожидается разрешение CWG 1997.
    // for (const int i : v)
    //     std::cout << i << ' ';
    // Результат не определен.
    std::cout <<
        (std::memcmp(v, original, sizeof(v)) == 0 ? "Unmodified\n" : "Modified\n");
}

Возможный вывод:

Default value
Default value
Default value
Unmodified

Смотрите также

создаёт объекты с помощью default-initialization в неинициализированной области памяти, заданной началом и количеством
(шаблон функции)
создаёт объекты с помощью value-initialization в неинициализированной области памяти, заданной диапазоном
(шаблон функции)
создаёт объекты с помощью default-initialization в неинициализированной области памяти, заданной диапазоном
(функциональный объект алгоритма)