decltype用于递归变元函数模板的返回类型

第一个选项的错误消息是由于中

std::declval<func_type>()(std::forward<Ts>(ts)...)

您试图用两个类型为double的参数（传递给operator()的参数）调用f1函子，但它需要一个std::pair（func_type指元组中第一个函子的类型）。

关于选项2，它不编译的原因是尾部返回类型是函数声明符的一部分，并且在看到声明符的末尾之前，函数不会被视为已声明，因此不能在apply的第一个声明的尾部返回类型中使用decltype(apply(...))。

我相信你现在很高兴知道为什么你的代码没有编译，但我想如果你有一个有效的解决方案，你会更高兴。

我认为有一个重要的事实需要首先澄清：compose_impl中apply和operator()模板的所有特殊化都有相同的返回类型——在这种情况下是第一个函子f1的返回类型。

有几种方法可以获得这种类型，但快速破解如下：

#include <cstddef>
#include <type_traits>
#include <tuple>
#include <iostream>
#include <utility>
#include <functional>
template<typename> struct ret_hlp;
template<typename F, typename R, typename... Args> struct ret_hlp<R (F::*)(Args...) const>
{
    using type = R;
};
template<typename F, typename R, typename... Args> struct ret_hlp<R (F::*)(Args...)>
{
    using type = R;
};
template<typename ... Fs>
struct compose_impl
{
    compose_impl(Fs&& ... fs) : functionTuple(std::forward_as_tuple(fs ...)) {}
    using f1_type = typename std::remove_reference<typename std::tuple_element<0, std::tuple<Fs...>>::type>::type;
    using ret_type = typename ret_hlp<decltype(&f1_type::operator())>::type;
    template<size_t N, typename ... Ts>
    ret_type apply(std::integral_constant<size_t, N>, Ts&& ... ts) const
    {
        return apply(std::integral_constant<size_t, N - 1>(), std::get<N>  (functionTuple)(std::forward<Ts>(ts)...));
    }
    template<typename ... Ts>
    ret_type apply(std::integral_constant<size_t, 0>, Ts&& ... ts) const
    {
        return std::get<0>(functionTuple)(std::forward<Ts>(ts)...);
    }
    template<typename ... Ts>
    ret_type operator()(Ts&& ... ts) const
    {
         return apply(std::integral_constant<size_t, sizeof ... (Fs) - 1>(), std::forward<Ts>(ts)...);
    }
    std::tuple<Fs ...> functionTuple;
};
template<typename ... Fs>
compose_impl<Fs ...> compose(Fs&& ... fs)
{
     return compose_impl<Fs ...>(std::forward<Fs>(fs) ...);
}
int main ()
{
    auto f1 = [](std::pair<double,double> p) {return p.first + p.second;    };
    auto f2 = [](double x) {return std::make_pair(x, x + 1.0); };
    auto f3 = [](double x, double y) {return x*y; };
    auto g = compose(f1, f2, f3);
    std::cout << g(2.0, 3.0) << std::endl;   //prints '13', evaluated as (2*3) + ((2*3)+1)
    return 0;
}

注：

• 它以C++11模式在GCC 4.9.1和Clang 3.5.0上以及在Visual C++2013上编译和工作
• 正如所写的，ret_hlp只处理声明其operator()的函数对象类型，类似于lambda闭包类型，但它可以很容易地扩展到几乎任何其他类型，包括普通函数类型
• 我试图尽可能少地更改原始代码；我认为关于该代码有一个重要的地方需要提及：如果compose被赋予了左值参数（如本例所示），compose_impl中的functionTuple将存储对这些参数的引用。这意味着只要使用复合函子，原始函子就必须可用，否则就会有悬空引用

编辑：以下是评论中要求的关于最后一条注释的更多信息：

这种行为是由于转发引用的工作方式——compose的Fs&& ...函数参数。如果您有一个形式为F&&的函数参数，正在对其进行模板参数推导（如这里所示），并且为该参数提供了一个类型为A的参数，那么：

• 如果参数表达式是右值，则F被推导为A，并且当被替换回函数参数时，它给出A&&（例如，如果将lambda表达式直接作为参数传递给compose，则会发生这种情况）
• 如果自变量表达式是左值，则F被推导为A&，并且当代入函数参数时，它给出A& &&，根据引用折叠规则产生A&（这就是当前示例中发生的情况，因为f1和其他都是左值）

因此，在当前示例中，compose_impl将使用推导出的模板参数进行实例化，类似于（为lambda闭包类型使用虚构的名称）

compose_impl<lambda_1_type&, lambda_2_type&, lambda_3_type&>

从而使CCD_ 31具有类型

std::tuple<lambda_1_type&, lambda_2_type&, lambda_3_type&>

如果您将lambda表达式作为参数直接传递给compose，那么根据上面的内容，functionTuple将具有类型

std::tuple<lambda_1_type, lambda_2_type, lambda_3_type>

因此，只有在后一种情况下，元组才会存储函数对象的副本，从而使组合的函数对象类型成为自包含的。

现在，问题不在于这是好是坏；这是一个你想要什么的问题。

如果您希望组合的对象始终是自包含的（存储函子的副本），那么您需要去掉这些引用。这里的一种方法是使用std::decay，因为它不仅可以删除引用，还可以处理函数到指针的转换，如果您想将compose_impl扩展为能够处理普通函数，这将非常有用。

最简单的方法是更改functionTuple的声明，因为它是当前实现中唯一关心引用的地方：

std::tuple<typename std::decay<Fs>::type ...> functionTuple;

结果是，函数对象将始终在元组中复制或移动，因此即使在原始组件被破坏后，也可以使用所生成的组合函数对象。

哇，时间变长了；也许你不应该说"精心设计"：-）。

编辑OP的第二条注释2：是的，没有std::decay的代码（但正如您所说，扩展为正确确定普通函数参数的ret_type）将处理普通函数，但要小心：

int f(int) { return 7; }
int main()
{
    auto c1 = compose(&f, &f); //Stores pointers to function f.
    auto c2 = compose(f, f); //Stores references to function f.
    auto pf = f; //pf has type int(*)(int), but is an lvalue, as opposed to &f, which is an rvalue.
    auto c3 = compose(pf, pf); //Stores references to pointer pf.
    std::cout << std::is_same<decltype(c1.functionTuple), std::tuple<int(*)(int), int(*)(int)>>::value << 'n';
    std::cout << std::is_same<decltype(c2.functionTuple), std::tuple<int(&)(int), int(&)(int)>>::value << 'n';
    std::cout << std::is_same<decltype(c3.functionTuple), std::tuple<int(*&)(int), int(*&)(int)>>::value << 'n';
}

c3的行为可能不是你想要的，也不是人们所期望的。更不用说所有这些变体可能会混淆用于确定ret_type的代码。

有了std::decay，所有三个变体都存储指向函数f的指针。