std::ranges::uninitialized_move, std::ranges::uninitialized_move_result
Материал из cppreference.com
<tbody>
</tbody>
| Определено в заголовочном файле <memory>
|
||
| Сигнатура вызова |
||
template< std::input_iterator I, std::sentinel_for<I> S1, прямой-итератор-без-исключения O, ограничитель-без-исключения-для<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, прямой-диапазон-без-исключения 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(*first)))
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.Функционально-подобные объекты, описанные на этой странице, являются ниблоидами, то есть:
- Явные списки аргументов шаблона не могут быть указаны при вызове любого из них.
- Ни один из них не виден для поиска, зависящего от аргумента.
- Когда какой-либо из них обнаруживается обычным неквалифицированным поиском по имени слева от оператора вызова функции, поиск, зависящий от аргумента запрещён.
На практике они могут быть реализованы как функциональные объекты или со специальными расширениями компилятора.
Параметры
| ifirst, ilast | — | пара итератор-ограничитель, обозначающая входной диапазон элементов, из которого перемещать |
| in_range | — | входной диапазон элементов, из которого перемещать |
| ofirst, olast | — | пара итератор-ограничитель, обозначающая выходной диапазон для инициализации |
| 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,
прямой-итератор-без-исключения O, ограничитель-без-исключения-для<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 (...) // откат: уничтожить созданные элементы
{
for (; ofirst != current; ++ofirst)
ranges::destroy_at(std::addressof(*ofirst));
throw;
}
}
template<ranges::input_range IR, прямой-диапазон-без-исключения 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[]{"Дом", "Работа"};
print("изначально, 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("после перемещения, in: ", std::begin(in), std::end(in));
print("после перемещения, out: ", first, last);
std::ranges::destroy(first, last);
}
catch (...)
{
std::cout << "Исключение!\n";
}
std::free(out);
}
}
Возможный вывод:
изначально, in: "Дом" "Работа"
после перемещения, in: "" ""
после перемещения, out: "Дом" "Работа"
Отчёты о дефектах
Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:
| Номер | Применён | Поведение в стандарте | Корректное поведение |
|---|---|---|---|
| LWG 3870 | C++20 | этот алгоритм может создавать объекты в const хранилище
|
запрещено |
Смотрите также
(C++20) |
перемещает ряд объектов в неинициализированную область памяти (ниблоид) |
(C++17) |
перемещает диапазон объектов в неинициализированную область памяти (шаблон функции) |