C++ 生成一个变量函数，它接受任意函子并返回输入函子每个返回值的元组

我想创建一个函数对象，它接受任意函数对象并返回一个元组，该元组存储每个函数对象的返回值

为了实现这个目标，我做了一个

a级

class A
{
private:
    template <class Ret, class Func>
    auto impl(Ret ret, Func func) -> decltype(tuple_cat(ret, make_tuple(func())))
    {
        return tuple_cat(ret, make_tuple(func()));
    }

    template <class Ret, class First, class... Funcs>
    auto impl(Ret ret, First first, Funcs... funcs) 
    -> decltype(impl(tuple_cat(ret, make_tuple(first())), funcs...))
    {
    return impl(tuple_cat(ret, make_tuple(first())), funcs...);
    }

public:
    template <class Func>
    auto operator()(Func func) -> decltype(make_tuple(func()))
        {
        return make_tuple(func());
    }

    template <class First, class... Funcs>
    auto operator()(First first, Funcs... funcs)
     -> decltype(impl(make_tuple(first()),funcs...))
    {
        impl(make_tuple(first()),funcs...);
    }
};

A类
{
私人：
模板
自动执行（Ret-Ret，Func-Func）->decltype（tuple\u cat（Ret，make\u tuple（Func（）））
{
返回tuple_cat（ret，make_tuple（func（））；
}
模板
自动执行（Ret Ret，First First，Funcs…Funcs）
->decltype（impl（tuple\u cat（ret，make\u tuple（first（））），funcs…）
{
返回impl（tuple\u cat（ret，make\u tuple（first（））），funcs；
}
公众：
模板
自动运算符（）（Func Func）->decltype（生成元组（Func（））
{
返回make_tuple（func（））；
}
模板
自动运算符（）
->decltype（impl（make_tuple（first（）），funcs…）
{
impl（make_tuple（first（）），funcs；
}
};

在主函数中，我制作了三个lambda

int main(){
    auto func1 = [](){ cout << 1 << endl; return 1;};
    auto func2 = [](){ cout << 2 << endl; return 2;};
    auto func3 = [](){ cout << 3 << endl; return 3;};

    A a;
    auto x = a(func1, func2);
    cout << "ans : " << get<0>(x) << get<1>(x) << endl; // I expect ans : 12
}

