std::uninitialized_fill
Defined in header <memory> | ||
---|---|---|
template< class ForwardIt, class T >
void uninitialized_fill( ForwardIt first, ForwardIt last, const T& value );
| (1) | |
template< class ExecutionPolicy, class ForwardIt, class T >
void uninitialized_fill( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, const T& value );
| (2) | (since C++17) |
1) Copies the given
value
to an uninitialized memory area, defined by the range [first, last)
as if by for (; first != last; ++first)
::new (static_cast<void*>(std::addressof(*first)))
typename std::iterator_traits<ForwardIt>::value_type(value);
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 initialize |
value | - | the value to construct the elements with |
policy | - | the execution policy to use. See execution policy for details. |
Type requirements | ||
-ForwardIt must meet the requirements of LegacyForwardIterator. |
||
-No increment, assignment, comparison, or indirection through valid instances of ForwardIt may throw exceptions. |
Return value
(none).
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 ForwardIt, class T>
void uninitialized_fill(ForwardIt first, ForwardIt last, const T& value)
{
typedef typename std::iterator_traits<ForwardIt>::value_type Value;
ForwardIt current = first;
try {
for (; current != last; ++current) {
::new (static_cast<void*>(std::addressof(*current))) Value(value);
}
} catch (...) {
for (; first != current; ++first) {
first->~Value();
}
throw;
}
} |
Example
#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <tuple>
int main()
{
std::string* p;
std::size_t sz;
std::tie(p, sz) = std::get_temporary_buffer<std::string>(4);
std::uninitialized_fill(p, p+sz, "Example");
for (std::string* i = p; i != p+sz; ++i) {
std::cout << *i << '\n';
i->~basic_string<char>();
}
std::return_temporary_buffer(p);
}
Output:
Example Example Example Example
See also
copies an object to an uninitialized area of memory, defined by a start and a count (function template) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/memory/uninitialized_fill