std::ranges::uninitialized_copy, std::ranges::uninitialized_copy_result
<memory>
no-throw-forward-iterator O, no-throw-sentinel-for<O> S2 >
requires std::constructible_from <std::iter_value_t <O>,
std::iter_reference_t <I>>
uninitialized_copy_result<I, O>
(constexpr since C++26)
requires std::constructible_from <ranges::range_value_t <OR>,
ranges::range_reference_t <IR>>
uninitialized_copy_result<ranges::borrowed_iterator_t <IR>,
ranges::borrowed_iterator_t <OR>>
(constexpr since C++26)
using uninitialized_copy_result = ranges::in_out_result <I, O>;
Let \(\scriptsize N\)N be ranges::min (ranges::distance (ifirst, ilast), ranges::distance (ofirst, olast)).
[
ifirst,
ilast)
to an uninitialized memory area [
ofirst,
olast)
as if by
for (; ifirst != ilast && ofirst != olast; ++ofirst, (void)++ifirst)
::new (voidify (*ofirst)) std::remove_reference_t <std::iter_reference_t <O>>(*ifirst);
return {std::move(ifirst), ofirst};
[
ofirst,
olast)
overlaps with [
ifirst,
ilast)
, the behavior is undefined.ranges::begin (out_range), ranges::end (out_range));.
The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:
- Explicit template argument lists cannot be specified when calling any of them.
- None of them are visible to argument-dependent lookup.
- When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.
Contents
[edit] Parameters
range
of elements to copy from
range
[edit] Return value
As described above.
[edit] Complexity
\(\scriptsize\mathcal{O}(N)\)O(N).
[edit] Exceptions
Any exception thrown on construction of the elements in the destination range.
[edit] Notes
An implementation may improve the efficiency of ranges::uninitialized_copy
if the value type of the output range is TrivialType.
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr for specialized memory algorithms, (1,2) |
[edit] Possible implementation
struct uninitialized_copy_fn { template<std::input_iterator I, std::sentinel_for <I> S1, no-throw-forward-iterator O, no-throw-sentinel-for<O> S2> requires std::constructible_from <std::iter_value_t <O>, std::iter_reference_t <I>> constexpr ranges::uninitialized_copy_result<I, O> operator()(I ifirst, S1 ilast, O ofirst, S2 olast) const { O current{ofirst}; try { for (; !(ifirst == ilast or current == olast); ++ifirst, ++current) ranges::construct_at (std::addressof (*current), *ifirst); return {std::move(ifirst), std::move(current)}; } catch (...) // rollback: destroy constructed elements { for (; ofirst != current; ++ofirst) ranges::destroy_at (std::addressof (*ofirst)); throw; } } template<ranges::input_range IR, no-throw-forward-range OR> requires std::constructible_from <ranges::range_value_t <OR>, constexpr ranges::range_reference_t <IR>> ranges::uninitialized_copy_result<ranges::borrowed_iterator_t <IR>, ranges::borrowed_iterator_t <OR>> operator()(IR&& in_range, OR&& out_range) const { return (*this)(ranges::begin (in_range), ranges::end (in_range), ranges::begin (out_range), ranges::end (out_range)); } }; inline constexpr uninitialized_copy_fn uninitialized_copy{};
[edit] Example
#include <cstdlib> #include <iomanip> #include <iostream> #include <memory> #include <string> int main() { const char* v[]{"This", "is", "an", "example"}; if (const auto sz{std::size (v)}; void* pbuf = std::aligned_alloc (alignof(std::string ), sizeof(std::string ) * sz)) { try { auto first{static_cast<std::string *>(pbuf)}; auto last{first + sz}; std::ranges::uninitialized_copy(std::begin (v), std::end (v), first, last); std::cout << "{"; for (auto it{first}; it != last; ++it) std::cout << (it == first ? "" : ", ") << std::quoted (*it); std::cout << "};\n"; std::ranges::destroy (first, last); } catch (...) { std::cout << "uninitialized_copy exception\n"; } std::free (pbuf); } }
Output:
{"This", "is", "an", "example"};
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 3870 | C++20 | this algorithm might create objects on a const storage | kept disallowed |
[edit] See also
(algorithm function object)[edit]