Standard library header <generator> (C++23)
From cppreference.com
Classes | ||
(C++23) | A view that represents synchronous coroutine generator (class template) | |
[edit]Synopsis
namespace std {// class template generatortemplate<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<>>;}}
[edit]Class template std::generator
namespace std {template<class Ref, class V =void, class Allocator =void>class generator :publicranges::view_interface<generator<Ref, V, Allocator>>{private:using/*value*/= conditional_t<is_void_v<V>, remove_cvref_t< Ref >, V>;// exposition-onlyusing/*reference*/= conditional_t<is_void_v<V>, Ref&&, Ref>;// exposition-only // class generator::iteratorclass/*iterator*/;// exposition-only public:using yielded = conditional_t<is_reference_v</*reference*/>, /*reference*/, const/*reference*/&>; // class generator::promise_typeclass promise_type; generator(const generator&)= delete; generator(generator&& other)noexcept; ~generator(); generator& operator=(generator other)noexcept; /*iterator*/ begin(); default_sentinel_t end()constnoexcept; private: coroutine_handle<promise_type>/*coroutine_*/= nullptr;// exposition-only unique_ptr<stack<coroutine_handle<>>>/*active_*/;// exposition-only};}
[edit]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()constnoexcept{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<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()constnoexcept{}void unhandled_exception(); void*operator new(size_t size) requires same_as<Allocator, void>|| default_initializable<Allocator>; template<class Alloc, class... Args>void*operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...); template<class This, class Alloc, class... Args>void*operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc, const Args&...); voidoperator delete(void* pointer, size_t size)noexcept; private: add_pointer_t<yielded>/*value_*/= nullptr;// exposition-only exception_ptr /*except_*/;// exposition-only};}
[edit]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*()constnoexcept(is_nothrow_copy_constructible_v</*reference*/>);/*iterator*/& operator++();void operator++(int); friendbool operator==(const/*iterator*/& i, default_sentinel_t); private: coroutine_handle<promise_type>/*coroutine_*/;// exposition-only};}
[edit]References
- C++23 standard (ISO/IEC 14882:2024):
- 26.8.2 Header
<generator>synopsis [generator.syn]
- 26.8.2 Header
- 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]
