| Defined in header <memory>
|
||
template< class InputIt, class NoThrowForwardIt > NoThrowForwardIt uninitialized_copy( InputIt first, InputIt last, NoThrowForwardIt d_first ); |
(1) | (constexpr since C++26) |
| template< class ExecutionPolicy, class ForwardIt, class NoThrowForwardIt > NoThrowForwardIt uninitialized_copy( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, NoThrowForwardIt d_first ); |
(2) | (since C++17) |
[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);
policy.|
|
(until C++20) |
|
|
(since C++20) |
|
If |
(since C++20) |
Parameters
| first, last | - | the range of the elements to copy |
| d_first | - | the beginning of the destination range |
| policy | - | the execution policy to use |
| Type requirements | ||
InputIt must meet the requirements of LegacyInputIterator.
| ||
ForwardIt must meet the requirements of LegacyForwardIterator.
| ||
NoThrowForwardIt must meet the requirements of LegacyForwardIterator.
| ||
No increment, assignment, comparison, or indirection through valid instances of NoThrowForwardIt may throw exceptions. Applying &* to a NoThrowForwardIt value must yield a pointer to its value type.(until C++11)
| ||
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
ExecutionPolicyis 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.
Notes
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr for specialized memory algorithms, (1) |
Possible implementation
|
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);
}
}This_is_an_example_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 resultsin 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 |
See also
| (C++11) |
copies a number of objects to an uninitialized area of memory (function template) |
| (C++20) |
copies a range of objects to an uninitialized area of memory (algorithm function object) |
Content from this page on cppreference.com, licensed under CC-BY-SA 3.0 and GFDL. Modified: restyled, site navigation removed, code windows added. Offline snapshot of 9 February 2025.