如何在C ++ 20中获得运行良好的生成器类模板？

分类：编程问答

如何解决如何在C ++ 20中获得运行良好的生成器类模板？

我只是一个简单的编码器，经常使用Python，并且沉迷于其生成器。据我了解当前的情况，可以使用协程在C ++ 20中完全实现它们，但是，至少直到C ++ 23为止，这并不是一件容易的事，因为需要编写一个生成器类（模板）。我怎么得到那个

  1. 运行速度相当快（至少不比旧的generators hack with macros慢）
  2. 我可以在其上使用基于范围的for，ranges库和Python的next的等效项。如果有一种方法可以测试发电机是否耗尽，那也很好。
  3. 当（如果有）等效项添加到标准库中时，我（很有可能）不需要更改我的代码太多

这有可能吗？

解决方法

如评论中所述，libcoro提供了更高级别的抽象，并可能解决您的某些问题。

对于point2，如果您确实需要一个公共方法来告诉您生成器已用尽，我想增强libcoro生成器将使其变得很容易。这是一个（未经测试）可能的示例。但是检查generator.end（）对您来说是一个问题吗？

namespace libcoro {
    template<typename T>
    class [[nodiscard]] generator
    {
    public:

    using reference_type = std::conditional_t<std::is_reference_v<T>,T,T&>;

    //.. libcoro stuff

    // ADDED
    bool done() const {
      m_coroutine.done();
    }

    reference_type value() const {
      return m_coroutine.promise().value();
    }

    void resume() {
      m_coroutine.resume();
    }

    // ...
};

}

然后您可以做：

while (true) {
        gen.resume();
        if(gen.done()) {
            std::cout << "this is the end!" << std::endl;
            break;
        }
        std::cout << "new value: " << gen.value() << std::endl;
}
,

在这里，您可以找到一些速度较快的生成器implementation，该生成器更喜欢std实现（如在MSVC中）：

在我的真实代码中，它被拆分为多个文件，但是为了显示在这里，我将其合并了。

它适用于所有主要的编译器（gcc，clang，msvc）。

//------------------
//general coroutine support
//------------------
#if defined(__clang__)
    //see: https://developercommunity.visualstudio.com/content/problem/502513/unable-to-use-clang-cl-coroutines-due-to-unresolve.html
    namespace std {
        namespace experimental {
            inline namespace coroutines_v1 {

                template <typename R,typename...>
                struct coroutine_traits {
                    using promise_type = typename R::promise_type;
                };

                template <typename Promise = void> 
                struct coroutine_handle;

                template <> struct coroutine_handle<void> {
                    static coroutine_handle from_address(void* addr) noexcept {
                        coroutine_handle me;
                        me.ptr = addr;
                        return me;
                    }
                    void operator()() { resume(); }
                    void* address() const { return ptr; }
                    void resume() const { __builtin_coro_resume(ptr); }
                    void destroy() const { __builtin_coro_destroy(ptr); }
                    bool done() const { return __builtin_coro_done(ptr); }
                    coroutine_handle& operator=(decltype(nullptr)) {
                        ptr = nullptr;
                        return *this;
                    }
                    coroutine_handle(decltype(nullptr)) : ptr(nullptr) {}
                    coroutine_handle() : ptr(nullptr) {}
                    //  void reset() { ptr = nullptr; } // add to P0057?
                    explicit operator bool() const { return ptr; }

                protected:
                    void* ptr;
                };

                template <typename Promise> 
                struct coroutine_handle : coroutine_handle<> {
                    using coroutine_handle<>::operator=;
                    using coroutine_handle<>::coroutine_handle;

                    static coroutine_handle from_address(void* addr) noexcept {
                        coroutine_handle me;
                        me.ptr = addr;
                        return me;
                    }

                    Promise& promise() const {
                        return *reinterpret_cast<Promise*>(
                            __builtin_coro_promise(ptr,alignof(Promise),false));
                    }
                    static coroutine_handle from_promise(Promise& promise) {
                        coroutine_handle p;
                        p.ptr = __builtin_coro_promise(&promise,true);
                        return p;
                    }
                };

                template <typename _PromiseT>
                bool operator==(coroutine_handle<_PromiseT> const& _Left,coroutine_handle<_PromiseT> const& _Right) noexcept
                {
                    return _Left.address() == _Right.address();
                }

                template <typename _PromiseT>
                bool operator!=(coroutine_handle<_PromiseT> const& _Left,coroutine_handle<_PromiseT> const& _Right) noexcept
                {
                    return !(_Left == _Right);
                }

                struct suspend_always {
                    bool await_ready() noexcept { return false; }
                    void await_suspend(coroutine_handle<>) noexcept {}
                    void await_resume() noexcept {}
                };
                struct suspend_never {
                    bool await_ready() noexcept { return true; }
                    void await_suspend(coroutine_handle<>) noexcept {}
                    void await_resume() noexcept {}
                };
            }
        }
    }
    #define NATIVE_COROUTINE_IMPL_NS std::experimental
