std::ranges::uninitialized_copy, std::ranges::uninitialized_copy_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_reference_t<I>> uninitialized_copy_result<I, O> uninitialized_copy( 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_reference_t<IR>> uninitialized_copy_result<ranges::borrowed_iterator_t<IR>, ranges::borrowed_iterator_t<OR>> uninitialized_copy( IR&& in_range, OR&& out_range );	(2)	(с C++20)
Вспомогательные типы
template< class I, class O > using uninitialized_copy_result = ranges::in_out_result<I, O>;	(3)	(с C++20)

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

Входной и выходной диапазоны не должны перекрываться.

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

Функция эквивалентна:

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

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}

Сложность

\(\scriptsize\mathcal{O}(N)\)𝓞(N).

Исключения

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

Примечания

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

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

struct uninitialized_copy_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_reference_t<I>>
    ranges::uninitialized_copy_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)
                ranges::construct_at(std::addressof(*current), *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_reference_t<IR>>
    ranges::uninitialized_copy_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_copy_fn uninitialized_copy{};

Пример

#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <memory>
#include <string>
 
int main()
{
    const char* v[]{"This", "is", "an", "example"};
 
    if (const auto sz{std::size(v)};
        void* pbuf = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz))
    {
        try
        {
            auto first{static_cast<std::string*>(pbuf)};
            auto last{first + sz};
            std::ranges::uninitialized_copy(std::begin(v), std::end(v), first, last);
 
            std::cout << "{";
            for (auto it{first}; it != last; ++it)
                std::cout << (it == first ? "" : ", ") << std::quoted(*it);
            std::cout << "};\n";
 
            std::ranges::destroy(first, last);
        }
        catch (...)
        {
            std::cout << "uninitialized_copy exception\n";
        }
        std::free(pbuf);
    }
}

Вывод:

{"This", "is", "an", "example"};

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

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

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

См. также

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

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