Skip to content

Search topics & cppreference

Search all study topics, concept maps, and 6,587 C++ and C reference pages.

std::ranges::uninitialized_fill_n

Copies value to an uninitialized memory area first + [ 0 , count) as if by return ranges::uninitialized_fill(std::counted_iterator(first, count), std::default_sentinel, value).base();

NotebookLM
Defined in header <memory>
Call signature
template< no-throw-forward-range I, class T >
    requires std::constructible_from<std::iter_value_t<I>, const T&>
I uninitialized_fill_n( I first, std::iter_difference_t<I> count,
                        const T& value );
(since C++20)
(constexpr since C++26)

Copies value to an uninitialized memory area first + [​0​, count) as if by return ranges::uninitialized_fill(std::counted_iterator(first, count),
                                  std::default_sentinel, value).base();

If an exception is thrown during the initialization, the objects already constructed are destroyed in an unspecified order.

The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:

Parameters

first - the beginning of the range of the elements to initialize
count - number of elements to construct
value - the value to construct the elements with

Return value

As described above.

Complexity

Linear in count.

Exceptions

Any exception thrown on construction of the elements in the destination range.

Notes

An implementation may improve the efficiency of the ranges::uninitialized_fill_n, e.g. by using ranges::fill_n, if the value type of the output range is TrivialType.

Feature-test macro Value Std Feature
__cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr for specialized memory algorithms

Possible implementation

snippet.cpp
struct uninitialized_fill_n_fn
{
    template<no-throw-forward-range I, class T>
    requires std::constructible_from<std::iter_value_t<I>, const T&>
    I operator()(I first, std::iter_difference_t<I> n, const T& x) const
    {
        I rollback{first};
        try
        {
            for (; n-- > 0; ++first)
                ranges::construct_at(std::addressof(*first), x);
            return first;
        }
        catch (...) // rollback: destroy constructed elements
        {
            for (; rollback != first; ++rollback)
                ranges::destroy_at(std::addressof(*rollback));
            throw;
        }
    }
};
 
inline constexpr uninitialized_fill_n_fn uninitialized_fill_n{};

Example

example.cpp
#include <iostream>
#include <memory>
#include <string>
 
int main()
{
    constexpr int n{3};
    alignas(alignof(std::string)) char out[n * sizeof(std::string)];
 
    try
    {
        auto first{reinterpret_cast<std::string*>(out)};
        auto last = std::ranges::uninitialized_fill_n(first, n, "cppreference");
 
        for (auto it{first}; it != last; ++it)
            std::cout << *it << '\n';
 
        std::ranges::destroy(first, last);
    }
    catch (...)
    {
        std::cout << "Exception!\n";
    }
}
Output
cppreference
cppreference
cppreference

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 3870 C++20 this algorithm might create objects on a const storage kept disallowed

See also

copies an object to an uninitialized area of memory, defined by a range
(algorithm function object)
copies an object to an uninitialized area of memory, defined by a start and a count
(function template)

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.