c++中需用std::promise+std::shared_ptr构建安全链式节点实现异步任务依赖执行：第一步声明shared_ptr管理的promise与future；第二步值捕获shared_ptr启动上游任务；第三步同法声明下游promise；第四步detach线程中move捕获future和promise并处理异常；最后封装task_then模板函数支持链式调用。
要在C++中让多个异步任务按依赖顺序自动执行，而不是写一堆嵌套的std::async加手动wait，就得绕过std::future本身不支持.then()的硬伤——它get()就阻塞、只能调用一次、没有就绪通知，硬连会触发std::future_error: No state或悬空引用崩溃。
用std::promise+std::shared_ptr手动构建安全链式节点
这一步解决最基础也最易崩的场景：两个任务A→B，B必须等A结果才能启动，且不能因栈上promise析构导致set_value写入已释放内存。
第一步：声明上游任务并获取其future，用std::make_shared包住promise，确保生命周期可控：
auto p1 = std::make_shared<:promise>>();
auto f1 = p1->get_future();
第二步：启动A任务，在独立线程中完成计算后调用p1->set_value(42)；注意此处必须用值捕获p1，不能用[&p1]——否则lambda可能在p1析构后才执行，触发未定义行为。
第三步：定义下游任务B的promise，同样用shared_ptr管理：
auto p2 = std::make_shared<:promise>>();
auto f2 = p2->get_future();
第四步：用std::thread启动B的执行逻辑，捕获f1和p2（都用std::move）：
std::thread([f1 = std::move(f1), p2 = std::move(p2)]() mutable {
try {
int x = f1.get();
p2->set_value(std::to_string(x * 2));
} catch (...) {
p2->set_exception(std::current_exception());
}
}).detach();
【p2必须是std::shared_ptr，不能是栈对象】因为detach后的线程可能在当前作用域结束之后才运行，栈上promise早已销毁。
封装task_then模板函数实现语法糖
每次手写thread+shared_ptr太啰嗦，封装成通用函数可复用，关键是规避三个坑：future移动、异常传播、promise生命周期。
方法一：直接返回std::future，内部用std::async调度（适合轻量短任务）：
template
auto task_then(std::future
std::promise
auto ret = p.get_future();
std::async(std::launch::async, [f = std::move(f), func = std::move(func), p = std::move(p)]() mutable {
try {
p.set_value(func(f.get()));
} catch (...) {
p.set_exception(std::current_exception());
}
});
return ret;
}
组合式C++代码评审方案，融合静态分析、AI推理、多轮迭代评审和C++专项检查，适用于PR审查、增量代码审查、全项目评审和代码质量评分，触发词包括review cpp、cpp代码评审、C++review、代码审查。
方法二：改用std::thread+detach，避免std::async的调度不可控问题（推荐用于生产环境）：
将上述async替换为std::thread(...).detach()，其余不变；但注意：detach线程需自行保证资源释放，不可依赖局部变量。
调用时链式写法自然：
auto f = std::async([]{ return 10; });
auto g = task_then(std::move(f), [](int x) { return x + 5; });
auto h = task_then(std::move(g), [](int x) { return std::to_string(x); });
std::cout
用C++20协程实现原生await链式流
如果你的编译器支持C++20且项目允许引入协程，这是代码最直观的方案——不用回调、不手动管理线程，靠co_await挂起等待，像写同步代码一样表达异步依赖。
先让std::future可被co_await：特化operator co_await，返回一个自定义awaitable对象，该对象的await_suspend必须把当前协程handle存起来，等future就绪时resume它。
定义awaiter结构体：
template
struct future_awaiter {
std::future
bool await_ready() const noexcept { return fut.wait_for(std::chrono::seconds(0)) == std::future_status::ready; }
void await_suspend(std::coroutine_handle h) {
std::thread([fut = &fut, h]() mutable {
fut->wait();
h.resume();
}).detach();
}
T await_resume() { return fut.get(); }
};
再为std::future
template
future_awaiter
最后写协程函数：
struct task { struct promise_type { task get_return_object() { return {}; } auto initial_suspend() { return std::suspend_always{}; } auto final_suspend() noexcept { return std::suspend_always{}; } void return_void() {} void unhandled_exception() {} }; };
task async_flow() {
auto f1 = std::async([]{ return 100; });
int x = co_await f1;
auto f2 = std::async([x]{ return x * 2; });
int y = co_await f2;
std::cout }
注意：await_suspend里用detach线程只是演示，真实项目应投递到io_context或线程池，避免无节制创建线程。
C++免费学习笔记（深入）：立即使用
在学习笔记中，你将探索 C++ 的入门与实战技巧！
