C++ 如何从一个函子元组返回一个返回值元组？ namespace-easy\u-random{ 模板 自动生成随机数的元组（第一个）{ 返回std:：make_tuple（first（））； } 模板 自动生成随机数的元组（第一，其余…其余）{ return std：：tuple_cat（第一个是make_tuple_，第二个是make_tuple_）； } 模板 自动生成随机数的元组（标准：：大小，第一个）{ 返回std:：make_tuple（第一个（n））； } 模板 自动生成随机数据的组（标准：：大小、第一、剩余、剩余）{ return std:：tuple_cat（n，first，n，rands的make_tuple_，n，rest…）； } 模板 类多随机流{ std：：元组流； 公众： 显式多随机流（随机流类型…参数）； 显式多随机流（std:：tuple和args）； 自动运算符（）； 自动运算符（）（标准：：大小\u t n）； }; 模板 多随机流：：多随机流（随机流类型…args）：流（args…{} 模板 多随机流：：多随机流（std：：tuple和args）：流（args）{} 模板 自动多重随机流：：运算符（）（）{ return std:：apply（生成随机、流的元组）； } 模板 自动多重随机流：：运算符（）{ 返回std：：apply（生成随机变量的tuple，std：：tuple_cat（std：：生成tuple（n），streams））； } }

我希望能够返回一个元组，该元组由作为functor运行tup成员的返回值组成

我现在不知道该怎么做。我曾尝试在tuple_cat中使用apply和recursion，但在推导函数的模板类型时遇到了问题

---

编辑：要包含我试图实现的完整类，可能会暴露我的错误。

回答上面的评论：我只需使用

std:：apply（）

将元组展开为可变lambda。然后，您可以将元组元素作为参数包接收，并将其展开为初始化器列表，该列表通过调用每个元素生成一个新元组：

    namespace easy_random {

    template<typename First_T>
    auto make_tuple_of_rands(First_T first) {
        return std::make_tuple(first());
    }

    template<typename First_T, typename... Rest_T>
    auto make_tuple_of_rands(First_T first, Rest_T... rest) {
        return std::tuple_cat(make_tuple_of_rands(first),make_tuple_of_rands(rest...));
    }

    template<typename First_T>
    auto make_tuple_of_n_rands(std::size_t n, First_T first) {
        return std::make_tuple(first(n));
    }

    template<typename First_T, typename... Rest_T>
    auto make_tuple_of_n_rands(std::size_t n, First_T first, Rest_T... rest) {
        return std::tuple_cat(make_tuple_of_n_rands(n, first), make_tuple_of_n_rands(n, rest...));
    }



    template<typename... RandStreamTypes>
    class multi_rand_stream {
        std::tuple<RandStreamTypes...> streams;
    public:
        explicit multi_rand_stream(RandStreamTypes... args);

        explicit multi_rand_stream(std::tuple<RandStreamTypes...> &args);

        auto operator()();

        auto operator()(std::size_t n);
    };

    template<typename... RandStreamTypes>
    multi_rand_stream<RandStreamTypes...>::multi_rand_stream(RandStreamTypes... args) : streams(args...) {}

    template<typename... RandStreamTypes>
    multi_rand_stream<RandStreamTypes...>::multi_rand_stream(std::tuple<RandStreamTypes...> &args) : streams(args) {}

    template<typename... RandStreamTypes>
    auto multi_rand_stream<RandStreamTypes...>::operator()() {
        return std::apply(make_tuple_of_rands, streams);
    }

    template<typename... RandStreamTypes>
    auto multi_rand_stream<RandStreamTypes...>::operator()(std::size_t n) {
        return std::apply(make_tuple_of_n_rands, std::tuple_cat(std::make_tuple(n), streams));
    }
}

模板
类多_函子
{
std:：tuple-tup；
公众：
自动运算符（）（）
{
返回标准：：应用（[]（自动和…参数）
{
返回std:：tuple{args（）…}；
}，tup）；
}
};

以上评论的答案：我只需使用

std:：apply（）

