如何展开嵌套的std::future？现有实现对std::future<void>存在问题

嘿，我来帮你搞定这个嵌套future展开的问题！你的核心需求是把多层嵌套的std::future/std::shared_future（比如std::future<std::future<std::shared_future<int>>>）展开成最内层类型的std::future，同时正确处理void类型的变体。咱们先分析下当前实现的问题，再给出修复方案。

当前实现的问题点 #

你的detail::get函数在处理void类型的future时，直接返回wait()的结果（也就是void），但在递归嵌套场景下，比如处理std::future<std::future<void>>时，内层的get调用会返回void，这会导致外层的模板推导出现问题——因为std::future<void>::get()返回void，而你的模板版本get(std::future<T>&&)期望T是一个可get()的类型，但void显然不符合。另外，fold函数里用std::async包装其实没必要，我们可以直接递归展开，避免额外的异步包装开销。

修复后的实现方案 #

我们可以通过模板特化和递归类型推导来正确处理所有嵌套future（包括void类型），同时区分std::future和std::shared_future：

#include <future>
#include <type_traits>

namespace detail {
    // 基础情况：非future类型直接返回
    template <typename T>
    struct fold_future {
        using type = T;
        static type apply(T&& val) {
            return std::forward<T>(val);
        }
    };

    // 特化处理std::future<T>
    template <typename T>
    struct fold_future<std::future<T>> {
        using inner_type = typename fold_future<T>::type;
        using type = std::future<inner_type>;

        static type apply(std::future<T>&& f) {
            if constexpr (std::is_void_v<inner_type>) {
                // 处理void情况：先等待内层future完成，再返回空的future
                f.get();
                return std::async(std::launch::deferred, [](){});
            } else {
                // 非void情况：递归展开后包装成future
                return std::async(std::launch::deferred, 
                    [val = fold_future<T>::apply(std::move(f).get())]() mutable {
                        return std::move(val);
                    });
            }
        }
    };

    // 特化处理std::shared_future<T>
    template <typename T>
    struct fold_future<std::shared_future<T>> {
        using inner_type = typename fold_future<T>::type;
        using type = std::shared_future<inner_type>;

        static type apply(std::shared_future<T> f) {
            if constexpr (std::is_void_v<inner_type>) {
                f.get();
                return std::async(std::launch::deferred, [](){}).share();
            } else {
                return std::async(std::launch::deferred, 
                    [val = fold_future<T>::apply(f.get())]() {
                        return val;
                    }).share();
            }
        }
    };

    // 处理void的基础特化（当最内层是void时）
    template <>
    struct fold_future<void> {
        using type = void;
        static type apply(void) {}
    };
}

template <typename Future>
auto fold(Future&& f) {
    return detail::fold_future<std::decay_t<Future>>::apply(std::forward<Future>(f));
}

关键改进点 #

• 类型递归推导：通过fold_future结构体的递归特化，自动展开所有嵌套的std::future和std::shared_future，直到得到最内层的类型（包括void）。
• void类型的正确处理：当最内层是void时，我们通过std::async(deferred, [](){})创建一个空的std::future<void>，确保返回类型符合要求，同时正确等待所有嵌套future完成。
• 避免冗余异步包装：只有在需要时才用std::async(deferred)包装结果，保证展开后的future行为和原始嵌套future一致——等待所有内层操作完成后才能获取结果。
• 支持std::shared_future：单独特化处理std::shared_future，返回对应的std::shared_future<inner_type>，保持共享特性。

测试示例 #

#include <iostream>

void foo(std::future<int> f) {
    std::cout << "Got int: " << f.get() << std::endl;
}

void bar(std::future<void> f) {
    std::cout << "Void future completed" << std::endl;
    f.get();
}

int main() {
    // 测试嵌套int future
    auto nested_int = std::async(std::launch::deferred, [](){
        return std::async(std::launch::deferred, [](){
            return std::shared_future<int>(std::async(std::launch::deferred, [](){ return 42; }));
        });
    });
    foo(fold(std::move(nested_int)));

    // 测试嵌套void future
    auto nested_void = std::async(std::launch::deferred, [](){
        return std::async(std::launch::deferred, [](){
            return std::shared_future<void>(std::async(std::launch::deferred, [](){ std::cout << "Inner void done\n"; }));
        });
    });
    bar(fold(std::move(nested_void)));

    return 0;
}

这个实现应该能完美处理所有嵌套future的情况，包括void类型的变体。

内容的提问来源于stack exchange，提问作者ronag