std::generate
From cppreference.com
| Defined in header <algorithm>
|
||
template< class ForwardIt, class Generator >
void generate( ForwardIt first, ForwardIt last, Generator gen );
|
(1) | (constexpr since C++20) |
template< class ExecutionPolicy, class ForwardIt, class Generator >
void generate( ExecutionPolicy&& policy,
ForwardIt first, ForwardIt last, Generator gen );
|
(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:
|
|
(until C++20) |
|
|
(since C++20) |
Parameters
| first, last | - | the pair of iterators defining the target range | ||||||
| gen | - | generator function object that will be called. The signature of the function should be equivalent to the following:
The type | ||||||
| policy | - | the execution policy to use | ||||||
| Type requirements | ||||||||
-ForwardIt must meet the requirements of LegacyForwardIterator.
| ||||||||
Complexity
Given \(\scriptsize N\)N as std::distance(first, last):
1,2) Exactly \(\scriptsize N\)N evaluations of
gen() and \(\scriptsize N\)N assignments.Exceptions
2) During the execution process:
- If the temporary memory resources required for parallelization are not available, std::bad_alloc is thrown.
- If an uncaught exception is thrown while accessing objects via an algorithm argument, the behavior is determined by the execution policy (for standard policies, std::terminate is invoked).
Possible implementation
template<class ForwardIt, class Generator>
constexpr //< since C++20
void generate(ForwardIt first, ForwardIt last, Generator gen)
{
for (; first != last; ++first)
*first = gen();
}
|
Example
Run this code
#include <algorithm>
#include <iostream>
#include <vector>
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<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 { return n++; });
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) |