Namespaces
Variants

std::uninitialized_move_n

От ru.cppreference.net
 
 
Библиотека алгоритмов
Ограниченные алгоритмы и алгоритмы над диапазонами (C++20)
Ограниченные алгоритмы, например ranges::copy, ranges::sort, ...
Немодифицирующие операции над последовательностями    
Пакетные операции
(C++17)
Операции поиска
Модифицирующие операции над последовательностями
Операции копирования
(C++11)
(C++11)
Операции обмена
Операции преобразования
Операции генерации
Операции удаления
Операции изменения порядка
(до C++17)(C++11)
(C++20)(C++20)
Операции выборки
(C++17)

Сортировка и связанные операции
Операции разбиения
(C++11)    

Операции сортировки
Операции двоичного поиска
(на разбитых диапазонах)
Операции над множествами (на сортированных диапазонах)
Операции слияния (на сортированных диапазонах)
Операции с пирамидой
Операции минимума/максимума
(C++11)
(C++17)
Операции лексикографического сравнения
Операции перестановок


Политики выполнения (C++17)
(только для пояснения*)(C++26)

Численные операции
(C++11)
(C++17)
(C++17)    

Специализированные <memory> алгоритмы

Специализированные <random> алгоритмы
Библиотека C









 
Специализированные <memory> алгоритмы
 
Определено в заголовочном файле <memory>
template< class InputIt, class Size, class NoThrowForwardIt >
std::pair<InputIt, NoThrowForwardIt>
    uninitialized_move_n( InputIt first, Size count,
                          NoThrowForwardIt d_first );
(1) (начиная с C++17)
(constexpr начиная с C++26)
template< class ExecutionPolicy,
          class ForwardIt, class Size, class NoThrowForwardIt >
std::pair<ForwardIt, NoThrowForwardIt>
    uninitialized_move_n( ExecutionPolicy&& policy, ForwardIt first,
                          Size count, NoThrowForwardIt d_first );
(2) (начиная с C++17)
1) Создаёт элементы в диапазоне назначения, начиная с d_first, из первых count элементов исходного диапазона, начиная с first, как если бы

for (; count > 0; ++d_first, (void) ++first, --count)
    ::new (voidify(*d_first))
        typename std::iterator_traits<NoThrowForwardIt>::value_type(deref-move(*iter));
return {first, d_first};

Если во время инициализации возникло исключение, некоторые объекты в first + [0count) остаются в допустимом, но неопределённом состоянии, а уже созданные объекты уничтожаются в неопределённом порядке.
2) То же, что и (1), но выполняется в соответствии с policy.
Эта перегрузка участвует в разрешении перегрузки только если значение следующего выражения равно true:

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

(до C++20)

std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

(начиная с C++20)


Если d_first + [0count) перекрывается с first + [0count), поведение не определено.

(начиная с C++20)

Параметры

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

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

Как описано выше.

Исключения

2) Во время выполнения процесса:
  • Если временные ресурсы памяти, необходимые для параллелизации, недоступны, std::bad_alloc выбрасывается.
  • Если необработанное исключение выбрасывается при доступе к объектам через аргумент алгоритма, поведение определяется политикой выполнения (для стандартных политик вызывается std::terminate).

Примечания

Когда входной итератор разыменовывается в rvalue, поведение std::uninitialized_move_n такое же, как у std::uninitialized_copy_n.

Проверка возможностей макрос Значение Стандарт Возможность
__cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr для специализированных <memory> алгоритмов, (1)

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

template<class InputIt, class Size, class NoThrowForwardIt>
constexpr std::pair<InputIt, NoThrowForwardIt>
    uninitialized_move_n(InputIt first, Size count, NoThrowForwardIt d_first)
{
    using ValueType = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = d_first;
    try
    {
        for (; count > 0; ++first, (void) ++current, --count) {
            auto addr = static_cast<void*>(std::addressof(*current));
            if constexpr (std::is_lvalue_reference_v<decltype(*first)>)
                ::new (addr) ValueType(std::move(*first));
            else
                ::new (addr) ValueType(*first);
        }
    }
    catch (...)
    {
        std::destroy(d_first, current);
        throw;
    }
    return {first, current};
}
**Примечание:** Весь код C++ внутри тегов `
` и `` был сохранен без изменений, как и требовалось. HTML-теги и атрибуты также остались нетронутыми.

Пример

#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[]{"One", "Definition", "Rule"};
    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_n(std::begin(in), sz, 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: "One" "Definition" "Rule" 
after move, in: "" "" "" 
after move, out: "One" "Definition" "Rule"

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

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

DR Применено к Поведение как опубликовано Корректное поведение
LWG 3918 C++17 перемещающее конструирование всегда выполняется, даже
если входной итератор разыменовывается в prvalue
без перемещающего конструирования
в этом случае

Смотрите также

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