std::uninitialized_fill() algorithm
- since C++17
- until C++17
// (1)
template< class ForwardIt, class T >
void uninitialized_fill( ForwardIt first, ForwardIt last, const T& value );
// (2)
template< class ExecutionPolicy, class ForwardIt, class T >
void uninitialized_fill( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, const T& value );
// (1)
template< class ForwardIt, class T >
void uninitialized_fill( ForwardIt first, ForwardIt last, const T& value );
-
(1) Copies the given value
value
to the firstcount
elements in an uninitialized memory area beginning atfirst
as if by:for (; n--; ++first)
::new (/* VOIDIFY */(*first))
typename std::iterator_traits<ForwardIt>::value_type(value);Where
/* VOIDIFY */
is- since C++20
- since C++11
- until C++11
voidify(e)
static_cast<void*>(std::addressof(e))
static_cast<void*>(&e)
cautionIf 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
.Overload ResolutionThese overloads participate in overload resolution only if
std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
(until C++20)std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
(since C++20) istrue
.
Parameters
first | The beginning of the range of the elements to initialize. |
count | The number of elements to construct. |
value | The value to construct the elements with. |
policy | The execution policy to use. See execution policy for details. |
Type requirements
Forwardit | LegacyForwardIterator |
ForwardIt NoThrowForwardIt | 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 count
.
Exceptions
The overloads with a template parameter named ExecutionPolicy
report 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 none otherExecutionPolicy
, the behavior is implementation-defined. - If the algorithm fails to allocate memory,
std::bad_alloc
is thrown.
Possible implementation
uninitialized_fill (1)
template<class ForwardIt, class Size, class T>
ForwardIt uninitialized_fill_n(ForwardIt first, Size count, const T& value)
{
using V = typename std::iterator_traits<ForwardIt>::value_type;
ForwardIt current = first;
try
{
for (; count > 0; ++current, (void) --count)
::new (static_cast<void*>(std::addressof(*current))) V(value);
return current;
}
catch (...)
{
for (; first != current; ++first)
first->~V();
throw;
}
}
Examples
#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_n(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);
}
Example
Example
Example
Example
Hover to see the original license.