我一直在从事一个名为:C++11/14 的函数式编程特性(针对我在大学的一个科目)的项目。 关于这些主题有几个现有的资源和类似的介绍，我找到了一个 不久前，其中包含几个我还没有完全理解的代码片段(并且它们可以以某种方式连接到函数式编程)。片段 A 和 B 属于递归，C 属于惰性求值。我想在下面与您分享:

片段A:

#include <iostream>

template <int N>
struct Factorial {
    static int const val = N * Factorial<N - 1>::val;
};

template <>
struct Factorial <0> {
    static int const val = 1;
};

int main() {
    int factorial_of_6 = Factorial<6>::val;
    std::cout << factorial_of_6 << std::endl;
    return 0;
}

这里的重点是编译时评估(为了避免运行时计算并提高性能)吗？ 或者还有其他优势吗？

片段 B:

#include <iostream>

template <int ...>
struct my_sum;

template <>
struct my_sum <> {
    static const int value {0};
};

template <int i, int ... tail>
struct my_sum <i, tail ...> {
    static const int value = i + my_sum<tail ...>::value;
};

int main() {
    int sum {my_sum<1, 2, 3, 4, 5>::value};
    std::cout << sum << std::endl;
    return 0;
}

同样的问题适用于上面。

这是另一个可能类似的片段:

片段 C:

#include <iostream>

template <typename... Args>
void some_function (Args ...) {
    std::cout << sizeof...(Args) << std::endl;
}

int main() {
    some_function ("Every little thing gonna be alright...", 1.0 / 0.0);
    return 0;
}

“演示文稿说:C++ 很急切，但以下内容会起作用。” 它的意思是，除非我不关心给定的表达式，否则我可以说出它们的数量吗？

请尽可能具体和详细，非常感谢您提前的耐心和帮助。 :)

最佳答案

片段A

这叫做 Template Metaprogramming ，这基本上是一种在编译时使用模板生成代码的技术。这会提高运行时性能，因为计算不是在运行时完成，而是在编译时完成。

片段 A 在编译时计算给定数字的阶乘:

template <int N>
struct Factorial {
    static int const val = N * Factorial<N - 1>::val;
};

这定义了一个 struct Factorial作为采用 int 的模板.在那struct , 有一个 static const多变的。变量是 static , 这样您就不必创建 Factorial 的实例要访问它，您可以使用 Factorial::val而不是

Factorial factorial;
factorial.val;

变量是const因为给定数字的阶乘总是相同的，而且如果不是 const，项目将无法编译。 ，因为编译器无法知道您是否在其他地方更改了变量。

变量的值为N * Factorial<N - 1::val; , 基本上乘以 N与前一个数字的阶乘。这是因为阶乘的定义方式 (3! = 2! * 3 = 1! * 2 * 3 = 1 * 2 * 3 = 6)。

template <>
struct Factorial <0> {
    static int const val = 1;
};

这定义了一个完全特化的 struct对于 N = 0 .这一点非常重要，否则之前函数中使用的递归将永远不会停止。

然后，获取数字的阶乘 N很简单，Factorial<N>::val .这将在编译时计算。

这也是 Template Metaprogramming .

template <int ...>
struct my_sum;

这定义了一个空模板 struct这需要 int... (a Parameter Pack )，以便它可以专门化(见下一点)。

template <>
struct my_sum <> {
    static const int value {0};
};

这专门针对 struct my_sum , 当没有给出模板参数时(这是因为 Parameter Pack 可以为空，因此当 Parameter Pack 展开时模板参数将为空)。 value是static和 const由于与之前相同的原因，它是0使用 initializer list 初始化(对于 int ， int i = 0; 和 int i{ 0 }; 之间没有区别)。

template <int i, int ... tail>
struct my_sum <i, tail ...> {
    static const int value = i + my_sum<tail ...>::value;
};

这定义了 struct my_sum作为一个接受 2 个模板参数的模板，一个 int和一个 int参数包。这用于获取参数包的第一个值的值，因为您无法索引参数包(它不是数组)。然后，value初始化为 i (包的第一个值)加上 value将其他值作为参数包进行扩展(使用 ... ):

int sum = my_sum<1, 2, 3>::value;

这调用了 my_sum<int i, int... tail> , i是1和 tail是2, 3 . value是i + my_sum<tail...>::value , 所以它是 1 + my_sum<2, 3> . my_sum<2, 3>再次调用相同的函数，2 + my_sum<3>::value .现在我们有 1 + 2 + my_sum<3>::value . my_sum<3>::value再次调用相同的函数，但现在参数包为空!所以value是1 + 2 + 3 + my_sum<>::value . my_sum<>::value是0 (定义)等等 value = 1 + 2 + 3 + 0 .

表达式已计算，但程序不会崩溃，因为计算时表达式是 double .仅当表达式为 int 时它会因 Integer division by zero exception 而崩溃吗？ .如果您要这样做:

int zero = 0; 
double d = 1.0 / zero;

然后 d将具有值 inf .

函数some_function是一个模板函数，它将参数包作为模板参数。然后它调用 sizeof...它计算参数包中的元素，并使用 std::cout 输出它.

关于C++函数式编程代码片段，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36204942/