c++懒协程

原文
前面的同步,用的是共针来共享同步/承诺,中值是置该值就拿到协程返回值了.
用T,而承诺用其引用,也可以.
还可让,同步持有协程句柄,取时从句柄的承诺中返回值.止挂起返回永不挂起,则立即释放协程,此时,要返回总是挂起.

元<型名 T>构 同步1{
公:
  构 承诺类型;
  同步1(协程句柄<承诺类型>句柄)
    :m句柄(句柄){
    输出<<"构造同步对象"<<行尾;
  }//用句柄构造同步1.

  ~同步1(){
    输出<<"析构同步对象"<<行尾;
    m句柄.消灭();
  }

  T 取(){
    输出<<"取该返回值..."<<行尾;
    中 m句柄.承诺().值;
  }这里取协程返回值.
  构 承诺类型{
    T 值={};
    承诺类型(){
      输出<<"创建承诺"<<行尾;
    }
    ~承诺类型(){
      输出<<"析构承诺"<<行尾;
    }
    动 取中对象(){
      中 同步1<T>{协程句柄<承诺类型>::从承诺(*本)};
    }
    动 初始挂起(){
      输出<<"开始协程"<<行尾;中 从不挂起{};
    }
    空 返回值(T v){
      输出<<"取协程结果"<<v<<行尾;值=v;
    }
    动 止挂起()无异{
      输出<<"完成协程"<<行尾;中 总是挂起{};
    }//变成总是挂起了.
    空 未处理异常(){退出(1);}
  };

  协程句柄<承诺类型>m句柄;
};

同步1<整>我协程2(){
  输出<<"执行协程函数体"<<行尾;协中 42;
}

永不挂起,自动释放.总是挂起,要手动调用句柄.消灭().
懒执行协程,在希望执行时执行的协程.则创建时要挂起,执行时恢复.

元<型名 T>构 懒{
公:
  构 承诺类型;
  懒(协程句柄<承诺类型>句柄)
    :m句柄(句柄){
    输出<<"构造同步对象"<<行尾;
  }

  ~懒(){
    输出<<"析构同步对象"<<行尾;m句柄.消灭();
  }

  T 取(){
    输出<<"I想现在执行协程"<<行尾;
    m句柄.恢复();
    输出<<"取中值..."<<行尾;
    中 m句柄.承诺().值;
  }//这里取协程返回值.
  构 承诺类型{
    T 值={};
    承诺类型(){输出<<"创建承诺"<<行尾;}
    ~承诺类型(){输出<<"析构承诺"<<行尾;}
    动 取中对象(){
      中 懒<T>{协程句柄<承诺类型>::从承诺(*本)};
    }
    动 初始挂起(){
      输出<<"开始协程"<<行尾;中 总是挂起{};
    }//总是挂起.

    动 止挂起()无异{
      输出<<"完成协程"<<行尾;中 总是挂起{};
    }//变成总是挂起了.

    空 返回值(T v){
      输出<<"取协程结果"<<v<<行尾;值=v;
    }

    空 未处理异常(){退出(1);}
  };

  协程句柄<承诺类型>m句柄;
};

懒<整>我协程3(){
  输出<<"执行协程函数体"<<行尾;协中 42;
}

整 主(){
  动 协程=我协程3();
  动 结果=协程.取();//开始执行
  输出<<"协程结果:"<<结果<<行尾;
}

此时,在当前线程执行,在外部线程/线程池执行时,要用协待.
可等待与承诺合作,实现想法.