Standard library header <generator> (C++23)

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Standard library headers

Language support <cfloat> <climits> <compare> (C++20) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Concepts <concepts> (C++20) Diagnostics <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Memory management <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogramming <type_traits> (C++11) <ratio> (C++11)

General utilities <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Containers <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iterators <iterator> Ranges <generator> (C++23) <ranges> (C++20)

Algorithms <algorithm> <numeric> Strings <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Text processing <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    Numerics <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <valarray> Time <chrono> (C++11) <ctime> C compatibility <ccomplex> (C++11/17/20*) <ciso646> (until C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Input/output <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Concurrency support <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Execution support <execution> (C++17)

 

Classes
generator (C++23)	A view that represents synchronous coroutine generator (class template)

Synopsis

namespace std {
  // class template generator
  template<class Ref, class V = void, class Allocator = void>
  class generator;
 
  namespace pmr {
    template<class Ref, class V = void>
    using generator = std::generator<Ref, V, polymorphic_allocator<>>;
  }
}

Class template std::generator

namespace std {
  template<class Ref, class V = void, class Allocator = void>
  class generator : public ranges::view_interface<generator<Ref, V, Allocator>>
  {
  private:
    using /*value*/ =
      conditional_t<is_void_v<V>, remove_cvref_t< Ref >, V>;       // exposition-only
    using /*reference*/ = conditional_t<is_void_v<V>, Ref&&, Ref>; // exposition-only
 
    // class generator::iterator
    class /*iterator*/; // exposition-only
 
  public:
    using yielded =
      conditional_t<is_reference_v</*reference*/>, /*reference*/, const /*reference*/&>;
 
    // class generator::promise_type
    class promise_type;
 
    generator(const generator&) = delete;
    generator(generator&& other) noexcept;
 
    ~generator();
 
    generator& operator=(generator other) noexcept;
 
    /*iterator*/ begin();
    default_sentinel_t end() const noexcept;
 
  private:
    coroutine_handle<promise_type> /*coroutine_*/ = nullptr; // exposition-only
    unique_ptr<stack<coroutine_handle<>>> /*active_*/;       // exposition-only
  };
}

Class std::generator::promise_type

namespace std {
  template<class Ref, class V, class Allocator>
  class generator<Ref, V, Allocator>::promise_type
  {
  public:
    generator get_return_object() noexcept;
 
    suspend_always initial_suspend() const noexcept { return {}; }
    auto final_suspend() noexcept;
 
    suspend_always yield_value(yielded val) noexcept;
 
    auto yield_value(const remove_reference_t<yielded>& lval)
      requires is_rvalue_reference_v<yielded> &&
               constructible_from<remove_cvref_t<yielded>,
                                  const remove_reference_t<yielded>&>;
 
    template<class R2, class V2, class Alloc2, class Unused>
      requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded>
    auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&&, Unused> g) noexcept;
 
    template<ranges::input_range R, class Alloc>
      requires convertible_to<ranges::range_reference_t<R>, yielded>
    auto yield_value(ranges::elements_of<R, Alloc> r);
 
    void await_transform() = delete;
 
    void return_void() const noexcept {}
    void unhandled_exception();
 
    void* operator new(size_t size)
      requires same_as<Allocator, void> || default_initializable<Allocator>;
 
    template<class Alloc, class... Args>
      requires same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>
    void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);
 
    template<class This, class Alloc, class... Args>
      requires same_as<Allocator, void> || convertible_to<const Alloc&, Allocator>
    void* operator new(size_t size,
                       const This&,
                       allocator_arg_t,
                       const Alloc& alloc,
                       const Args&...);
 
    void operator delete(void* pointer, size_t size) noexcept;
 
  private:
    add_pointer_t<yielded> /*value_*/ = nullptr; // exposition-only
    exception_ptr /*except_*/;                   // exposition-only
  };
}

Class std::generator::iterator

namespace std {
  template<class Ref, class V, class Allocator>
  class generator<Ref, V, Allocator>::/*iterator*/
  {
  public:
    using value_type      = /*value*/;
    using difference_type = ptrdiff_t;
 
    /*iterator*/(/*iterator*/&& other) noexcept;
    /*iterator*/& operator=(/*iterator*/&& other) noexcept;
 
    /*reference*/ operator*() const
      noexcept(is_nothrow_copy_constructible_v</*reference*/>);
    /*iterator*/& operator++();
    void operator++(int);
 
    friend bool operator==(const /*iterator*/& i, default_sentinel_t);
 
  private:
    coroutine_handle<promise_type> /*coroutine_*/; // exposition-only
  };
}

References

• C++23 standard (ISO/IEC 14882:2024):

• 26.8.2 Header <generator> synopsis [generator.syn]

• 26.8.3 Class template generator [coro.generator.class]

• 26.8.5 Class generator::promise_type [coro.generator.promise]

• 26.8.6 Class generator::iterator [coro.generator.iterator]