# std::generate_n

> C++ Atlas: `cppatlas.com/w/cpp/algorithm/generate_n` | Source: https://en.cppreference.com/w/cpp/algorithm/generate_n | Domain: Algorithms | Standards: C++17, C++20

If Size is not convertible to an integral type, the program is ill-formed.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <algorithm>

template< class OutputIt, class Size, class Generator >
OutputIt generate_n( OutputIt first, Size count, Generator g ); // (1) (constexpr since C++20)

template< class ExecutionPolicy,
          class ForwardIt, class Size, class Generator >
ForwardIt generate_n( ExecutionPolicy&& policy,
                      ForwardIt first, Size count, Generator g ); // (2) (since C++17)
```

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 participates in overload resolution only if all following conditions are satisfied:

   `std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>` is `true`. (until C++20)

   `std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is `true`. (since C++20)

If `Size` is not convertible to an integral type, the program is ill-formed.

### Parameters

- `first` - the beginning of the range of elements to generate
- `count` - number of the 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:

  ```cpp
  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

Iterator one past the last element assigned if `count > 0`, `first` otherwise.

### Complexity

Exactly `std::max(0, count)` 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

```cpp
template<class OutputIt, class Size, class Generator>
constexpr // since C++20
OutputIt generate_n(OutputIt first, Size count, Generator g)
{
    for (Size i = 0; i < count; ++i, ++first)
        *first = g();

    return first;
}
```

### Example

```cpp
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <random>

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:

```text
3499211612 581869302 3890346734 3586334585 545404204
```

### Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

| DR | Applied to | Behavior as published | Correct behavior |
| --- | --- | --- | --- |
| LWG 426 | C++98 | the complexity requirement was “exactly `count` invocations or assignments”, which is broken if `count` is negative | no invocation or assignment if `count` is non-positive |
| LWG 865 | C++98 | the location of the first element following the generation range was not returned | returned |

### See also

- [`fill_n`](https://en.cppreference.com/w/cpp/algorithm/fill_n): copy-assigns the given value to N elements in a range (function template)
- [`generate`](https://en.cppreference.com/w/cpp/algorithm/generate): assigns the results of successive function calls to every element in a range (function template)
- [`ranges::generate_n`](https://en.cppreference.com/w/cpp/algorithm/ranges/generate_n) (C++20): saves the result of N applications of a function (algorithm function object)

---
Attribution: content from https://en.cppreference.com/w/cpp/algorithm/generate_n (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.