cppreference.com

Namespaces

Variants

Actions

std::ranges::fill_n

From cppreference.com

< cpp‎ | algorithm‎ | ranges

Compiler support

Freestanding and hosted

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

External libraries

Algorithm library

Constrained algorithms and algorithms on ranges (C++20)

Constrained algorithms, e.g. ranges::copy, ranges::sort, ...

Execution policies (C++17)

is_execution_policy

(C++17)

execution::seqexecution::parexecution::par_unseqexecution::unseq

(C++17) (C++17)(C++17)(C++20)

execution::sequenced_policyexecution::parallel_policyexecution::parallel_unsequenced_policyexecution::parallel_unsequenced

(C++17)(C++17)(C++17)(C++20)

Non-modifying sequence operations

Batch operations

(C++17)

Search operations

all_ofany_ofnone_of

(C++11) (C++11)(C++11)

findfind_iffind_if_not

(C++11)

Modifying sequence operations Copy operations

(C++11)

(C++11)

(C++11)

(C++11)

Swap operations

Transformation operations

replacereplace_if

replace_copyreplace_copy_if

Generation operations

Removing operations

removeremove_if

remove_copyremove_copy_if

Order-changing operations

random_shuffleshuffle

(until C++17)(C++11)

shift_leftshift_right

(C++20)(C++20)

Sampling operations

(C++17)

Sorting and related operations

Partitioning operations

(C++11)

stable_partition

(C++11)

partition_point

(C++11)

Sorting operations

partial_sort_copy

(C++11)

is_sorted_until

(C++11)

Binary search operations
(on partitioned ranges)

Set operations (on sorted ranges)

set_intersection

set_symmetric_difference

Merge operations (on sorted ranges)

Heap operations

(C++11)

(C++11)

Minimum/maximum operations

(C++11)

(C++17)

(C++11)

Lexicographical comparison operations

lexicographical_compare

lexicographical_compare_three_way

(C++20)

Permutation operations

next_permutation

prev_permutation

(C++11)

Numeric operations

(C++11)

adjacent_difference

(C++17)

transform_reduce

(C++17)

(C++17)

(C++17)

transform_inclusive_scan

(C++17)

transform_exclusive_scan

(C++17)

Operations on uninitialized memory

uninitialized_copy

uninitialized_move

(C++17)

uninitialized_fill

uninitialized_copy_n

(C++11)

uninitialized_move_n

(C++17)

uninitialized_fill_n

(C++17)

(C++17)

(C++17)

(C++20)

uninitialized_default_construct

(C++17)

uninitialized_value_construct

(C++17)

uninitialized_default_construct_n

(C++17)

uninitialized_value_construct_n

(C++17)

Constrained algorithms

All names in this menu belong to namespace std::ranges

Non-modifying sequence operations

all_ofany_ofnone_of

lexicographical_compare

containscontains_subrange

(C++23)(C++23)

findfind_iffind_if_not

find_lastfind_last_iffind_last_if_not

(C++23)(C++23)(C++23)

(C++23)

(C++23)

Modifying sequence operations

shift_leftshift_right

(C++23)(C++23)

fill_n

removeremove_if

replacereplace_if

remove_copyremove_copy_if

replace_copyreplace_copy_if

Partitioning operations

partition_point

stable_partition

Sorting operations

is_sorted_until

partial_sort_copy

Binary search operations (on sorted ranges)

Set operations (on sorted ranges)

set_intersection

set_symmetric_difference

Heap operations

Minimum/maximum operations

Permutation operations

next_permutation

prev_permutation

Fold operations

(C++23)

fold_left_first

(C++23)

(C++23)

fold_right_last

(C++23)

fold_left_with_iter

(C++23)

fold_left_first_with_iter

(C++23)

Defined in header <algorithm>

Call signature

template< class T, std::output_iterator <const T&> O >
constexpr O fill_n( O first, std::iter_difference_t <O> n, const T& value );

(since C++20)
(until C++26)

template< class O, class T = std::iter_value_t <O> >

requires std::output_iterator <O, const T&>

constexpr O fill_n( O first, std::iter_difference_t <O> n, const T& value );

(since C++26)

Assigns the given value to all elements in the range [first, first + n).

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

[edit] Parameters

first - the beginning of the range of elements to modify

n - number of elements to modify

value - the value to be assigned

[edit] Return value

An output iterator that compares equal to first + n.

[edit] Complexity

Exactly n assignments.

[edit] Possible implementation

struct fill_n_fn
{
 template<class O, class T = std::iter_value_t <O>>
 requires std::output_iterator <O, const T&>
 constexpr O operator()(O first, std::iter_difference_t <O> n, const T& value) const
 {
 for (std::iter_difference_t <O> i {}; i != n; ++first, ++i)
 *first = value;
 return first;
 }
};
 
inline constexpr fill_n_fn fill_n {};

[edit] Notes

Feature-test macro	Value	Std	Feature
`__cpp_lib_algorithm_default_value_type`	`202403`	(C++26)	List-initialization for algorithms

[edit] Example

Run this code

#include <algorithm>
#include <complex>
#include <iostream>
#include <string>
#include <vector>
 
void println(const auto& v)
{
 for (const auto& elem : v)
 std::cout << ' ' << elem;
 std::cout << '\n';
}
 
int main()
{
 constexpr auto n{8};
 
 std::vector <std::string > v(n, "▓▓░░");
 println(v);
 
 std::ranges::fill_n(v.begin(), n, "░░▓▓");
 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_n(nums.begin(), 2, {4, 2});
 #else
 std::ranges::fill_n(nums.begin(), 2, std::complex <double>{4, 2});
 #endif
 println(nums);
}

Output:

 ▓▓░░ ▓▓░░ ▓▓░░ ▓▓░░ ▓▓░░ ▓▓░░ ▓▓░░ ▓▓░░
 ░░▓▓ ░░▓▓ ░░▓▓ ░░▓▓ ░░▓▓ ░░▓▓ ░░▓▓ ░░▓▓
 (1,3) (2,2) (4,8)
 (4,2) (4,2) (4,8)

[edit] See also

(C++20)

assigns a range of elements a certain value
(algorithm function object)[edit]

(C++20)

copies a number of elements to a new location
(algorithm function object)[edit]

ranges::generate

(C++20)

saves the result of a function in a range
(algorithm function object)[edit]

ranges::transform

(C++20)

applies a function to a range of elements
(algorithm function object)[edit]

ranges::generate_random

(C++26)

fills a range with random numbers from a uniform random bit generator
(algorithm function object)[edit]

copy-assigns the given value to N elements in a range
(function template) [edit]

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/ranges/fill_n&oldid=171921"