home | help 
std::fill(3)		       C++ Standard Libary		    std::fill(3)

NAME
     std::fill - std::fill

Synopsis
	Defined in header <algorithm>
	template< class ForwardIt, class T >		      (constexpr since
	void fill( ForwardIt first, ForwardIt last,	      C++20)
	const T& value );				      (until C++26)
	template< class ForwardIt, class T = typename
	std::iterator_traits

	 <ForwardIt>::value_type >			      (since C++26)
	constexpr void fill( ForwardIt first,
	ForwardIt last,

			     const T& value );
	template< class ExecutionPolicy, class
	ForwardIt, class T >
						      (1)
     (since C++17)
	void		 fill(		   ExecutionPolicy&&		 policy,
     (until C++26)

		   ForwardIt first, ForwardIt last,
	const T& value );
	template< class ExecutionPolicy,
							  (2)
		  class ForwardIt, class T = typename
	std::iterator_traits
									       (since
     C++26)
	 <ForwardIt>::value_type >
	void fill( ExecutionPolicy&& policy,

		   ForwardIt first, ForwardIt last,
	const T& value );

	1) Assigns the given value to all elements in the range [first, last).
	2) Same as (1), but executed according to policy.
	This overload participates in overload resolution only if

	std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>    is    true.
     (until
										  C++20)
	std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>      is
     true. (since
										  C++20)

	If value is not writable to first, the program is ill-formed.

Parameters
	first, last - the range of elements to modify
	value	    - the value to be assigned
	policy	    - the execution policy to use. See execution policy for  de-
     tails.

Type requirements
	-
	ForwardIt must meet the requirements of LegacyForwardIterator.

Complexity
	Exactly std::distance(first, last) assignments.

Exceptions
	The overload with a template parameter named ExecutionPolicy reports er-
     rors 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  any  other  ExecutionPolicy, the behavior is implementation-de-
     fined.
	  * If the algorithm fails to allocate memory, std::bad_alloc is thrown.

Possible implementation
					  fill
	template<class ForwardIt,
		 class T = typename std::iterator_traits<ForwardIt>::value_type>
	void fill(ForwardIt first, ForwardIt last, const T& value)
	{
	    for (; first != last; ++first)
		*first = value;
	}

Notes
		  Feature-test macro	       Value	Std		 Feature
	__cpp_lib_algorithm_default_value_type 202403  (C++26)	List-initializa-
     tion 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, 6, 7, 8};
	  println(v);

	  // set all of the elements to 8
	  std::fill(v.begin(), v.end(), 8);
	  println(v);

	  std::vector<std::complex<double>> nums{{1, 3}, {2, 2}, {4, 8}};
	  println(nums);
	  #ifdef __cpp_lib_algorithm_default_value_type
	      std::fill(nums.begin(), nums.end(), {4, 2});
	  #else
	      std::fill(nums.begin(), nums.end(), std::complex<double>{4, 2});
	  #endif
	  println(nums);
      }

Output:
      0 1 2 3 4 5 6 7 8
      8 8 8 8 8 8 8 8 8
      (1,3) (2,2) (4,8)
      (4,2) (4,2) (4,2)

	Defect reports

	The  following	behavior-changing  defect  reports were applied retroac-
     tively to
	previously published C++ standards.

	  DR	Applied to	   Behavior as	published		 Correct
     behavior
			   T was required to be CopyAssignable,   required to be
     writable
	LWG 283 C++98	   but					  instead
			   T is not always writable to ForwardIt

See also
	fill_n	     copy-assigns the given value to N elements in a range
		     (function template)
	copy	     copies a range of elements to a new location
	copy_if      (function template)
	(C++11)
		     assigns  the  results of successive function calls to every
     element in a
	generate     range
		     (function template)
		     applies a function to a range of elements, storing  results
     in a
	transform    destination range
		     (function template)
	ranges::fill assigns a range of elements a certain value
	(C++20)      (niebloid)

http://cppreference.com 	   2024.06.10			    std::fill(3)
home | help