| Defined in header <memory>
|
||
template< class NoThrowForwardIt > void uninitialized_value_construct( NoThrowForwardIt first, NoThrowForwardIt last ); |
(1) | (since C++17) (constexpr since C++26) |
| template< class ExecutionPolicy, class NoThrowForwardIt > void uninitialized_value_construct( ExecutionPolicy&& policy, NoThrowForwardIt first, NoThrowForwardIt last ); |
(2) | (since C++17) |
[first, last) by value-initialization, as if by
for (; first != last; ++first)
::new (voidify(*first))
typename std::iterator_traits<NoThrowForwardIt>::value_type();
policy.|
|
(until C++20) |
|
|
(since C++20) |
Parameters
| first, last | - | the range of the elements to initialize |
| policy | - | the execution policy to use |
| Type requirements | ||
NoThrowForwardIt must meet the requirements of LegacyForwardIterator.
| ||
No increment, assignment, comparison, or indirection through valid instances of NoThrowForwardIt may throw exceptions.
| ||
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 <iostream>
#include <memory>
#include <string>
int main()
{
struct S { std::string m{"Default value"}; };
constexpr int n{3};
alignas(alignof(S)) unsigned char mem[n * sizeof(S)];
try
{
auto first{reinterpret_cast<S*>(mem)};
auto last{first + n};
std::uninitialized_value_construct(first, last);
for (auto it{first}; it != last; ++it)
std::cout << it->m << '\n';
std::destroy(first, last);
}
catch (...)
{
std::cout << "Exception!\n";
}
// For scalar types, uninitialized_value_construct
// zero-fills the given uninitialized memory area.
int v[]{1, 2, 3, 4};
for (const int i : v)
std::cout << i << ' ';
std::cout << '\n';
std::uninitialized_value_construct(std::begin(v), std::end(v));
for (const int i : v)
std::cout << i << ' ';
std::cout << '\n';
}Default value
Default value
Default value
1 2 3 4
0 0 0 0Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 3870 | C++20 | this algorithm might create objects on a const storage | kept disallowed |
See also
| constructs objects by value-initialization in an uninitialized area of memory, defined by a start and a count (function template) | |
| constructs objects by default-initialization in an uninitialized area of memory, defined by a range (function template) | |
| constructs objects by value-initialization in an uninitialized area of memory, defined by a range (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.