std::ranges::uninitialized_fill

Определено в заголовочном файле `<memory>`
Сигнатура вызова
template< /nothrow-forward-iterator/ I, /nothrow-sentinel-for/<I> S, class T > requires std::constructible_from<std::iter_value_t<I>, const T&> I uninitialized_fill( I first, S last, const T& value );	(1)	(начиная с C++20) (constexpr начиная с C++26)
template< /nothrow-forward-range/ R, class T > requires std::constructible_from<ranges::range_value_t<R>, const T&> ranges::borrowed_iterator_t<R> uninitialized_fill( R&& r, const T& value );	(2)	(начиная с C++20) (constexpr начиная с C++26)
template< /execution-policy/ Ep, /nothrow-random-access-iterator/ I, /nothrow-sized-sentinel-for/<I> S, class T = std::iter_value_t<I> > requires constructible_from<std::iter_value_t<I>, const T&> I uninitialized_fill( Ep&& policy, I first, S last, const T& value );	(3)	(начиная с C++26)
template< /execution-policy/ Ep, /nothrow-sized-random-access-range/ R, class T = ranges::range_value_t<R> > requires std::constructible_from<ranges::range_value_t<R>, const T&> ranges::borrowed_iterator_t<R> uninitialized_fill( Ep&& policy, R&& r, const T& value );	(4)	(начиная с C++26)

Определение /*execution-policy*/ см. на этой странице; определения других понятий, используемых только для описания, см. на этой странице.

1) Создаёт элементы в целевом диапазоне [first, last) со значением value, как если бы выполнялось

for(;first!=last;++first) ::new(voidify(*first))std::remove_reference_t<std::iter_reference_t<I>>(value); returnfirst;

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

2) То же, что и (1), но в качестве целевого диапазона используется r.

3,4) То же, что и (1,2), но выполнение производится согласно policy.

Описанные на этой странице функциональные объекты являются функциональными объектами алгоритмов (неофициально называемыми niebloids), то есть:

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

Параметры

first, last	-	пара итератора и сентинела, задающая диапазон элементов для инициализации
r	-	`range` элементов для инициализации
value	-	значение, которым инициализируются элементы
policy	-	политика выполнения

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

Как описано выше.

Исключения

Любое исключение, возникшее при создании элементов в целевом диапазоне.

3,4) В процессе выполнения:

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

Примечания

Реализация может повысить эффективность ranges::uninitialized_fill (например, используя ranges::fill), если тип значения выходного диапазона является TrivialType.

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

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

struct uninitialized_fill_fn
{
    template</*nothrow-forward-iterator*/ I, /*nothrow-sentinel-for*/<I> S, class T>
        requires std::constructible_from<std::iter_value_t<I>, const T&>
    constexpr I operator()(I first, S last, const T& value) const
    {
        I rollback{first};
        try
        {
            for (; !(first == last); ++first)
                ranges::construct_at(std::addressof(*first), value);
            return first;
        }
        catch (...)
        {   
            // rollback: destroy constructed elements
            for (; rollback != first; ++rollback)
                ranges::destroy_at(std::addressof(*rollback));
            throw;
        }
    }

    template</*nothrow-forward-range*/ R, class T>
        requires std::constructible_from<ranges::range_value_t<R>, const T&>
    constexpr ranges::borrowed_iterator_t<R> operator()(R&& r, const T& value) const
    {
        return (*this)(ranges::begin(r),
                       ranges::next(ranges::begin(r), ranges::end(r)), value);
    }
};

inline constexpr uninitialized_fill_fn uninitialized_fill{};

Пример

#include <iostream>
#include <memory>
#include <string>

int main()
{
    constexpr int n{4};
    alignas(alignof(std::string)) char out[n * sizeof(std::string)];
    
    try
    {
        auto first{reinterpret_cast<std::string*>(out)};
        auto last{first + n};
        std::ranges::uninitialized_fill(first, last, "▄▀▄▀▄▀▄▀");
        
        int count{1};
        for (auto it{first}; it != last; ++it)
            std::cout << count++ << ' ' << *it << '\n';
        
        std::ranges::destroy(first, last);
    }
    catch(...)
    {
        std::cout << "Exception!\n";
    }
}

Вывод:

1 ▄▀▄▀▄▀▄▀
2 ▄▀▄▀▄▀▄▀
3 ▄▀▄▀▄▀▄▀
4 ▄▀▄▀▄▀▄▀

См. также

ranges::uninitialized_fill_n (C++20)	копирует объект в неинициализированную область памяти, заданную началом и количеством элементов (функциональный объект алгоритма)
uninitialized_fill	копирует объект в неинициализированную область памяти, заданную диапазоном (шаблон функции)

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