#elif __has_include(<coroutine>)
    #include <coroutine>
    #define NATIVE_COROUTINE_IMPL_NS std    
#elif __has_include(<experimental/coroutine>)
    #include <experimental/coroutine>
    #define NATIVE_COROUTINE_IMPL_NS std::experimental
#endif

//------------------
//Generator defintion
//-----------------

#if __has_include(<generator>)
    #include <generator>
    namespace CORE_NATIVE_NS
    {
        template<typename T>
        using YieldEnum = std::generator<T>;
    }
#elif __has_include(<experimental/generator>) && !defined(__clang__)
    #include <experimental/generator>
    namespace CORE_NATIVE_NS
    {
        template<typename T>
        using YieldEnum = std::experimental::generator<T>;
    }
#else
#include <memory>
#include <cstddef>
#include <type_traits>
#include <utility>
#include <exception>
#include <iterator>
#include <functional>

namespace CORE_NATIVE_NS
{
    template<typename T>
    class generator;

    namespace detail
    {
        template<typename T>
        class generator_promise
        {
        public:
            using value_type = std::remove_reference_t<T>;
            using reference_type = std::conditional_t<std::is_reference_v<T>,T&>;
            using pointer_type = value_type*;

            generator_promise() = default;

            generator<T> get_return_object() noexcept;

            constexpr NATIVE_COROUTINE_IMPL_NS::suspend_always initial_suspend() const noexcept 
            { return {}; }
            constexpr NATIVE_COROUTINE_IMPL_NS::suspend_always final_suspend() const noexcept
            { return {}; }

            template<
                typename U = T,std::enable_if_t<!std::is_rvalue_reference<U>::value,int> = 0
            >
            NATIVE_COROUTINE_IMPL_NS::suspend_always yield_value(std::remove_reference_t<T>& value) noexcept
            {
                m_value = std::addressof(value);
                return {};
            }

            NATIVE_COROUTINE_IMPL_NS::suspend_always yield_value(std::remove_reference_t<T>&& value) noexcept
            {
                m_value = std::addressof(value);
                return {};
            }

            void unhandled_exception() noexcept
            {
                m_exception = std::current_exception();
            }

            void return_void() const noexcept
            {
            }

            reference_type value() const noexcept
            {
                return static_cast<reference_type>(*m_value);
            }

            // Don't allow any use of 'co_await' inside the generator coroutine.
            template<typename U>
            NATIVE_COROUTINE_IMPL_NS::suspend_never await_transform(U&& value) = delete;

            void rethrow_if_exception()
            {
                if (m_exception)
                {
                    std::rethrow_exception(m_exception);
                }
            }
        private:
            pointer_type m_value;
            std::exception_ptr m_exception;
        };

        struct generator_sentinel {};

        template<typename T>
        class generator_iterator
        {
            using coroutine_handle = NATIVE_COROUTINE_IMPL_NS::coroutine_handle<generator_promise<T>>;
        public:

            using iterator_category = std::input_iterator_tag;
            // What type should we use for counting elements of a potentially infinite sequence?
            using difference_type = std::ptrdiff_t;
            using value_type = typename generator_promise<T>::value_type;
            using reference = typename generator_promise<T>::reference_type;
            using pointer = typename generator_promise<T>::pointer_type;

            // Iterator needs to be default-constructible to satisfy the Range concept.
            generator_iterator() noexcept
                : m_coroutine(nullptr)
            {}

            explicit generator_iterator(coroutine_handle coroutine) noexcept
                : m_coroutine(coroutine)
            {}

