std::ranges::fill - cppreference.com (original) (raw)

| Defined in header | | | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | --------------------------- | | Call signature | | | | (1) | | | | template< class T, std::output_iterator<const T&> O, std::sentinel_for<O> S > constexpr O fill( O first, S last, const T& value ); | | (since C++20) (until 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 ); | | (since C++26) | | (2) | | | | template< class T, ranges::output_range<const T&> R > constexpr ranges::borrowed_iterator_t<R> fill( R&& r, const T& value ); | | (since C++20) (until C++26) | | template< class R, class T = ranges::range_value_t<R> > requires ranges::output_range<R, const T&> constexpr ranges::borrowed_iterator_t<R> fill( R&& r, const T& value ); | | (since C++26) |

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 algorithm function objects (informally known as 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.

Contents

• 1 Parameters
• 2 Return value
• 3 Complexity
• 4 Possible implementation
• 5 Notes
• 6 Example
• 7 See also

[edit] Parameters

[edit] Return value

An output iterator that compares equal to last.

[edit] Complexity

Exactly last - first assignments.

[edit] Possible implementation

struct fill_fn { template<class O, std::sentinel_for S, class T = std::iter_value_t> 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 = ranges::range_value_t> requires ranges::output_range<R, const T&> constexpr ranges::borrowed_iterator_t operator()(R&& r, const T& value) const { return (*this)(ranges::begin(r), ranges::end(r), value); } };   inline constexpr fill_fn fill;

[edit] Notes

[edit] Example

#include #include #include #include   void println(const auto& seq) { for (const auto& e : seq) std::cout << e << ' '; std::cout << '\n'; }   int main() { std::vector 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> 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{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)

[edit] See also