std::generate - cppreference.com (original) (raw)

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

Assigns each element in range [first, last) a value generated by the given function object g.
Same as (1), but executed according to policy.

This overload participates in overload resolution only if all following conditions are satisfied:

[edit] Parameters

first, last	-	the pair of iterators defining the range of elements to generate
policy	-	the execution policy to use
g	-	generator function object that will be called. The signature of the function should be equivalent to the following: The type Ret must be such that an object of type ForwardIt can be dereferenced and assigned a value of type Ret.
Type requirements
-ForwardIt must meet the requirements of LegacyForwardIterator.

[edit] Complexity

Exactly std::distance(first, last) invocations of g() and assignments.

[edit] 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::terminate is called. For any other ExecutionPolicy, the behavior is implementation-defined.
If the algorithm fails to allocate memory, std::bad_alloc is thrown.

[edit] Possible implementation

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

[edit] Example

#include #include #include void println(std::string_view fmt, const auto& v) { for (std::cout << fmt; const auto& e : v) std::cout << e << ' '; std::cout << '\n'; }; int f() { static int i; return ++i; } int main() { std::vector 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 { return n++; }); println("v: ", v); }

Output:

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

[edit] See also

| | copy-assigns the given value to every element in a range (function template) [edit] | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | assigns the results of successive function calls to N elements in a range (function template) [edit] | | | fills a range with successive increments of the starting value (function template) [edit] | | | saves the result of a function in a range(algorithm function object)[edit] |