C++20协程初探！

coro_ret<int> number_generator(int begin, int count) {    std::cout << "number_generator invoked." << std::endl;    for (int i=begin; i<count; ++i) {        co_yield i;    }    co_return;}
int main(int argc, char* argv[]){    auto g = number_generator(1, 10);    std::cout << "begin to run!" << std::endl;    while(!g.resume()) {        std::cout << "got number:" << g.get() << std::endl;    }
    std::cout << "coroutine done, return value:" << g.get() << std::endl;
    return 0;}

//!coro_ret 协程函数的返回值，内部定义promise_type，承诺对象template <typename T>struct coro_ret{  struct promise_type;  using handle_type = std::coroutine_handle<promise_type>;  //! 协程句柄  handle_type coro_handle_;      //!promise_type就是承诺对象，承诺对象用于协程内外交流    struct promise_type    {            promise_type() {            std::cout << "promise constructor invoded." << std::endl;        }        ~promise_type() = default;
        //!生成协程返回值        auto get_return_object(){            std::cout << "get_return_object invoked." << std::endl;            return coro_ret<T>{handle_type::from_promise(*this)};        }
        //! 注意这个函数,返回的就是awaiter        //! 如果返回std::suspend_never{}，就不挂起，        //! 返回std::suspend_always{} 挂起        //! 当然你也可以返回其他awaiter        auto initial_suspend(){            //return std::suspend_never{};            std::cout << "initial_suspend invoked." << std::endl;            return std::suspend_always{};        }        //!co_return 后这个函数会被调用        /*        void return_value(const T&amp; v)        {            return_data_ = v;            return;        }        */
        void return_void(){            std::cout << "return void invoked." << std::endl;        }
        //!        auto yield_value(const T&amp; v){            std::cout << "yield_value invoked." << std::endl;            return_data_ = v;            return std::suspend_always{};            //return std::suspend_never{};        }        //! 在协程最后退出后调用的接口。        auto final_suspend() noexcept{            std::cout << "final_suspend invoked." << std::endl;            return std::suspend_always{};        }        //        void unhandled_exception(){            std::cout << "unhandled_exception invoked." << std::endl;            std::exit(1);        }        //返回值        T return_data_;    };
    coro_ret(handle_type h)            : coro_handle_(h)    {    }    ~coro_ret()    {        //!自行销毁        if (coro_handle_)        {            coro_handle_.destroy();        }    }
    //!恢复协程，返回是否结束    bool resume(){        if (!coro_handle_.done()) {  //! 如果已经done了，再调用resume，会导致coredump            coro_handle_.resume();        }        return coro_handle_.done();    }
    bool done() const{        return coro_handle_.done();    }
    //!通过promise获取数据，返回值    T get(){        return coro_handle_.promise().return_data_;    }
};

coro_return<T> logic() {    // 发起异步操作    some_async_oper();    co_yield xxx          // 恢复执行了，要先检查和获得异步操作的结果     auto result = get_async_oper_result()     do_some_thing(result)
     co_return}
int main() {  auto co_ret = logic();  // 循环检查异步操作是否结束  while(true) {      auto result = get_async_result();      if (result) {          // 异步操作结束了，恢复协程的运行，要把结果传过去          co_ret.resume()          break;      }  }}

coro_return<T> logic() {    auto result = co_await some_async_oper();    do_some_thing(result);}

 if (!awaiter.await_ready())  {    using handle_t = std::experimental::coroutine_handle<P>;
    using await_suspend_result_t =      decltype(awaiter.await_suspend(handle_t::from_promise(p)));
    <suspend-coroutine>
    if constexpr (std::is_void_v<await_suspend_result_t>){      awaiter.await_suspend(handle_t::from_promise(p));      <return-to-caller-or-resumer>    }    else    {      static_assert(         std::is_same_v<await_suspend_result_t, bool>,         "await_suspend() must return 'void' or 'bool'.");
      if (awaiter.await_suspend(handle_t::from_promise(p)))      {        <return-to-caller-or-resumer>      }    }
    <resume-point>  }
  return awaiter.await_resume();

coro_ret<int> connect_addr_example(io_service&amp; service, const char* ip, int16_t port){    coroutine_tcp_client client;    // 异步连接, service是对epoll的一个封装    auto connect_ret = co_await client.connect(ip, port, 3, service);    printf("client.connect return:%d\n", connect_ret);    if (connect_ret)    {        printf("connect failed, coroutine return\n");        co_return -1;    }
    do_something_with_connect(client);
    co_return 0;}

  struct connect_awaiter    {        coroutine_tcp_client& tcp_client_;
        // co_await开始会调用，根据返回值决定是否挂起协程        bool await_ready(){            auto status = tcp_client_.status();            switch(status)            {            case ERROR:                printf("await_ready: status error invalid, should not suspend!\n");                return true;            case CONNECTED:                printf("await_ready: already connected, should not suspend!\n");                return true;            default:                printf("await_ready: status:%d, return false.\n", status);                return false;            }
        }
        // 在协程挂起后会调用这个，如果返回true，会返回调用者，如果返回false，会立刻resume协程        bool await_suspend(std::coroutine_handle<> awaiting){            printf("await_suspend invoked.\n");            tcp_client_.handle_ = awaiting;            return true;        }
        // 在协程resume的时候会调用这个，这个的返回值会作为await的返回值        int await_resume(){            int ret = tcp_client_.status() == CONNECTED ? 0 : -1;            printf("awati_resume invoked, ret:%d\n", ret);            return ret;        }    };