std::uninitialized_copy
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
#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) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/memory/uninitialized_copy