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

From cppreference.com
< cpp‎ | header

### 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]

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/generator&oldid=163907"