            friend bool operator==(const generator_iterator& it,generator_sentinel) noexcept
            {
                return !it.m_coroutine || it.m_coroutine.done();
            }

            friend bool operator!=(const generator_iterator& it,generator_sentinel s) noexcept
            {
                return !(it == s);
            }

            friend bool operator==(generator_sentinel s,const generator_iterator& it) noexcept
            {
                return (it == s);
            }

            friend bool operator!=(generator_sentinel s,const generator_iterator& it) noexcept
            {
                return it != s;
            }

            generator_iterator& operator++()
            {
                m_coroutine.resume();
                if (m_coroutine.done())
                {
                    m_coroutine.promise().rethrow_if_exception();
                }

                return *this;
            }

            // Need to provide post-increment operator to implement the 'Range' concept.
            void operator++(int)
            {
                (void)operator++();
            }

            void next(){
                (void)operator++();
            }

            reference operator*() const noexcept
            {
                return m_coroutine.promise().value();
            }

            pointer operator->() const noexcept
            {
                return std::addressof(operator*());
            }

        private:
            coroutine_handle m_coroutine;
        };
    }

    template<typename T>
    class [[nodiscard]] generator
    {
    public:

        using promise_type = detail::generator_promise<T>;
        using iterator = detail::generator_iterator<T>;

        generator() noexcept
            : m_coroutine(nullptr)
        {}

        generator(generator&& other) noexcept
            : m_coroutine(other.m_coroutine)
        {
            other.m_coroutine = nullptr;
        }

        generator(const generator& other) = delete;

        ~generator()
        {
            if (m_coroutine)
            {
                m_coroutine.destroy();
            }
        }

        generator& operator=(generator other) noexcept
        {
            swap(other);
            return *this;
        }

        iterator begin()
        {
            if (m_coroutine)
            {
                m_coroutine.resume();
                if (m_coroutine.done())
                {
                    m_coroutine.promise().rethrow_if_exception();
                }
            }

            return iterator{ m_coroutine };
        }

        detail::generator_sentinel end() noexcept
        {
            return detail::generator_sentinel{};
        }

        void swap(generator& other) noexcept
        {
            std::swap(m_coroutine,other.m_coroutine);
        }

    private:

        friend class detail::generator_promise<T>;

        explicit generator(NATIVE_COROUTINE_IMPL_NS::coroutine_handle<promise_type> coroutine) noexcept
            : m_coroutine(coroutine)
        {}

        NATIVE_COROUTINE_IMPL_NS::coroutine_handle<promise_type> m_coroutine;

    };

    template<typename T>
    void swap(generator<T>& a,generator<T>& b)
    {
        a.swap(b);
    }

    namespace detail
    {
        template<typename T>
        generator<T> generator_promise<T>::get_return_object() noexcept
        {
            using coroutine_handle = NATIVE_COROUTINE_IMPL_NS::coroutine_handle<generator_promise<T>>;
            return generator<T>{ coroutine_handle::from_promise(*this) };
        }
    }

    template<typename FUNC,typename T>
    generator<std::invoke_result_t<FUNC&,typename generator<T>::iterator::reference>> fmap(FUNC func,generator<T> source)
    {
        for (auto&& value : source)
        {
            co_yield std::invoke(func,static_cast<decltype(value)>(value));
        }
    }

    template<typename T>
    using YieldEnum = CORE_NATIVE_NS::generator<T>;
}
#endif


inline CORE_NATIVE_NS::YieldEnum<int> GetNumbers() noexcept
{
    for(int i=0; i<= 10; ++i){
        co_yield 10;
    }
}

#include <iostream>

int main()
{
    int sum = 0;
    for(auto x : GetNumbers()){
        sum += x;
    }
    std::cout << sum;
    return 0;
}

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

