std::uninitialized_copy
<memory>
NoThrowForwardIt uninitialized_copy( InputIt first, InputIt last,
class NoThrowForwardIt >
NoThrowForwardIt uninitialized_copy( ExecutionPolicy&& policy,
ForwardIt first, ForwardIt last,
[
first,
last)
to an uninitialized memory area beginning at d_first as if by
for (; first != last; ++d_first, (void) ++first)
::new (voidify
(*d_first))
typename std::iterator_traits <NoThrowForwardIt>::value_type(*first);
std::is_execution_policy_v <std::decay_t <ExecutionPolicy>> is true.
(until C++20)std::is_execution_policy_v <std::remove_cvref_t <ExecutionPolicy>> is true.
(since C++20)
If d_first +
[
0,
std::distance (first, last))
overlaps with [
first,
last)
, the behavior is undefined.
Contents
[edit] Parameters
InputIt
must meet the requirements of LegacyInputIterator.
ForwardIt
must meet the requirements of LegacyForwardIterator.
NoThrowForwardIt
must meet the requirements of LegacyForwardIterator.
NoThrowForwardIt
may throw exceptions. Applying &* to a NoThrowForwardIt
value must yield a pointer to its value type.(until C++11)
[edit] Return value
Iterator to the element past the last element copied.
[edit] Complexity
Linear in the distance between first and last.
[edit] 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.
[edit] Notes
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr for specialized memory algorithms, (1) |
[edit] Possible implementation
template<class InputIt, class NoThrowForwardIt> constexpr NoThrowForwardIt uninitialized_copy(InputIt first, InputIt last, NoThrowForwardIt d_first) { using T = typename std::iterator_traits <NoThrowForwardIt>::value_type; NoThrowForwardIt current = d_first; try { for (; first != last; ++first, (void) ++current) ::new (static_cast<void*>(std::addressof (*current))) T(*first); return current; } catch (...) { for (; d_first != current; ++d_first) d_first->~T(); throw; } }
[edit] Example
#include <cstdlib> #include <iostream> #include <memory> #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::cout << '\n'; std::destroy (first, last); } catch (...) {} std::free (pbuf); } }
Output:
This_is_an_example_
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 866 | C++98 | given T as the value type of NoThrowForwardIt , ifT::operator new exists, the program might be ill-formed |
uses global replacement- new instead |
LWG 2133 | C++98 | the effect description used a for loop with the iteration expression ++d_first, ++first, which results in an argument-dependent lookup of operator, |
discards the value of one operand to disable that ADL |
LWG 2433 | C++11 | this algorithm might be hijacked by overloaded operator& | uses std::addressof |
LWG 3870 | C++20 | this algorithm might create objects on a const storage | kept disallowed |
[edit] See also
(algorithm function object)[edit]