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

NAME
     std::fill_n - std::fill_n

Synopsis
	Defined in header <algorithm>
	template< class OutputIt, class Size, class T	      (constexpr since
	>						      C++20)
	OutputIt fill_n( OutputIt first, Size count,	      (until C++26)
	const T& value );
	template< class OutputIt, class Size,

		  class T = typename
	std::iterator_traits
							      (since C++26)
	<OutputIt>::value_type >
	constexpr OutputIt fill_n( OutputIt first,
	Size count,

				   const T& value );
	template< class ExecutionPolicy,

		  class ForwardIt, class Size, class  (1)
	T								       >
     (since C++17)
	ForwardIt	   fill_n(	     ExecutionPolicy&&		 policy,
     (until C++26)

			  ForwardIt first, Size
	count, const T& value );
	template< class ExecutionPolicy,
							  (2)
		  class ForwardIt, class Size,
		  class T = typename
	std::iterator_traits
									       (since
     C++26)
	<OutputIt>::value_type >
	ForwardIt fill_n( ExecutionPolicy&& policy,

			  ForwardIt first, Size
	count, const T& value );

	1)  Assigns the given value to the first count elements in the range be-
     ginning at
	first if count > 0. Does nothing otherwise.
	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 any of the following conditions is satisfied,  the  program	is  ill-
     formed:

	  * value is not writable to first.
	  * Size is not convertible to an integral type.

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

Type requirements
	-
	OutputIt must meet the requirements of LegacyOutputIterator.
	-
	ForwardIt must meet the requirements of LegacyForwardIterator.

Return value
	Iterator one past the last element assigned if count > 0,  first  other-
     wise.

Complexity
	Exactly std::max(0, count) 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_n
	template<class OutputIt, class Size,
		 class T = typename std::iterator_traits<OutputIt>::value_type>
	OutputIt fill_n(OutputIt first, Size count, const T& value)
	{
	    for (Size i = 0; i < count; i++)
		*first++ = value;
	    return first;
	}

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 <iterator>
      #include <vector>

      int main()
      {
	  std::vector<int> v1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

	  // replace values of the first 5 elements with -1
	  std::fill_n(v1.begin(), 5, -1);

	  std::copy_n(v1.cbegin(),	   v1.size(),	     std::ostream_itera-
     tor<int>(std::cout, " "));
	  std::cout << '\n';

	  std::vector<std::complex<double>> nums{{1, 3}, {2, 2}, {4, 8}};
	  #ifdef __cpp_lib_algorithm_default_value_type
	      std::fill_n(nums.begin(), 2, {4, 2});
	  #else
	      std::fill_n(nums.begin(), 2, std::complex<double>{4, 2});
	  #endif
	  std::copy_n(nums.cbegin(), nums.size(),
		      std::ostream_iterator<std::complex<double>>(std::cout,   "
     "));
	  std::cout << '\n';
      }

Output:
      -1 -1 -1 -1 -1 5 6 7 8 9
      (4,2) (4,2) (4,8)

	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
	LWG 283 C++98	   T was required to be CopyAssignable, but  required to
     be writable
			   T is not always writable to OutputIt      instead
			   the complexity requirement was aexactly
	LWG  426 C++98	    count				      no assign-
     ment if
			   assignmentsa, which is broken if count  is  count  is
     non-positive
			   negative
			   the location of the first element
	LWG 865 C++98	   following				     returned
			   the filling range was not returned

See also
	fill	       copy-assigns the given value to every element in a range
		       (function template)
	ranges::fill_n assigns a value to a number of elements
	(C++20)        (niebloid)

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