c++协待

co_await expr

co_await(协待)是C++20新关键字.上面表示等待懒求值任务.不希望该任务阻塞调用者,用协待挂起任务.调用者继续.任务完成后,协待返回协程的结果.有两个作用:挂起协程及取协程返回值.
协待等待任务时,不阻塞调用者,就是协程化异步为同步的关键.
协待类似调用函数.对象有()时是可调用的.对象支持协待()时,就是可等待的.协待后的式为可等待式.

总是挂起
协待 从不挂起;
空 测试(){
  协待 总是挂起{};
}//错误,缺少承诺类型.

协待必须在协程中,协程必须要有承诺类型.通过它返回内外通信对象.

构 任务{//任务
  构 承诺类型{
    任务 取中对象(){中{协程句柄<任务::承诺类型>::从承诺(*本)};}
    从不挂起 初始挂起(){中{};}
    从不挂起 止挂起()无异{中{};}
    空 中空(){}
    空 未处理异常(){}
  };

  协程句柄<任务::承诺类型>句柄_;
};

任务 测试(){
  协待 总是挂起{};//.1
}

.1转换为前面见过的模板框架代码:

{//
  动&&值=总是挂起{};
//先取表达式值.
  动&&w=取可等待(承诺,静转<推导(值)>(值));
//然后取`可等待`.
  动&&等待器=取等待器(静转<推导(w)>(w));
  如(!等待器.准备好协())
  {
    用 句柄型=实验::协程句柄
;
    用 等待挂起果型=推导(等待器.挂起协(句柄型::从承诺(p)));
    <挂起协程>
    如 常式(是空值<等待挂起果型>)
    {
      等待器.挂起协(句柄型::从承诺(p));
      <返回到调用者或恢复者>
    } 异 {
      静断(是相同值<等待挂起果型,极>,
         "挂起协()必须中'空'或'极'.");

      如(等待器.挂起协(句柄型::从承诺(p)))
      {
        <返回到调用者或恢复者>
      }
    }

    <恢复点>
  }

  中 等待器.恢复协();
}
//取可等待的代码
元<类 P,类 T>
推导(动)取可等待(P&承诺,T&&式)
{
  如 常式(有任何等待转换成员值
)
    中 承诺.等待转换(静转(式));
  异
    中 静转(式);
}

如果协程的承诺中定义了await_transform,那么就调用它来得到可等待,否则就按可等待返回自己,这里,未在task里面定义await_transform,因此总是挂起将为可等待,实现代码:

构 总是挂起{
    常式 极 准备好协()常 无异 中 假;
    常式 空 挂起协(协程句柄<>)常 无异{}
    常式 空 恢复协()常 无异{}
};

取了总是挂起后,再根据它来取等待器,代码:

元<类 W>
推导(动)取等待器(W&&w)
{
  如 常式(有成员操作符协待值)
    中 静转(w).符号 协待();
    //有自身的`协待
  异 如 常式(无成员操作符协待值)
    中 符号 协待(静转(w));//全局协待
  异
    中 静转(w);//自身转为`等待器`.
}

等待器是可等待的返回对象.1,用专门带约束对象来实现挂起协程和取协程返回值.2,灵活性和扩展性.可等待作为间接层,保存协待环境,可做更多事情.
等待器必须实现准备好等待(.1)/挂起等待(.2)/恢复等待(.3).
.1为假,就挂起协程,调用.2.如果.2返回真/空,就返回到调用者.返回假,就执行协待下面语句..1为真,说明执行完协程,调用.3返回协程结果.

构 任务{
  构 承诺类型{
    任务 取中对象(){中{协程句柄<任务::承诺类型>::从承诺(*本)};}
    从不挂起 初始挂起(){中{};}
    从不挂起 止挂起()无异{中{};}
    空 中空(){ 输出<<"取协程结果n"; }//5
    空 未处理异常(){}
  };

  协程句柄<任务::承诺类型>句柄_;//外部控制.
};

任务 测试(){
  输出<<"创建协程n";//1
  协待 总是挂起{};//在这里挂起了.
  输出<<"这是恢复点n";//4
}
整 主(){
  动 t=测试();输出<<"现在返回调用者n";//2
  输出<<"调用者恢复挂起协程n";t.句柄_();//3
  输出<<"消灭协程n";//6
}

可定义等待器,控制它的.1和.2来控制协程.
一般在.2中发起异步操作,此时协程是挂起的.返回调用者不阻塞.完成异步操作后,通过.3返回协程返回值,并恢复协程.结束协待,调用者拿到结果.