std::ranges::uninitialized_move, std::ranges::uninitialized_move_result

Определено в заголовке `<memory>`
Подпись вызова
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_rvalue_reference_t<I>> uninitialized_move_result<I, O> uninitialized_move( I ifirst, S1 ilast, O ofirst, S2 olast );	(1)	(с C++20)
template< ranges::input_range IR, no-throw-forward-range OR > requires std::constructible_from<ranges::range_value_t<OR>, ranges::range_rvalue_reference_t<IR>> uninitialized_move_result<ranges::borrowed_iterator_t<IR>, ranges::borrowed_iterator_t<OR>> uninitialized_move( IR&& in_range, OR&& out_range );	(2)	(с C++20)
Вспомогательные типы
template< class I, class O > using uninitialized_move_result = ranges::in_out_result<I, O>;	(3)	(с C++20)

1) Перемещает N элементы из входного диапазона [ifirst, ilast) в выходной диапазон [ofirst, olast) (это область неинициализированной памяти), где N является min(ranges::distance(ifirst, ilast), ranges::distance(ofirst, olast)).

Эффект эквивалентен:

for (; ifirst != ilast && ofirst != olast; ++ofirst, ++ifirst)
    ::new (static_cast<void*>(std::addressof(*ofirst)))
        std::remove_reference_t<std::iter_reference_t<O>>(ranges::iter_move(ifirst));

Если во время инициализации возникает исключение, то объекты, которые уже были созданы в [ofirst, olast) , уничтожаются в неопределенном порядке. Кроме того, объекты в [ifirst, ilast) , которые уже были перемещены, остаются в корректном, но неопределенном состоянии.

2) То же, что и (1), но использует in_range в качестве первого диапазона и out_range в качестве второго диапазона, как если бы использовали ranges::begin(in_range) в качестве ifirst, ranges::end(in_range) в качестве ilast, ranges::begin(out_range) в качестве ofirst, и ranges::end(out_range) в качестве olast.

Функциональные сущности, описанные на этой странице, являются niebloids, то есть:

Явные списки шаблонов аргументов не могут быть указаны при вызове любого из них.
Ни один из них не виден для поиска зависимого от аргументов.
Когда любой из них найден обычным неопределённым поиском как имя слева от оператора вызова функции, поиск зависимый от аргументов подавляется.

На практике они могут быть реализованы как объекты функций или с помощью специальных расширений компилятора.

Параметры

ifirst, ilast	-	Пара iterator-sentinel, обозначающая входной диапазон элементов, которые нужно переместить
in_range	-	входной диапазон элементов, которые нужно переместить
ofirst, olast	-	Пара iterator-sentinel, обозначающая выходной диапазон для инициализации
out_range	-	выходной диапазон для инициализации

Возвращаемое значение

{ifirst + N, ofirst + N}

Сложность

Линейная по N.

Исключения

Исключение, сгенерированное при создании элементов в целевом диапазоне, если таковое есть.

Примечания

Реализация может повысить эффективность ranges::uninitialized_move, например, используя ranges::copy_n, если тип значения выходного диапазона является TrivialType.

Возможная реализация

struct uninitialized_move_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_rvalue_reference_t<I>>
    ranges::uninitialized_move_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)
                ::new (const_cast<void*>(static_cast<const volatile void*>
                    (std::addressof(*current)))) std::remove_reference_t<
                        std::iter_reference_t<O>>(ranges::iter_move(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>,
             ranges::range_rvalue_reference_t<IR>>
    ranges::uninitialized_move_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_move_fn uninitialized_move{};

Пример

#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[]{"Home", "World"};
    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(std::begin(in), std::end(in), 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: "Home" "World"
after move, in: "" ""
after move, out: "Home" "World"

Отчеты об ошибках

Следующие отчеты об ошибках, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

DR	Применено к	Поведение, как опубликовано	Правильное поведение
LWG 3870	C++20	Этот алгоритм мог создавать объекты в const памяти	Оставлено запрещённым

См. также

ranges::uninitialized_move_n (C++20)	перемещает определенное количество объектов в область неинициализированной памяти (niebloid)
uninitialized_move (C++17)	перемещает диапазон объектов в область неинициализированной памяти (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/memory/ranges/uninitialized_move