将元组展开为可变lambda。然后，您可以将元组元素作为参数包接收，并将其展开为初始化器列表，该列表通过调用每个元素生成一个新元组：

    namespace easy_random {

    template<typename First_T>
    auto make_tuple_of_rands(First_T first) {
        return std::make_tuple(first());
    }

    template<typename First_T, typename... Rest_T>
    auto make_tuple_of_rands(First_T first, Rest_T... rest) {
        return std::tuple_cat(make_tuple_of_rands(first),make_tuple_of_rands(rest...));
    }

    template<typename First_T>
    auto make_tuple_of_n_rands(std::size_t n, First_T first) {
        return std::make_tuple(first(n));
    }

    template<typename First_T, typename... Rest_T>
    auto make_tuple_of_n_rands(std::size_t n, First_T first, Rest_T... rest) {
        return std::tuple_cat(make_tuple_of_n_rands(n, first), make_tuple_of_n_rands(n, rest...));
    }



    template<typename... RandStreamTypes>
    class multi_rand_stream {
        std::tuple<RandStreamTypes...> streams;
    public:
        explicit multi_rand_stream(RandStreamTypes... args);

        explicit multi_rand_stream(std::tuple<RandStreamTypes...> &args);

        auto operator()();

        auto operator()(std::size_t n);
    };

    template<typename... RandStreamTypes>
    multi_rand_stream<RandStreamTypes...>::multi_rand_stream(RandStreamTypes... args) : streams(args...) {}

    template<typename... RandStreamTypes>
    multi_rand_stream<RandStreamTypes...>::multi_rand_stream(std::tuple<RandStreamTypes...> &args) : streams(args) {}

    template<typename... RandStreamTypes>
    auto multi_rand_stream<RandStreamTypes...>::operator()() {
        return std::apply(make_tuple_of_rands, streams);
    }

    template<typename... RandStreamTypes>
    auto multi_rand_stream<RandStreamTypes...>::operator()(std::size_t n) {
        return std::apply(make_tuple_of_n_rands, std::tuple_cat(std::make_tuple(n), streams));
    }
}

模板
类多_函子
{
std:：tuple-tup；
公众：
自动运算符（）（）
{
返回标准：：应用（[]（自动和…参数）
{
返回std:：tuple{args（）…}；
}，tup）；
}
};

这不仅仅是一个“如何扩展变量”的问题。我试图将结果组合成一个元组，输出是可变类型的，具体取决于函子的结果类型。编译器很不高兴。你是真的看了用例，还是仅仅看到了三个点，并认为我忽略了显而易见的东西？怎么样？经典的标签调度，使用索引序列折叠元组。我认为索引序列位是我需要的缺失部分。让我试着将其应用到我的实现中。不幸的是，我不能再发布和回答了，但我会简单地使用

std:：apply

将元组展开为可变lambda。在那里，您可以将元组元素作为参数包接收，您可以将其展开为初始化器列表，该列表通过调用每个元素生成新的元组。这里的示例：：D很高兴我能帮忙；）这不仅仅是一个“如何扩展变量”的问题。我试图将结果组合成一个元组，输出是可变类型的，具体取决于函子的结果类型。编译器很不高兴。你是真的看了用例，还是仅仅看到了三个点，并认为我忽略了显而易见的东西？怎么样？经典的标签调度，使用索引序列折叠元组。我认为索引序列位是我需要的缺失部分。让我试着将其应用到我的实现中。不幸的是，我不能再发布和回答了，但我会简单地使用

std:：apply

将元组展开为可变lambda。在那里，您可以将元组元素作为参数包接收，您可以将其展开为初始化器列表，该列表通过调用每个元素生成新的元组。这里的示例：：D很高兴我能帮忙；）很抱歉，我说得有点晚了，但不管怎样，我都会给你信用。@KotoroShinoto不用担心，希望它能回答你的问题…；-）很抱歉，我说得有点晚了，但不管怎样，我都会给你信用。@KotoroShinoto不用担心，希望它能回答你的问题…；-）