intmain（）{
auto func1=[]（）{cout我认为问题在于缺少一个
return
语句：

template <class First, class... Funcs>
auto operator()(First first, Funcs... funcs)
 -> decltype(impl(make_tuple(first()),funcs...))
{
    return impl(make_tuple(first()),funcs...);
//  ^^^^^^
}

模板
自动运算符（）
->decltype（impl（make_tuple（first（）），funcs…）
{
返回impl（make_tuple（first（）），funcs；
//  ^^^^^^
}

如果没有它，代码将具有未定义的行为。根据C++11标准第6.6.3/2段：

从函数末尾流出的[…]相当于没有值的返回；这会导致值返回函数中出现未定义的行为

我认为问题在于您缺少一个
return
语句：

template <class First, class... Funcs>
auto operator()(First first, Funcs... funcs)
 -> decltype(impl(make_tuple(first()),funcs...))
{
    return impl(make_tuple(first()),funcs...);
//  ^^^^^^
}

模板
自动运算符（）
->decltype（impl（make_tuple（first（）），funcs…）
{
返回impl（make_tuple（first（）），funcs；
//  ^^^^^^
}

如果没有它，代码将具有未定义的行为。根据C++11标准第6.6.3/2段：

从函数末尾流出的[…]相当于没有值的返回；这会导致值返回函数中出现未定义的行为

显而易见的问题是，正如其他答案所指出的，您缺少一条返回语句

无论如何，我认为你做得太多了。这应该行得通：

class A
{
public:
    template <class First, class... Funcs>
    auto operator()(First first, Funcs... funcs) -> decltype((make_tuple(first(),funcs()...)))
    {
        return (make_tuple(first(),funcs()...));
    }
};

int main(){
    auto func1 = [](){ cout << 1 << endl; return 1;};
    auto func2 = [](){ cout << 2 << endl; return 2;};

    A a;
    auto x = a(func1, func2);
    cout << "ans : " << get<0>(x) << get<1>(x) << endl; // I expect ans : 12
}

A类
{
公众：
模板
自动运算符（）
{
返回（make_tuple（first（），funcs（）…）；
}
};
int main（）{
auto func1=[]（）{cout显而易见的问题是，正如其他答案所指出的，您缺少一条返回语句

无论如何，我认为你做得太多了。这应该行得通：

class A
{
public:
    template <class First, class... Funcs>
    auto operator()(First first, Funcs... funcs) -> decltype((make_tuple(first(),funcs()...)))
    {
        return (make_tuple(first(),funcs()...));
    }
};

int main(){
    auto func1 = [](){ cout << 1 << endl; return 1;};
    auto func2 = [](){ cout << 2 << endl; return 2;};

    A a;
    auto x = a(func1, func2);
    cout << "ans : " << get<0>(x) << get<1>(x) << endl; // I expect ans : 12
}

A类
{
公众：
模板
自动运算符（）
{
返回（make_tuple（first（），funcs（）…）；
}
};
int main（）{
auto func1=[]（）{cout@Andy的修复程序可以正常工作，但您可以做得更简单，而无需实现重载或帮助函数：

#include <iostream>
#include <tuple>

template<typename... Args>
auto tuple_from_funs(Args&&... args) -> std::tuple<decltype(args())...>{
    return std::make_tuple(args()...);
}

int f() { return 1; }
char g() { return '2'; }
std::string h() { return "jorge"; }

int main() {
    auto tup = tuple_from_funs(f, g, h);
    std::cout << std::get<0>(tup) << ", " << std::get<1>(tup) << ", " << std::get<2>(tup) << std::endl;
}

#包括
#包括
模板
自动元组\u from\u funs（Args&&…Args）->std:：tuple{
返回std:：make_tuple（args（）…）；
}
int f（）{return 1；}
char g（）{return'2'；}
字符串h（）{返回“jorge”；}
int main（）{
自动tup=tuple_from_funs（f，g，h）；
std:：cout@Andy的修复程序可以工作，但您可以做得更简单，无需实现重载或帮助函数：

#include <iostream>
#include <tuple>

template<typename... Args>
auto tuple_from_funs(Args&&... args) -> std::tuple<decltype(args())...>{
    return std::make_tuple(args()...);
}

int f() { return 1; }
char g() { return '2'; }
std::string h() { return "jorge"; }

int main() {
    auto tup = tuple_from_funs(f, g, h);
    std::cout << std::get<0>(tup) << ", " << std::get<1>(tup) << ", " << std::get<2>(tup) << std::endl;
}

#包括
#包括
模板
自动元组\u from\u funs（Args&&…Args）->std:：tuple{
返回std:：make_tuple（args（）…）；
}
int f（）{return 1；}
char g（）{return'2'；}
字符串h（）{返回“jorge”；}
int main（）{
自动tup=tuple_from_funs（f，g，h）；
std：：cout“但是，它没有像我预期的那样工作。”那么它是如何工作的呢？我得到了一些垃圾值。在我的计算机中，我得到了
-2 196246021
“但是，它没有像我预期的那样工作。”那么它是如何工作的呢？我得到了一些垃圾值。在我的计算机中，我得到了
-2 196246021
@Sungmin:很高兴它有帮助：-）@Sungmin:很高兴它有帮助：-）谢谢。但是，我不太明白。它是如何工作的？你能给我一些关于行
std:：make_tuple（args（））的参考资料吗
？
std:：make_tuple
只是一个函数，它接受一些可变模板参数并返回一个包含所有参数的元组。至于
args（）…
，它基本上意味着“对该参数包中的每个参数应用调用运算符，并将其展开”。这与执行
arg0（），arg1（）操作相同，arg…
。非常感谢。但是，我不太明白。它是如何工作的？你能给我一些关于行
std:：make_tuple（args（））
的参考吗？
std:：make_tuple
只是一个函数，它接受一些可变模板参数并返回一个包含所有参数的元组。
args（）…
，它的基本意思是“将调用运算符应用于此参数包中的每个参数，并将其展开”。这与执行
arg0（），arg1（）相同，arg…
。非常感谢。我刚刚看到了您的代码。它几乎与mfontanini的代码相同。因此，我想问上面相同的问题。您能给我一些关于行
make_tuple（first（），funcs（）…）的参考吗
？@Sungmin:for
std:：make\u tuple
。看一看，了解它的用法！非常感谢。我刚刚看过你的代码。它几乎和mfontanini的一样。所以，我想问上面同样的问题。你能给我一些关于
make\u tuple（first（），funcs（）…）这行的参考资料吗
？@Sungmin:for
std:：make\u tuple
。看看它，了解它的用法！