std::ranges::uninitialized_move_n() algorithm
- od C++20
- Simplified
- Detailed
// (1)
uninitialized_move_n_result<I, O>
uninitialized_move_n( I ifirst, std::iter_difference_t<I> n, O ofirst, S olast );
The type of arguments are generic and have following constraints:
I
-std::input_iterator
O
-no-throw-forward-iterator
S
-no-throw-sentinel-for<O>
Additionally, each overload has the following constraints:
- (1)
std::constructible_from<std::iter_value_t<O>, std::iter_rvalue_reference_t<I>>
// (1)
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>>
uninitialized_move_n_result<I, O>
uninitialized_move_n( I ifirst, std::iter_difference_t<I> n, O ofirst, S olast );
With the helper types defined as follows:
template< class I, class O >
using uninitialized_move_n_result = ranges::in_out_result<I, O>;
Given N
as min(n, ranges::distance(ofirst, olast))
:
Moves N
elements from the input range beginning at ifirst
to the uninitialized storage designated by the range [ofirst
; olast
)
The function has the effect equal to:
for (; n-- > 0 && ofirst != olast; ++ifirst, ++ofirst)
::new (static_cast<void*>(std::addressof(*first)))
std::remove_reference_t<std::iter_reference_t<O>>(ranges::iter_move(ifirst));
If an exception is thrown during the initialization then the objects that already constructed in [ofirst
; olast
) are destroyed in an unspecified order.
Also, the objects in the input range beginning at ifirst, that were already moved, are left in a valid but unspecified state.
The function-like entities described on this page are niebloids.
Parameters
ifirst | The beginning of the input range to move elements from. |
ofirst olast | The destination range to initialize. |
n | The number of elements to move. |
Return value
{
ifirst + N,
ofirst + N
}
Complexity
Linear in N
.
Exceptions
The exception thrown on construction of the elements in the destination range, if any.
Possible implementation
uninitialized_move_n(1)
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>>
ranges::uninitialized_move_n_result<I, O>
operator()(I ifirst, std::iter_difference_t<I> n, O ofirst, S olast) const
{
O current{ofirst};
try
{
for (; n-- > 0 && current != olast; ++ifirst, ++current)
::new (const_cast<void*>(static_cast<const volatile void*>
(std::addressof(*current)))) std::remove_reference_t<
std::iter_reference_t<O>>(ranges::iter_move_n(ifirst));
return {std::move_n(ifirst), std::move_n(current)};
}
catch (...) // rollback: destroy constructed elements
{
for (; ofirst != current; ++ofirst)
ranges::destroy_at(std::addressof(*ofirst));
throw;
}
}
};
inline constexpr uninitialized_move_n_fn uninitialized_move_n{};
Notes
An implementation may improve the efficiency of ranges::uninitialized_move_n
if the value type of the output range is TrivialType
.
Examples
#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_n, in: ", std::begin(in), std::end(in));
print("after move_n, out: ", first, last);
std::ranges::destroy(first, last);
}
catch (...)
{
std::cout << "Exception!\n";
}
std::free(out);
}
}
initially, in: "No" "Diagnostic" "Required"
after move_n, in: "" "" ""
after move_n, out: "No" "Diagnostic" "Required"
Hover to see the original license.