Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

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

NAME
       std::generate - std::generate

Synopsis
	  Defined in header <algorithm>
	  template<	 class	    ForwardIt,	    class      Generator     >
       (until C++20)
	  void generate( ForwardIt first, ForwardIt last, Generator g );
	  template< class ForwardIt, class Generator >
	  constexpr  void   generate(	ForwardIt   first,   ForwardIt	 last,
       (since C++20)
	  Generator g );						 (1)
	  template< class ExecutionPolicy, class ForwardIt, class
	  Generator							     >
       (2) (since C++17)
	  void generate( ExecutionPolicy&& policy, ForwardIt first,
	  ForwardIt last, Generator g );

	  1) Assigns each element in range [first, last) a value generated  by
       the given
	  function object g.
	  2) Same as (1), but executed according to policy. This overload does
       not participate
	  in overload resolution unless
	  std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
	  (until C++20)
	  std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
	  (since C++20)	is true.

Parameters
	  first, last -	the range of elements to generate
	  policy       - the execution policy to use. See execution policy for
       details.
			generator function object that will be called.

			The signature of the function should be	equivalent  to
       the following:
	  g	      -
			Ret fun();

			The  type Ret must be such that	an object of type For-
       wardIt can be
			dereferenced and assigned a value of type Ret.

Type requirements
	  -
	  ForwardIt must meet the requirements of LegacyForwardIterator.

Return value
	  (none)

Complexity
	  Exactly std::distance(first, last) invocations of  g()  and  assign-
       ments.

Exceptions
	  The overload with a template parameter named ExecutionPolicy reports
       errors 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::termi-
       nate is called.
	      For any other ExecutionPolicy, the behavior  is  implementation-
       defined.
	    *  If  the	algorithm  fails to allocate memory, std::bad_alloc is
       thrown.

Possible implementation
	  template<class ForwardIt, class Generator>
	  constexpr // Since C++20
	  void generate(ForwardIt first, ForwardIt last, Generator g)
	  {
	      while (first != last) {
		  *first++ = g();
	      }
	  }

Example
       // Run this code

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

	int f()
	{
	    static int i;
	    return ++i;
	}

	int main()
	{
	    std::vector<int> v(5);
	    auto print = [&] {
		for (std::cout << "v: "; auto iv: v)
		    std::cout << iv << " ";
		std::cout << "\n";
	    };

	    std::generate(v.begin(), v.end(), f);
	    print();

	    // Initialize with default values 0,1,2,3,4	from a lambda function
	    // Equivalent to std::iota(v.begin(), v.end(), 0);
	    std::generate(v.begin(), v.end(), [n = 0] () mutable { return n++;
       });
	    print();
	}

Output:
	v: 1 2 3 4 5
	v: 0 1 2 3 4

See also
	  fill		   copy-assigns	the given value	to every element in  a
       range
			   (function template)
			   assigns the results of successive function calls to
       N elements in a
	  generate_n	   range
			   (function template)
	  iota		    fills  a  range  with successive increments	of the
       starting	value
	  (C++11)	   (function template)
	  ranges::generate saves the result of a function in a range
	  (C++20)	   (niebloid)

http://cppreference.com		  2022.07.31		      std::generate(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::generate&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help