原文

一般回调

#包含<io流>

元<类 完成处理器>
空 异步加(整 a,整 b,完成处理器&&处理器){
    标::前向<完成处理器>(处理器)(a+b);
}

整 主(){
    异步加(1,2,[](整 n){
        标::输出<<"回调:"<<n<<标::行尾;
    });
    //等待从异步操作返回..
}

支持完成令牌

为了无影响的用不同方式调用异步操作.要提供更加通用的抽象接口.
然后隐藏原接口,即放入私有名字空间.

引入async_result的适配层来转发或修改用户的调用形式,使其既符合用户期望,又能转换到原始异步调用.它有两个模板参数:

完成令牌:用户期望的回调形式.
签名:需要适配成原始异步操作的回调签名.

适配层的主要工作由initiate()函数来完成.它有三个参数来转发用户的输入:

1,initiation:原始异步函数,这是个模板函数,难以作为参数传递,所以需要封装成函数对象,如async_add_op.
2,token:用户期望的回调形式实例,即完成令牌,如果只是转发则就是原始异步函数的回调实例.
3,args...:异步操作的输入参数,原样转发给原始异步函数.
所以,可见async_result只是普通转发,闲着,对原使用原始异步操作函数的用户没有影响.

#包含<io流>

名字空间 细节{

元<类 完成处理器>
空 异步加(整 a,整 b,完成处理器&&处理器){
    标::前向<完成处理器>(处理器)(a+b);
}

构 异步加操作{
    元<类 完成处理器>
    空 符号()(整 a,整 b,完成处理器&&处理器)常{
        中 细节::异步加(a,b,标::前向<完成处理器>(处理器));
    }
};

}// namespace detail

// 转发调用
元<类 完成令牌,类 特征>
构 异步结果
{
    元<类 启动, 类 原始完成令牌, 类...实参>
    静 动 初化(启动&&启动, 原始完成令牌&&令牌, 实参&&...实参)
    {
        中 标::前向<启动>(启动)(标::前向<实参>(实参)..., 标::前向<原始完成令牌>(令牌));
    }
};

// 用户接口
元<类 完成令牌>
动 异步加(整 a,整 b,完成令牌 令牌){
    用 特征型=空(整);
    用 结果型=异步结果<完成令牌,特征型>;
    中 结果型::初化(细节::异步加操作{}, 令牌, a, b);
}

整 主(){
    // 转发调用的回调
    异步加(1,2,[](整 n){
        标::输出<<"回调:"<<n<<标::行尾;
    });
    // 等待异步操作返回...
}

定制完成令牌

接下来,要动点手脚了.为了使原来的异步操作函数支持未来连续的调用形式,可以使用类模板偏特化来定制async_result实现适配.

#包含<未来>
#包含<元组>
#包含<类型特征>

// 未来
常式 构 用未来型{}用未来;

元<类 R,类...右参>
构 异步结果<用未来型,R(右参...)>
{
    元<类 启动, 类...实参>
    静 动 初化(启动&&启动, 用未来型, 实参&&...实参)
    {
        标::承诺<标::元组<标::移除常易引用型<右参>...>>p;
        动 未来=p.取未来();

        动 处理器=[pp=标::移动(p)](右参...右参)可变{
            pp.置值(标::造元组(右参...));
        };
        标::前向<启动>(启动)(标::前向<实参>(实参)..., 标::移动(处理器));
        中 未来;
    }
};

整 主(){
    // 未来
    动 未来=异步加(1,2,用未来);
    动[n]=未来.取();
    标::输出<<"未来:"<<n<<标::行尾;
}