Skip to content

Search topics & cppreference

Search all study topics, concept maps, and 6,587 C++ and C reference pages.

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

Let N be ranges::min(count, ranges::distance(ofirst, olast)).

Memory management
  • C++17
  • C++20
  • C++26
2 min readView on cppreference
NotebookLM
Defined in header <memory>
Call signature
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> count,
                          O ofirst, S olast );
(1) (since C++20)
(constexpr since C++26)
Helper types
template< class I, class O >
using uninitialized_move_n_result = ranges::in_out_result<I, O>;
(2) (since C++20)

Let N be ranges::min(count, ranges::distance(ofirst, olast)).

Copies N elements from the range beginning at ifirst (using move semantics if supported) to an uninitialized memory area [ofirst, olast) as if by 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};

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.

If [ofirst, olast) overlaps with ifirst + [​0​, count), the behavior is undefined.

The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:

Parameters

ifirst - the beginning of the input range of elements to move from
ofirst, olast - iterator-sentinel pair denoting the output range of elements to initialize
n - the number of elements to move

Return value

As described above.

Complexity

𝓞(N).

Exceptions

Any exception thrown on construction of the elements in the destination range.

Notes

An implementation may improve the efficiency of the ranges::uninitialized_move_n, e.g. by using ranges::copy_n, 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)

Possible implementation

snippet.cpp
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{};

Example

example.cpp
#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);
    }
}
Possible output
initially, in: "No" "Diagnostic" "Required"
after move, in: "" "" ""
after move, out: "No" "Diagnostic" "Required"

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

See also

moves a range of objects to an uninitialized area of memory
(algorithm function object)
moves a number of objects to an uninitialized area of memory
(function template)

Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.