Namespaces
Variants

    std::generate

    From cppreference.com
     
    C++
     
    Algorithm library
    Constrained algorithms and algorithms on ranges (C++20)
    Constrained algorithms, e.g. ranges::copy, ranges::sort, ...
    Non-modifying sequence operations    
    Batch operations
    (C++17)
    Search operations
    Modifying sequence operations
    Copy operations
    (C++11)
    (C++11)
    (C++11)
    Swap operations
    Transformation operations
    Generation operations
    Removing operations
    Order-changing operations
    (until C++17)(C++11)
    (C++20)(C++20)
    Sampling operations
    (C++17)

    Sorting and related operations
    Partitioning operations
    (C++11)    
    (C++11)

    Sorting operations
    Binary search operations
    (on partitioned ranges)
    Set operations (on sorted ranges)
    Merge operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    (C++11)
    (C++17)
    Lexicographical comparison operations
    (C++20)
    Permutation operations


     
    Defined in header <algorithm> 
    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)
    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 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 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: 

    Ret fun();

    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.

    Complexity

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

    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.

    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();
}

    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

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