std::ranges::fill(3)

okay so bestie, welcome to std::ranges::fill(3) 💖 this is from the C++ Standard Libary man page (yes, that’s literally how it’s spelled at the top, and we’re not fixing it 💅). the vibe? we’re filling ranges. it’s giving “assign the same value to everything in sight” ✨

✨ NAME ✨

std::ranges::fill — std::ranges::fill. no cap, that’s the whole name. it’s literally the same thing twice. iconic. 👑

📜 Synopsis 📜

Defined in header <algorithm>

call signature

overload (1) — since C++20, until C++26:

template< class T, std::output_iterator<const T&> O, std::sentinel_for<O> S >
constexpr O fill( O first, S last, const T& value );

overload (1) — since C++26:

template< class O, std::sentinel_for<O> S, class T = std::iter_value_t<O> >
    requires std::output_iterator<O, const T&>
constexpr O fill( O first, S last, const T& value );

overload (2) — since C++20, until C++26:

template< class T, ranges::output_range<const T&> R >
constexpr ranges::borrowed_iterator_t<R> fill( R&& r, const T& value );

overload (2) — since C++26:

template< class R, class T = std::range_value_t<R> >
    requires ranges::output_range<R, const T&>
constexpr ranges::borrowed_iterator_t<R> fill( R&& r, const T& value );

1. Assigns the given value to the elements in the range [first, last).
2. Same as (1), but uses r as the source range, as if using ranges::begin(r) as first and ranges::end(r) as last.

The function-like entities described on this page are niebloids, that is:

• Explicit template argument lists cannot be specified when calling any of them.
• None of them are visible to argument-dependent lookup.
• When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.

In practice, they may be implemented as function objects, or with special compiler extensions.

🌸 Parameters 🌸

• first, last — the range of elements to modify
• r — the range of elements to modify
• value — the value to be assigned

🎀 Return value 🎀

An output iterator that compares equal to last.

🔥 Complexity 🔥

Exactly last - first assignments. no extra, no less, fr fr.

🛠️ Possible implementation 🛠️

struct fill_fn
{
    template<class O, std::sentinel_for<O> S, class T = std::iter_value_t<O>>
    requires std::output_iterator<O, const T&>
    constexpr O operator()(O first, S last, const T& value) const
    {
        while (first != last)
            *first++ = value;

        return first;
    }

    template<class R, class T = std::range_value_t<R>>
    requires ranges::output_range<R, const T&>
    constexpr ranges::borrowed_iterator_t<R> operator()(R&& r, const T& value) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), value);
    }
};

inline constexpr fill_fn fill;

📝 Notes 📝

lowkey important feature-test macro info:

• Feature-test macro: __cpp_lib_algorithm_default_value_type
• Value: 202403
• Std: (C++26)
• Feature: List-initialization for algorithms (1,2)

💻 Example 💻

// Run this code

#include <algorithm>
#include <complex>
#include <iostream>
#include <vector>

void println(const auto& seq)
{
    for (const auto& e : seq)
        std::cout << e << ' ';
    std::cout << '\n';
}

int main()
{
    std::vector<int> v{0, 1, 2, 3, 4, 5};

    // set all elements to -1 using overload (1)
    std::ranges::fill(v.begin(), v.end(), -1);
    println(v);

    // set all element to 10 using overload (2)
    std::ranges::fill(v, 10);
    println(v);

    std::vector<std::complex<double>> nums{{1, 3}, {2, 2}, {4, 8}};
    println(nums);
    #ifdef __cpp_lib_algorithm_default_value_type
        std::ranges::fill(nums, {4, 2}); // T gets deduced
    #else
        std::ranges::fill(nums, std::complex<double>{4, 2});
    #endif
    println(nums);
}

🖨️ Output 🖨️

-1 -1 -1 -1 -1 -1
10 10 10 10 10 10
(1,3) (2,2) (4,8)
(4,2) (4,2) (4,2)

👀 See also 👀

• ranges::fill_n — assigns a value to a number of elements (C++20) (niebloid)
• ranges::copy — copies a range of elements to a new location (C++20) (niebloid)
• ranges::copy_if — copies a range of elements to a new location (C++20) (niebloid)
• ranges::generate — saves the result of a function in a range (C++20) (niebloid)
• ranges::transform — applies a function to a range of elements (C++20) (niebloid)
• ranges::generate_random — fills a range with random numbers from a uniform random bit generator (C++26) (niebloid)
• fill — copy-assigns the given value to every element in a range (function template)

---

that’s the whole vibe, bestie! 🫶 source: http://cppreference.com — version/date: 2024.06.10 — page: std::ranges::fill(3). now go fill something iconic 💅✨