std::uninitialized_copy_n() algorithm
- od C++17
- od C++11
// (1)
template< class InputIt, class Size, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_copy_n( InputIt first, Size count, NoThrowForwardIt d_first );
// (2)
template< class ExecutionPolicy, class ForwardIt, class Size, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_copy_n(
ExecutionPolicy&& policy,
ForwardIt first,
Size count,
NoThrowForwardIt d_first
);
// (1)
template< class InputIt, class Size, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_copy_n( InputIt first, Size count, NoThrowForwardIt d_first );
-
(1) Copies
count
elements from a range beginning atfirst
to an uninitialized memory area beginning atd_first
as if by:for (; n > 0; ++d_first, (void) ++first, --n)
::new (static_cast<void*>(std::addressof(*d_first)))
typename std::iterator_traits<NoThrowForwardIt>::value_type(*first);uwagaIf an exception is thrown during the initialization, the objects already constructed are destroyed in an unspecified order.
Undefined BehaviourIf d_first + [0
,n
) overlaps with [first
;last
), the behavior is undefined. (od C++20) -
(2) Same as (1), but executed according to
policy
.
These overloads participate in overload resolution only if
std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
(do C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
(od C++20) is true
.
Parameters
first | The beginning of the range of the elements to copy. |
copy | The number of elements to copy. |
d_first | The beginning of the destination range. |
policy | The execution policy to use. See execution policy for details. |
Type requirements
InputIt | LegacyInputIterator |
ForwardIt NoThrowForwardIt | LegacyForwardIterator |
No increment, assignment, comparison, or indirection through valid instances of NoThrowForwardIt
may throw exceptions.
Return value
Iterator to the element past the last element copied.
Complexity
Linear in count
.
Exceptions
The overloads with a template parameter named ExecutionPolicy
report errors as follows:
- If execution of a function invoked as part of the algorithm throws an exception and
ExecutionPolicy
is one of the standard policies,std::terminate
is called. For none otherExecutionPolicy
, the behavior is implementation-defined. - If the algorithm fails to allocate memory,
std::bad_alloc
is thrown.
Possible implementation
uninitialized_copy_n (1)
template<class InputIt, class Size, class NoThrowForwardIt>
NoThrowForwardIt uninitialized_copy_n(InputIt first, Size count, NoThrowForwardIt d_first)
{
using T = typename std::iterator_traits<NoThrowForwardIt>::value_type;
NoThrowForwardIt current = d_first;
try
{
for (; count > 0; ++first, (void) ++current, --count)
::new (static_cast<void*>(std::addressof(*current))) T(*first);
}
catch (...)
{
for (; d_first != current; ++d_first)
d_first->~T();
throw;
}
return current;
}
Examples
#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <tuple>
#include <vector>
int main()
{
std::vector<std::string> v = {"This", "is", "an", "example"};
std::string* p;
std::size_t sz;
std::tie(p, sz) = std::get_temporary_buffer<std::string>(v.size());
sz = std::min(sz, v.size());
std::uninitialized_copy_n(v.begin(), sz, p);
for (std::string* i = p; i != p + sz; ++i)
{
std::cout << *i << ' ';
i->~basic_string<char>();
}
std::cout << '\n';
std::return_temporary_buffer(p);
}
This is an example
Hover to see the original license.