From cppreference.com
Defined in header
template<classForwardIt,classGenerator>voidgenerate(ForwardItfirst,ForwardItlast,Generatorgen); (1)(constexpr since C++20)template<classExecutionPolicy,classForwardIt,classGenerator>voidgenerate(ExecutionPolicy&&policy,ForwardItfirst,ForwardItlast,Generatorgen); (2) (since C++17)1) Assigns the result of successive evaluations of gen() to each element in the target range [first, last).
2) Same as (1), but executed according to policy.
This overload participates in overload resolution only if the value of the following expression is true:
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)Parameters
first, last - the pair of iterators defining the target
gen - generator function object that will be called. The signature of the function should be equivalent to the following:
Retfun();The type Ret must be such that an object of type ForwardIt can be dereferenced and assigned a value of type Ret.
policy - the
to use Type requirements -ForwardIt must meet the requirements of
. Complexity
Given N as std::distance(first,last):
1,2) Exactly N evaluations of gen() and N assignments.
Exceptions
2) During the execution process:
If the temporary memory resources required for parallelization are not available,
is thrown.
If an uncaught exception is thrown while accessing objects via an algorithm argument, the behavior is determined by the execution policy (for
,
is invoked).
Possible implementation
template<classForwardIt,classGenerator>constexpr//< since C++20voidgenerate(ForwardItfirst,ForwardItlast,Generatorgen){for(;first!=last;++first)*first=gen();}Example
Run this code
#include<algorithm>#include<iostream>#include<vector>voidprintln(std::string_viewfmt,constauto&v){for(std::cout<<fmt;constauto&e:v)std::cout<<e<<' ';std::cout<<'\n';};intf(){staticinti;return++i;}intmain(){std::vector<int>v(5);std::generate(v.begin(),v.end(),f);println("v: ",v);// 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{returnn++;});println("v: ",v);}Output:
v: 1 2 3 4 5 v: 0 1 2 3 4 See also
(C++20)
saves the result of a function in a range
(algorithm function object)
copy-assigns the given value to every element in a range
(function template & algorithm function object)
(C++20)
assigns the results of successive function calls to N elements in a range
(function template & algorithm function object)
(C++20)
(C++11)
fills a range with successive increments of the starting value
(function template & algorithm function object)
(C++23)