Std::generate_n (3) Linux Manual Page

std::generate_n – std::generate_n

Synopsis

Defined in header<algorithm>

    template <class OutputIt, class Size, class Generator>
    (until C++ 11)

        void generate_n(OutputIt first, Size count, Generator g);

template <class OutputIt, class Size, class Generator>
(since C++ 11)

    OutputIt generate_n(OutputIt first, Size count, Generator g);
(1)(until C++ 20)

    template <class OutputIt, class Size, class Generator>
    (since C++ 20)

        constexpr OutputIt generate_n(OutputIt first, Size count, Generator g);

template <class ExecutionPolicy, class ForwardIt, class Size, class Generator>
(2)(since C++ 17)

    ForwardIt generate_n(ExecutionPolicy &&policy, ForwardIt first, Size count, Generator g);

1) Assigns values, generated by given function object g, to the first count elements in the range beginning at first, if count>0. Does nothing otherwise.
2) Same as (1), but executed according to policy. This overload only participates in overload resolution if std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true

Parameters

first – the beginning of the range of elements to generate
count – number of the 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 OutputIt can be dereferenced and assigned a value of type Ret.

Type requirements

–
OutputIt must meet the requirements of LegacyOutputIterator.
–
ForwardIt must meet the requirements of LegacyForwardIterator.

Return value

(none) (until C++11)
Iterator one past the last element assigned if count>0, first otherwise. (since C++11)

Complexity

Exactly count invocations of g() and assignments, for count>0.

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 OutputIt, class Size, class Generator >
  OutputIt generate_n( OutputIt first, Size count, Generator g )
  {
      for( Size i = 0; i < count; i++ ) {
          *first++ = g();
      }
      return first;
  }

Example

// Run this code

#include <random>

#include <iostream>

#include <iterator>

#include <algorithm>

#include <functional>
int main()

{
    std::mt19937 rng; // default constructed, seeded with fixed seed
    std::generate_n(std::ostream_iterator<std::mt19937::result_type>(std::cout, " "),
                    5, std::ref(rng));
    std::cout << '\n';
}

Output:

3499211612 581869302 3890346734 3586334585 545404204

std::generate_n (3) Linux Manual Page