std::ranges::uninitialized_default_construct

Определено в заголовке <memory>

Подпись вызова

Определено в заголовке `<memory>`
Подпись вызова
template< no-throw-forward-iterator I, no-throw-sentinel-for<I> S > requires std::default_initializable<std::iter_value_t<I>> I uninitialized_default_construct( I first, S last );	(1)	(с C++20)
template< no-throw-forward-range R > requires std::default_initializable<ranges::range_value_t<R>> ranges::borrowed_iterator_t<R> uninitialized_default_construct( R&& r );	(2)	(с C++20)

template< no-throw-forward-iterator I, no-throw-sentinel-for<I> S >
requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_default_construct( I first, S last );

(1)

(с C++20)

template< no-throw-forward-range R >
requires std::default_initializable<ranges::range_value_t<R>>
ranges::borrowed_iterator_t<R>
uninitialized_default_construct( R&& r );

(2)

(с C++20)

1) Создаёт объекты типа std::iter_value_t<I> в неинициализированном хранилище, заданном диапазоном [first, last) путём инициализации по умолчанию, как если бы с помощью

for (; first != last; ++first)
    ::new (static_cast<void*>(std::addressof(*first)))
        std::remove_reference_t<std::iter_reference_t<I>>;

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

2) То же, что и (1), но использует r в качестве диапазона, как если бы использовалась ranges::begin(r) как first, и ranges::end(r) как last.

Функциональные сущности, описанные на этой странице, являются niebloids, то есть:

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

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

Параметры

first, last	-	пара итераторов-пределов, определяющая диапазон элементов для инициализации
r	-	диапазон элементов для инициализации

Возвращаемое значение

Итератор, равный last.

Сложность

Линейная по расстоянию между first и last.

Исключения

Исключение, сгенерированное при создании элементов в целевом диапазоне, если таковое имеется.

Примечания

Реализация может пропустить создание объектов (без изменения наблюдаемого эффекта), если при инициализации по умолчанию объекта std::iter_value_t<I> не вызывается никакой нетривиальный конструктор по умолчанию, что может быть обнаружено с помощью std::is_trivially_default_constructible_v.

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

struct uninitialized_default_construct_fn
{
    template<no-throw-forward-iterator I, no-throw-sentinel-for<I> S>
    requires std::default_initializable<std::iter_value_t<I>>
    I operator()(I first, S last) const
    {
        using ValueType = std::remove_reference_t<std::iter_reference_t<I>>;
        if constexpr (std::is_trivially_default_constructible_v<ValueType>)
            return ranges::next(first, last); // skip initialization
        I rollback{first};
        try
        {
            for (; !(first == last); ++first)
                ::new (const_cast<void*>(static_cast<const volatile void*>
                    (std::addressof(*first)))) ValueType;
            return first;
        }
        catch (...) // rollback: destroy constructed elements
        {
            for (; rollback != first; ++rollback)
                ranges::destroy_at(std::addressof(*rollback));
            throw;
        }
    }
 
    template<no-throw-forward-range R>
    requires std::default_initializable<ranges::range_value_t<R>>
    ranges::borrowed_iterator_t<R>
    operator()(R&& r) const
    {
        return (*this)(ranges::begin(r), ranges::end(r));
    }
};
 
inline constexpr uninitialized_default_construct_fn uninitialized_default_construct{};

Пример

#include <cstring>
#include <iostream>
#include <memory>
#include <string>
 
int main()
{
    struct S { std::string m{"▄▀▄▀▄▀▄▀"}; };
 
    constexpr int n{4};
    alignas(alignof(S)) char out[n * sizeof(S)];
 
    try
    {
        auto first{reinterpret_cast<S*>(out)};
        auto last{first + n};
 
        std::ranges::uninitialized_default_construct(first, last);
 
        auto count{1};
        for (auto it{first}; it != last; ++it)
            std::cout << count++ << ' ' << it->m << '\n';
 
        std::ranges::destroy(first, last);
    }
    catch (...) { std::cout << "Exception!\n"; }
 
    // Notice that for "trivial types" the uninitialized_default_construct
    // generally does not zero-fill the given uninitialized memory area.
    constexpr char etalon[]{'A', 'B', 'C', 'D', '\n'};
    char v[]{'A', 'B', 'C', 'D', '\n'};
    std::ranges::uninitialized_default_construct(std::begin(v), std::end(v));
    if (std::memcmp(v, etalon, sizeof(v)) == 0)
    {
        std::cout << "  ";
        // Maybe undefined behavior, pending CWG 1997:
        // for (const char c : v) { std::cout << c << ' '; }
        for (const char c : etalon)
            std::cout << c << ' ';
    }
    else
        std::cout << "Unspecified\n";
}

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

1 ▄▀▄▀▄▀▄▀
2 ▄▀▄▀▄▀▄▀
3 ▄▀▄▀▄▀▄▀
4 ▄▀▄▀▄▀▄▀
  A B C D

Отчёты об ошибках

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

DR	Применено к	Поведение, как опубликовано	Правильное поведение
LWG 3870	C++20	Этот алгоритм может создавать объекты в const хранилище	остаётся запрещённым

См. также

ranges::uninitialized_default_construct_n (C++20)	создаёт объекты путём инициализации по умолчанию в неинициализированной области памяти, определяемой началом и количеством (niebloid)
ranges::uninitialized_value_construct (C++20)	создаёт объекты путём инициализации значением в неинициализированной области памяти, определяемой диапазоном (niebloid)
ranges::uninitialized_value_construct_n (C++20)	создаёт объекты путём инициализации значением в неинициализированной области памяти, определяемой началом и количеством (niebloid)
uninitialized_default_construct (C++17)	создаёт объекты путём инициализации по умолчанию в неинициализированной области памяти, определяемой диапазоном (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/memory/ranges/uninitialized_default_construct