导入项目后报错问题
依赖报错 idea导入项目后依赖报错，解决方案：https://blog.csdn.net/weixin_42420249/article/details/81191861 依赖版本报错：更换其他版本 无法下载依赖可参考：https://blog.csdn.net/weixin_42628809/a
idea不能识别yaml文件
使用mybatis plus常见错误
错误1：代码生成器依赖和mybatis依赖冲突 启动项目时报错如下 2021-12-03 13:33:33.927 ERROR 7228 [ main] o.s.b.d.LoggingFailureAnalysisReporter : *************************** APPL
gradle常见问题与错误
错误1：gradle项目控制台输出为乱码 # 解决方案：https://blog.csdn.net/weixin_43501566/article/details/112482302 # 在gradle-wrapper.properties 添加以下内容 org.gradle.jvmargs=-Df
Mybatis Plus传入参数0不起作用
错误还原：在查询的过程中，传入的workType为0时，该条件不起作用 &lt;select id=&quot;xxx&quot;&gt; SELECT di.id, di.name, di.work_type, di.updated... &lt;where&gt; &lt;if test=&qu
linux中make编译源码包失败
报错如下，gcc版本太低 ^ server.c:5346:31: 错误：‘struct redisServer’没有名为‘server_cpulist’的成员 redisSetCpuAffinity(server.server_cpulist); ^ server.c: 在函数‘hasActiveC
微服务启动错误：Command line is too long. Shorten command line for
解决方案1 1、改项目中.idea/workspace.xml配置文件，增加dynamic.classpath参数 2、搜索PropertiesComponent，添加如下 &lt;property name=&quot;dynamic.classpath&quot; value=&quot;tru
vue常见错误
删除根组件app.vue中的默认代码后报错：Module Error (from ./node_modules/eslint-loader/index.js): 解决方案：关闭ESlint代码检测，在项目根目录创建vue.config.js，在文件中添加 module.exports = { lin
spark常见错误
查看spark默认的python版本 [root@master day27]# pyspark /home/software/spark-2.3.4-bin-hadoop2.7/conf/spark-env.sh: line 2: /usr/local/hadoop/bin/hadoop: No s
matplotlib报错：AttributeError: module 'backend_interagg' has no attribute 'FigureCanvas'. Did you mean: 'FigureCanvasAgg'?
使用本地python环境可以成功执行 import pandas as pd import matplotlib.pyplot as plt # 设置字体 plt.rcParams[&#39;font.sans-serif&#39;] = [&#39;SimHei&#39;] # 能正确显示负号 p
gitlab登录失败，报错：This challenge page was accidentally cached by an intermediary and is no longer available.
设置时间 控制面板
后端开发常见错误
错误1：Request method ‘DELETE‘ not supported 错误还原：controller层有一个接口，访问该接口时报错：Request method ‘DELETE‘ not supported 错误原因：没有接收到前端传入的参数，修改为如下 参考 错误2：cannot r
docker常见错误
错误1：启动docker镜像时报错：Error response from daemon: driver failed programming external connectivity on endpoint quirky_allen 解决方法：重启docker -&gt; systemctl r
idea常见错误
错误1：private field ‘xxx‘ is never assigned 按Altʾnter快捷键，选择第2项 参考：https://blog.csdn.net/shi_hong_fei_hei/article/details/88814070 错误2：启动时报错，不能找到主启动类 #
pip安装依赖失败
报错如下，通过源不能下载，最后警告pip需升级版本 Requirement already satisfied: pip in c:\users\ychen\appdata\local\programs\python\python310\lib\site-packages (22.0.4) Coll
maven常见错误
错误1：maven打包报错 错误还原：使用maven打包项目时报错如下 [ERROR] Failed to execute goal org.apache.maven.plugins:maven-resources-plugin:3.2.0:resources (default-resources)
cloud项目中常见错误
错误1：服务调用时报错 服务消费者模块assess通过openFeign调用服务提供者模块hires 如下为服务提供者模块hires的控制层接口 @RestController @RequestMapping(&quot;/hires&quot;) public class FeignControl
springboot常见错误
错误1：运行项目后报如下错误 解决方案 报错2：Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.8.1:compile (default-compile) on project sb 解决方案：在pom.
springmvc拦截器中使用redisTemplate报空指针异常
参考 错误原因 过滤器或拦截器在生效时，redisTemplate还没有注入 解决方案：在注入容器时就生效 @Component //项目运行时就注入Spring容器 public class RedisBean { @Resource private RedisTemplate&lt;String
vite报错：npm ERR! command C:WINDOWSsystem32cmd.exe /d /s /c C:UsersychenAppDataLocalTempnpx-dde1c848.cmd
使用vite构建项目报错 C:\Users\ychen\work&gt;npm init @vitejs/app @vitejs/create-app is deprecated, use npm init vite instead C:\Users\ychen\AppData\Local\npm-
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot