std::uninitialized_move

Определено в заголовке <memory>

Определено в заголовке `<memory>`
template< class InputIt, class NoThrowForwardIt > NoThrowForwardIt uninitialized_move( InputIt first, InputIt last, NoThrowForwardIt d_first );	(1)	(с C++17)
template< class ExecutionPolicy, class ForwardIt, class NoThrowForwardIt > NoThrowForwardIt uninitialized_move( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, NoThrowForwardIt d_first );	(2)	(с C++17)

template< class InputIt, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_move( InputIt first, InputIt last,
                                     NoThrowForwardIt d_first );

(1)

(с C++17)

template< class ExecutionPolicy, class ForwardIt, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_move( ExecutionPolicy&& policy,
                                     ForwardIt first, ForwardIt last,
                                     NoThrowForwardIt d_first );

(2)

(с C++17)

1) Перемещает элементы из диапазона [first, last) в область неинициализированной памяти, начинающейся с d_first так, как если бы

for (; first != last; ++d_first, (void) ++first)
 ::new (static_cast<void*>(std::addressof(*d_first)))
 typename std::iterator_traits<NoThrowForwardIt>::value_type(std::move(*first));

Если во время инициализации возникает исключение, некоторые объекты в [first, last) останутся в допустимом, но неопределённом состоянии, а уже построенные объекты будут разрушены в неопределённом порядке.

Если d_first + [0, std::distance(first, last)) перекрывается с [first, last), поведение является неопределённым.

(с C++20)

2) Аналогично (1), но выполняется согласно policy. Этот перегруз не участвует в разрешении перегрузки, если

`std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>` является `true`.	(до C++20)
`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` является `true`.	(с C++20)

Параметры

first, last	-	диапазон элементов, подлежащих перемещению
d_first	-	начало целевого диапазона
policy	-	используемая политика выполнения. Подробности см. в политике выполнения.
Требования к типу
-`InputIt` должен удовлетворять требованиям LegacyInputIterator.
-`ForwardIt` должен удовлетворять требованиям LegacyForwardIterator.
-`NoThrowForwardIt` должен удовлетворять требованиям LegacyForwardIterator.
-Обращение к допустимым экземплярам `NoThrowForwardIt` посредством инкремента, присваивания, сравнения или косвенного доступа не должно вызывать исключения.

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

Итератор, указывающий на элемент после последнего перемещённого элемента.

Сложность

Линейная относительно расстояния между first и last.

Исключения

Перегрузка с параметром шаблона под названием ExecutionPolicy сообщает об ошибках следующим образом:

Если во время выполнения функции, вызываемой в рамках алгоритма, возникает исключение и ExecutionPolicy является одной из стандартных политик, вызывается std::terminate. Для любой другой ExecutionPolicy, поведение определяется реализацией.
Если алгоритм не может выделить память, выбрасывается std::bad_alloc.

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

template<class InputIt, class NoThrowForwardIt>
NoThrowForwardIt uninitialized_move(InputIt first, InputIt last, NoThrowForwardIt d_first)
{
    using Value = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = d_first;
    try
    {
        for (; first != last; ++first, (void) ++current)
            ::new (static_cast<void*>(std::addressof(*current))) Value(std::move(*first));
        return current;
    }
    catch (...)
    {
        std::destroy(d_first, current);
        throw;
    }
}

Пример

#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", "Work!"};
    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::uninitialized_move(std::begin(in), std::end(in), first);
 
            print("after move, in: ", std::begin(in), std::end(in));
            print("after move, out: ", first, last);
 
            std::destroy(first, last);
        }
        catch (...)
        {
            std::cout << "Exception!\n";
        }
        std::free(out);
    }
}

Возможный вывод:

initially, in: "Home" "Work!"
after move, in: "" ""
after move, out: "Home" "Work!"

Отчёты о дефектах

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

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

См. также

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

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