Namespaces
Variants

std::ranges::uninitialized_default_construct

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 >
    requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_default_construct( I first, S last );
(1) (C++20以降)
(C++26以降 constexpr)
template< /*nothrow-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以降)
(C++26以降 constexpr)
template< /*execution-policy*/ Ep, /*nothrow-random-access-iterator*/ I,
          /*nothrow-sized-sentinel-for*/<I> S >
    requires std::default_initializable<std::iter_value_t<I>>
I uninitialized_default_construct( Ep&& policy, I first, S last );
(3) (C++26以降)
template< /*execution-policy*/ Ep, /*nothrow-sized-random-access-range*/ R >
    requires std::default_initializable<ranges::range_value_t<R>>
ranges::borrowed_iterator_t<R>
    uninitialized_default_construct( Ep&& policy, R&& r );
(4) (C++26以降)

/*execution-policy*/の定義については、このページを参照してください。その他の説明専用コンセプトの定義については、このページを参照してください。

1) 宛先範囲の要素を [first, last) によって デフォルト初期化 して次のように構築します

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

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

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

  • これらのいずれかを呼び出す際に、明示的なテンプレート引数リストを指定することはできません。
  • これらはすべて 引数依存の名前探索 からは見えません。
  • 関数呼び出し演算子の左側にある名前として 通常の非修飾名前探索 によってこれらのいずれかが見つかった場合、引数依存の名前探索 は抑制されます。

パラメータ

first, last - イテレータ-センチネルペアは、初期化する要素のrangeを定義する
r - 初期化する要素のrange
policy - 使用するexecution policy

戻り値

上記の通り。

例外

宛先範囲内の要素の構築時に投げられた例外はすべて伝播される。

3,4) 実行プロセス中:
  • 並列化に必要な一時メモリリソースが利用できない場合、std::bad_allocが投げられる。
  • アルゴリズムの引数を介してオブジェクトにアクセス中にキャッチされない例外が投げられた場合、動作は実行ポリシーによって決まる(標準ポリシーでは、 std::terminateが呼び出される)。

注記

実装は、std::iter_value_t<I>オブジェクトをデフォルト初期化する際に、非トリビアルなデフォルトコンストラクタが呼び出されない場合、オブジェクトの構築を(観測可能な効果を変更せずに)スキップすることがあります。これはstd::is_trivially_default_constructibleで検出できます。

機能テストマクロ 値 標準 機能
__cpp_lib_parallel_algorithm 202506L (C++26) 並列範囲アルゴリズム
__cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr用特殊化された<memory>アルゴリズム、(1,2)

考えられる実装

struct uninitialized_default_construct_fn
{
    template</*nothrow-forward-iterator*/ I, /*nothrow-sentinel-for*/<I> S>
        requires std::default_initializable<std::iter_value_t<I>>
    constexpr I operator()(I first, S last) const
    {
        using value_type = std::remove_reference_t<std::iter_reference_t<I>>;
        if constexpr (std::is_trivially_default_constructible_v<value_type>)
            return ranges::next(first, last); // skip initialization
        I rollback{first};
        try
        {
            for (; !(first == last); ++first)
                ::new (static_cast<void*>(std::addressof(*first))) value_type;
            return first;
        }
        catch (...) // rollback: destroy constructed elements
        {
            for (; rollback != first; ++rollback)
                ranges::destroy_at(std::addressof(*rollback));
            throw;
        }
    }
    
    template</*nothrow-forward-range*/ R>
        requires std::default_initializable<ranges::range_value_t<R>>
    constexpr ranges::borrowed_iterator_t<R> operator()(R&& r) const
    {
        return (*this)(ranges::begin(r),
                       ranges::next(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"; }
    // 注意: "trivial types" の場合、uninitialized_default_construct は
    // 一般的に指定された未初期化メモリ領域をゼロフィルしません。
    constexpr char sample[]{'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, sample, sizeof(v)) == 0)
    {
        std::cout << "  ";
        // 未定義動作の可能性あり、CWG 1997 の解決待ち:
        // for (const char c : v) { std::cout << c << ' '; }
        for (const char c : sample)
            std::cout << c << ' ';
    }
    else
        std::cout << "Unspecified\n";
}

出力例:

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

参照

オブジェクトを構築する、デフォルト初期化によって、開始位置と個数で定義されるメモリの初期化されていない領域内で
(アルゴリズム関数オブジェクト)
オブジェクトを構築する、値初期化によって、範囲で定義されるメモリの初期化されていない領域内で
(アルゴリズム関数オブジェクト)
オブジェクトを構築する、値初期化によって、開始位置と個数で定義されるメモリの初期化されていない領域内で
(アルゴリズム関数オブジェクト)
オブジェクトを構築する、デフォルト初期化によって、範囲で定義されるメモリの初期化されていない領域内で
(関数テンプレート)