std::ranges::uninitialized_copy_n, std::ranges::uninitialized_copy_n_result

来自cppreference.com
< cpp‎ | memory
 
 
内存管理库
(仅用于阐述*)
分配器
未初始化内存算法
受约束的未初始化内存算法
内存资源
未初始化存储 (C++20 前)
(C++17 弃用)
(C++17 弃用)
垃圾收集器支持 (C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
 
在标头 <memory> 定义
调用签名
template< std::input_iterator I,

          no-throw-input-iterator O, no-throw-sentinel-for<O> S >
    requires std::constructible_from<std::iter_value_t<O>,
                                     std::iter_reference_t<I>>
uninitialized_copy_n_result<I, O>
    uninitialized_copy_n( I ifirst, std::iter_difference_t<I> count,

                          O ofirst, S olast );
(1)(C++20 起)
(C++26 起为 constexpr)
辅助类型
template< class I, class O >
using uninitialized_copy_n_result = ranges::in_out_result<I, O>;
(2)(C++20 起)

Nranges::min(count, ranges::distance(ofirst, olast))

如同用以下方式将始于 ifirst 的范围中的 N 个元素复制到未初始化内存区域 [ofirstolast)auto ret = ranges::uninitialized_copy(std::counted_iterator(std::move(ifirst), count),
                                      std::default_sentinel, ofirst, olast);
return {std::move(ret.in).base(), ret.out};

如果初始化中抛出了异常,那么以未指定的顺序销毁已构造的对象。

如果 [ofirstolast)ifirst + [0count) 有重叠,那么行为未定义。

此页面上描述的函数式实体是算法函数对象(非正式地称为 niebloid),即:

参数

ifirst-要复制的元素范围的起始
count-要复制的元素数
ofirst, olast-目标元素范围的迭代器-哨位对

返回值

如上所述。

复杂度

𝓞(N)

异常

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

注解

如果输出范围的值类型是平凡类型 (TrivialType) ,那么实现可能提升 ranges::uninitialized_copy_n 的效率,例如用 ranges::copy_n

功能特性测试标准功能特性
__cpp_lib_raw_memory_algorithms202411L(C++26)constexpr特化内存算法, (1)

可能的实现

struct uninitialized_copy_n_fn
{
    template<std::input_iterator I, no-throw-input-iterator O, no-throw-sentinel-for<O> S>
        requires std::constructible_from<std::iter_value_t<O>, std::iter_reference_t<I>>
    constexpr ranges::uninitialized_copy_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_copy(iter, std::default_sentinel, ofirst, olast);
        return {std::move(ret.in).base(), ret.out};
    }
};
 
inline constexpr uninitialized_copy_n_fn uninitialized_copy_n{};

示例

#include <iomanip>
#include <iostream>
#include <memory>
#include <string>
 
int main()
{
    const char* stars[]{"Procyon", "Spica", "Pollux", "Deneb", "Polaris"};
 
    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};
        auto ret{std::ranges::uninitialized_copy_n(std::begin(stars), n, first, last)};
 
        std::cout << '{';
        for (auto it{first}; it != ret.out; ++it)
            std::cout << (it == first ? "" : ", ") << std::quoted(*it);
        std::cout << "};\n";
 
        std::ranges::destroy(first, last);
    }
    catch (...)
    {
        std::cout << "uninitialized_copy_n 异常\n";
    }
}

输出:

{"Procyon", "Spica", "Pollux", "Deneb"};

参阅

复制范围中对象到未初始化内存
(算法函数对象)
复制若干对象到未初始化内存
(函数模板)