Namespaces
Variants

std::ranges::uninitialized_fill

ja.cppreference.net から
 
 
アルゴリズムライブラリ
制約付きアルゴリズムとレンジアルゴリズム (C++20)
制約付きアルゴリズム、例: ranges::copy, ranges::sort, ...
ソートおよび関連操作
分割操作
(C++11)    

ソート操作
二分探索操作
(分割されたレンジに対する)
集合操作 (ソート済みレンジに対する)
マージ操作 (ソート済みレンジに対する)
ヒープ操作
最小/最大操作
(C++11)
(C++17)
辞書式比較操作
順列操作


 
 
ヘッダ <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以降)
(C++26以降constexpr)
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以降)
(C++26以降constexpr)
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) 宛先範囲 [firstlast) 内の要素を指定された値 value で、

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

を使用したかのように構築します 初期化中に例外がスローされた場合、既に構築されたオブジェクトは未規定の順序で破棄されます。
2) (1) と同じですが、宛先範囲として r を使用します。
3,4) (1,2) と同じですが、policy に従って実行されます。

このページで説明されている関数のようなエンティティは、アルゴリズム関数オブジェクト(非公式にはniebloidsと呼ばれます)です。つまり、

引数

first, last - 初期化する要素の範囲を定義するイテレータ-センチネルペア
r - 初期化する要素の範囲
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 ▄▀▄▀▄▀▄▀

関連項目

オブジェクトを、開始位置と個数で指定された未初期化メモリ領域にコピーする
(アルゴリズム関数オブジェクト)
オブジェクトを、範囲で指定された未初期化メモリ領域にコピーする
(関数テンプレート)