std::uninitialized_copy
From cppreference.com
Defined in header <memory>
|
||
template< class InputIt, class ForwardIt > ForwardIt uninitialized_copy( InputIt first, InputIt last, ForwardIt d_first ); |
(1) | |
template< class ExecutionPolicy, class InputIt, class ForwardIt > ForwardIt uninitialized_copy( ExecutionPolicy&& policy, InputIt first, InputIt last, ForwardIt d_first ); |
(2) | (since C++17) |
1) Copies elements from the range
[first, last)
to an uninitialized memory area beginning at d_first
as if by
for (; first != last; ++d_first, (void) ++first) ::new (static_cast<void*>(std::addressof(*d_first))) typename std::iterator_traits<ForwardIt>::value_type(*first);
If an exception is thrown during the initialization, the objects already constructed are destroyed in an unspecified order.
2) Same as (1), but executed according to
policy
. This overload does not participate in overload resolution unless std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is trueParameters
first, last | - | the range of the 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 must meet the requirements of LegacyInputIterator.
| ||
-ForwardIt must meet the requirements of LegacyForwardIterator.
| ||
-No increment, assignment, comparison, or indirection through valid instances of ForwardIt may throw exceptions.
|
Return value
Iterator to the element past the last element copied.
Complexity
Linear in the distance between first
and last
Exceptions
The overload with a template parameter named ExecutionPolicy
reports 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 any otherExecutionPolicy
, the behavior is implementation-defined. - If the algorithm fails to allocate memory, std::bad_alloc is thrown.
Possible implementation
template<class InputIt, class ForwardIt> ForwardIt uninitialized_copy(InputIt first, InputIt last, ForwardIt d_first) { typedef typename std::iterator_traits<ForwardIt>::value_type Value; ForwardIt current = d_first; try { for (; first != last; ++first, (void) ++current) { ::new (static_cast<void*>(std::addressof(*current))) Value(*first); } return current; } catch (...) { for (; d_first != current; ++d_first) { d_first->~Value(); } throw; } } |
Example
Run this code
#include <iostream> #include <memory> #include <cstdlib> #include <string> int main() { const char *v[] = {"This", "is", "an", "example"}; auto sz = std::size(v); if(void *pbuf = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz)) { try { auto first = static_cast<std::string*>(pbuf); auto last = std::uninitialized_copy(std::begin(v), std::end(v), first); for (auto it = first; it != last; ++it) std::cout << *it << '_'; std::destroy(first, last); } catch(...) {} std::free(pbuf); } }
Output:
This_is_an_example_
See also
(C++11) |
copies a number of objects to an uninitialized area of memory (function template) |