std::generate_n (3) - Linux Man Pages

std::generate_n: std::generate_n

NAME

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

See also


         copy-assigns the given value to N elements in a range
fill_n (function template)
         assigns the results of successive function calls to every element in a range
generate (function template)