std::ranges:: uninitialized_move_n, std::ranges:: uninitialized_move_n_result

令 \(\scriptsize N\) N 为 ranges:: min ( count, ranges:: distance ( ofirst, olast ) ) 。

将始于 ifirst 的范围中的 \(\scriptsize N\) N 个元素（若支持则使用移动语义）复制到未初始化的内存区域 [ ofirst , olast ) ，其效果等同于执行： auto ret = ranges:: uninitialized_move ( std:: counted_iterator ( std :: move ( ifirst ) , count ) ,
std:: default_sentinel , ofirst, olast ) ;
return { std :: move ( ret. in ) . base ( ) , ret. out } ;

如果在初始化过程中抛出异常，那么已经在 [ ofirst , olast ) 范围内构造的对象将以未指定的顺序被销毁。同时，从 ifirst 开始的输入范围内已被移动的对象将处于有效但未指定的状态。

如果 [ ofirst , olast ) 与 ifirst + [ ​ 0 ​ , count ) 存在重叠，则行为未定义。

本页面描述的函数式实体是 算法函数对象 （非正式称为 niebloids ），即：

• 在调用其中任何一个时，都不能指定显式模板实参列表。
• 它们对 实参依赖查找 不可见。
• 当通过 普通非限定查找 在函数调用运算符左侧发现其中任何名称时，将抑制 实参依赖查找 。

参数

返回值

如上所述。

复杂度

\(\scriptsize\mathcal{O}(N)\) 𝓞(N) 。

异常

在目标范围元素构造过程中抛出的任何异常。

注释

当输出范围的 值类型 为平凡类型时，实现可以通过使用 ranges::copy_n 等方式来提升 ranges::uninitialized_move_n 的执行效率。

可能的实现

struct uninitialized_move_n_fn
{
    template<std::input_iterator I,
             no-throw-forward-iterator O, no-throw-sentinel-for<O> S>
        requires std::constructible_from<std::iter_value_t<O>,
                                         std::iter_rvalue_reference_t<I>>
    constexpr ranges::uninitialized_move_n_result<I, O>
        operator()(I ifirst, std::iter_difference_t<I> count, O ofirst, S olast) const
    {
        auto iter = std::counted_iterator(std::move(ifirst), count);
        auto ret = ranges::uninitialized_move(iter, std::default_sentinel, ofirst, olast);
        return {std::move(ret.in).base(), ret.out};
    }
};
inline constexpr uninitialized_move_n_fn uninitialized_move_n{};

示例

#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <memory>
#include <string>
void print(auto rem, auto first, auto last)
{
    for (std::cout << rem; first != last; ++first)
        std::cout << std::quoted(*first) << ' ';
    std::cout << '\n';
}
int main()
{
    std::string in[]{ "No", "Diagnostic", "Required", };
    print("initially, in: ", std::begin(in), std::end(in));
    if (
        constexpr auto sz = std::size(in);
        void* out = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz)
    )
    {
        try
        {
            auto first{static_cast<std::string*>(out)};
            auto last{first + sz};
            std::ranges::uninitialized_move_n(std::begin(in), sz, first, last);
            print("after move, in: ", std::begin(in), std::end(in));
            print("after move, out: ", first, last);
            std::ranges::destroy(first, last);
        }
        catch (...)
        {
            std::cout << "Exception!\n";
        }
        std::free(out);
    }
}

initially, in: "No" "Diagnostic" "Required"
after move, in: "" "" ""
after move, out: "No" "Diagnostic" "Required"

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的C++标准。

参见