现代 C++ 函数式编程指南

  • 现代 C++ 函数式编程指南
    • 什么是 柯里化 （Curry）
    • 什么是 部分应用 （Partial Application）
      • 二元函数 （Partial Application）
      • 参数排序 （Partial Application）
        • 应用场景
          • 计算碳衰减周期求年龄
        • 多参数 （Partial Application）
        • 高阶函数 （Partial Application）
    • 结论

现代 C++ 函数式编程指南

函数式编程是一种编程范式，它强调程序的构建是通过应用(applying)和组合函数(composing functions)来实现的。在函数式编程中，程序被视为由函数定义的表达式树，这些函数将一个值映射到另一个值，而不是一系列更新程序运行状态的命令式语句。

https://en.wikipedia.org/wiki/Functional_programming

什么是 柯里化 （Curry）

一种函数，将具有多个参数的函数作为输入并返回仅具有一个参数的函数。

Curry: A function that takes a function with multiple parameters as input and returns a function with exactly one parameter.

让我们首先看一个简单的例子，展示柯里化的基本概念：

#include <print> // C++23// 柯里化函数模板
template<typename Func, typename... Args>
auto curry(Func func, Args... args) {return [=](auto... remainingArgs) {return func(args..., remainingArgs...);};
}// 示例一：加法器的柯里化
int add(int a, int b) {return a + b;
}int main() {// 使用柯里化创建新的加法函数auto curriedAdd = curry(add, 5);  // 固定第一个参数为 5// 调用柯里化后的函数std::println("{:d}", curriedAdd(3));  // 输出 8 (5 + 3)return 0;
}

这个例子中，curry 函数接受一个函数和部分参数，返回一个接受剩余参数的函数。curriedAdd 就是一个将加法函数柯里化后的结果，固定了第一个参数为 5。

什么是 部分应用 （Partial Application）

将函数应用于其某些参数的过程。 部分应用的函数将被返回以供以后使用。 换句话说，一个函数接受一个具有多个参数的函数并返回一个具有较少参数的函数。 部分应用修复（部分应用函数）返回函数内的一个或多个参数，返回函数将其余参数作为参数以完成函数应用。

Partial Application: The process of applying a function to some of its arguments. The partially applied function gets returned for later use. In other words, a function that takes a function with multiple parameters and returns a function with fewer parameters. Partial application fixes (partially applies the function to) one or more arguments inside the returned function, and the returned function takes the remaining parameters as arguments in order to complete the function application.

参考 https://en.wikipedia.org/wiki/Partial_application

注文中 特化 代指 Partial Application 。

二元函数 （Partial Application）

作为 API 创建者，我们经常希望特化功能或预填充某些参数，这可以通过部分应用来实现。

partial_application_scheme

我们提供具体论据的子集，并产生一个较小数量的函数。

我们来看一个具体的例子。

该函数计算扇形的面积。

partial_application_circle_sector

double secArea(double theta, double radius){return 0.5*theta*pow(radius,2);
}

让我们专门计算这个函数来计算整圆的面积,我们需要嵌套 lambda 来表达 部分应用(Partial Application)。

// papply 是 Partial Application 缩写的形式，p(Partial) apply(Application)
auto papply = [](auto f, auto x) {return [=](auto y){return f(x,y);};
};

为了实现特化，我们只需要传递函数及其第一个参数。

auto op = papply(secArea,2*M_PI); // 固定第一个参数为完整的圆弧长度即完整的圆
auto val = op(3.0); // 计算半径为 3 的圆的面积

partial_application_circle_sector2

在前一种情况下，特化涉及第一个函数参数。

double secArea(double rAngle, double radius);

完整代码如下：

#include <print>    // C++23
#include <numbers>  // C++20// papply 是 Partial Application 缩写的形式，p(Partial) apply(Application)
auto papply = [](auto f, auto x) {return [=](auto y) {return f(x, y);};
};// 计算圆弧的面积
double secArea(double theta, double radius) {return 0.5 * theta * pow(radius, 2);
}int main() {auto op  = papply(secArea, 2 * std::numbers::pi);  // 固定第一个参数为完整的圆弧长度即完整的圆auto val = op(3.0);                                // 计算半径为 3 的圆的面积// 使用 std::format 格式化浮点数并保留两位小数std::println("{:.2f}", val);  // 输出半径为2的圆面积 28.27return 0;
}

然而，我们常常不得不处理参数排序。

参数排序 （Partial Application）

partial_application_pow

double pow (double base, double exponent);

例如 将 pow C 库函数将基数(base)位置参数置换为指数(exponent)位置参数。

我们如何特化 pow 来返回基数(base)的 2 次方？

partial_application_pow2

下面这种特化可以解决我们上面的问题吗?

partial_application_pow3

如果我们特化 base 部分，papply 将返回一个 2 的任意幂函数。

auto op = papply(pow,2); // 2 的任意幂
auto val = op(3); // 2^3 = 8

该结果不是我们想要的。

pow 函数需要对第二个参数进行特化。

double pow (double base, double exponent);

这个问题可以通过参数交换来解决。

auto swapArgs = [] (auto f){return [=](auto x, auto y){return f(y,x);};
};
auto op = papply(swapArgs(pow), 2); // 现在2作为了指数，解决了我们上面的问题。
auto val = op(3); // 3^2 = 9

我们也可以使用特化专用于 pow 的 lambda 来解决。

auto powS = [](auto exponent, auto base){return pow(base, exponent);
};
auto op = papply(powS, 2); 
auto val = op(3); // 3^2 = 9

或者使用下面这种更加紧凑的形式。

auto op = papply([](auto exponent, auto base){return pow(base, exponent);}, 2);auto val = op(3); // 3^2 = 9

另一种选择是使用库函数 std::bind

此解决方案绕过了使用 lambda 表达式。

auto op = std::bind(pow, std::placeholders::_1, 2);
auto val = op(3); // 3^2 = 9
应用场景
计算碳衰减周期求年龄

接下来，让我们看一个关于碳衰减周期求年龄的例子：

含有有机物质的物体的年龄可以通过放射性同位素测年法确定。

partial_application_radioactive2

这是放射性衰变的一般方程

partial_application_radioactive3

double age(double remainingProportion, double halflife){return log(remainingProportion)*halflife / -log(2);
}

将半衰期替换为碳C14的半衰期，即5730年。

auto op = papply(swapArgs(age),5730);

问题1. 与活体样本相比，含有 40% C14 的化石有多少年了？

auto val = op(0.4); // 7575 years

完整代码如下：

#include <print> // C++23// papply 是 Partial Application 缩写的形式，p(Partial) apply(Application)
auto papply = [](auto f, auto x) {return [=](auto y) {return f(x, y);};
};auto swapArgs = [](auto f) {return [=](auto x, auto y) {return f(y, x);};
};double age(double remainingProportion, double halflife) {return log(remainingProportion) * halflife / -log(2);
}int main() {auto op  = papply(swapArgs(age), 5730);                  // 将半衰期替换为碳C14的半衰期，即5730年。auto val = op(0.4);                                      // 计算含有 40% C14 的化石有多少年了？std::println("{:d}", static_cast<int>(std::ceil(val)));  // 7575 yearsreturn 0;
}

与正则表达式相关的函数的特化也非常有用。

让我们专门研究 std::regex_match

std::regex_match 确定正则表达式 re 是否匹配整个字符序列 s。

bool std::regex_match( const std::string& s,const std::regex& re,std::regex_constants::match_flag_type flags =std::regex_constants::match_default);

我们如何特化使用 std::regex_match 来验证电子邮件地址？

我们使用特化的 lambda 来实现所需的参数排序

auto op = papply([](auto re, auto str){return std::regex_match(str, re);}, std::regex("(\\w+)(\\.|_)?(\\w*)@(\\w+)(\\.(\\w+))+"));
auto val1 = op("test@cheungxiongwei.com"); // return 1, i.e. true
auto val2 = op("test@cheungxiongweicom"); // return 0, i.e. false

完整代码：

#include <print>  // C++23
#include <regex>  // C++11// papply 是 Partial Application 缩写的形式，p(Partial) apply(Application)
auto papply = [](auto f, auto x) {return [=](auto y) {return f(x, y);};
};int main() {// 该例子中使用的特化 lambda 形式进行参数交换auto op   = papply([](auto re, auto str) { return std::regex_match(str, re); }, std::regex("(\\w+)(\\.|_)?(\\w*)@(\\w+)(\\.(\\w+))+"));auto val1 = op("test@cheungxiongwei.com");  // return 1, i.e. trueauto val2 = op("test@cheungxiongweicom");   // return 0, i.e. falsestd::println("{} {}", val1, val2);  // true falsereturn 0;
}

让我们继续讨论多参数问题

多参数 （Partial Application）

这是运动物体最终速度的公式。

partial_application_velocity

Note：这个函数有三个参数，而不是前面2个参数的形式

// 计算速度
double velocity(double v0/*初始速度*/, double a/*加速度*/, double t/*加速时间*/){return v0 + a*t;
}

我们如何将这个公式特化用于解决自由落体问题？

我们想要专门研究 两个参数 ：初始速度和加速度。

我们需要嵌套 lambda 和参数包。

auto papply = [](auto f, auto... args) {return [=](auto... rargs) {return f(args..., rargs...);};
};

多个参数的使用通过参数包来表示 ...

我们将其类似地应用于二元情况

partial_application_velocity2

auto op = papply(velocity, 0.0, 9.81);
auto val = op(4.5/*4.5秒加速时间*/); // returns 44.15 m/s

在这种特定情况下，不需要交换。

完整代码：

#include <print>  // C++23// papply 是 Partial Application 缩写的形式，p(Partial) apply(Application)
auto papply = [](auto f, auto... args) {return [=](auto... rargs) {return f(args..., rargs...);};
};double velocity(double v0 /*初始速度*/, double a /*加速度*/, double t /*加速时间*/) {return v0 + a * t;
}int main() {auto op  = papply(velocity, 0.0, 9.81);auto val = op(4.5 /*4.5秒加速时间*/);  // returns 44.15 m/sstd::println("{:.2f} m/s", val);  // 44.15 m/sreturn 0;
}
高阶函数 （Partial Application）

如何特化高阶函数？

此函数对集合执行左折叠

auto leftFold = [](auto col, auto op, auto init) {return std::accumulate(std::begin(col), std::end(col), init, op);
};

函数 leftFold 使用二元运算 op 从值 init 开始组合集合 col 的元素。

  1. 使用 leftFold 特化执行求和
auto op = papply([](auto op, auto init, auto col){return leftFold(col, op, init);},std::plus<>(), 0.0);

该函数计算从值 0.0 开始的集合元素的总和。

  1. 使用 leftFold 特化计算集合的乘积
auto op = papply([](auto op, auto init, auto col){return leftFold(col, op, init);},std::multiplies<>(),1.0);

完整代码：

#include <print>    // C++23
#include <numeric>  // C++20
#include <vector>auto papply = [](auto f, auto... args) {return [=](auto... rargs) {return f(args..., rargs...);};
};auto leftFold = [](auto col, auto op, auto init) {return std::accumulate(std::begin(col), std::end(col), init, op);
};int main() {auto op_plus       = papply([](auto op, auto init, auto col) { return leftFold(col, op, init); }, std::plus<>(), 0.0);auto op_multiplies = papply([](auto op, auto init, auto col) { return leftFold(col, op, init); }, std::multiplies<>(), 1.0);std::vector<int> set = {1, 2, 3, 4, 5};auto val1 = op_plus(set);        // 1 + 2 + 3 + 4 + 5 = 15auto val2 = op_multiplies(set);  // 1 * 2 * 3 * 4 * 5 = 120std::println("{:d} {:d}", static_cast<int>(val1), static_cast<int>(val2)); // 15 120return 0;
}

结论

柯里化（Curry） 和 （部分应用）Partial Application 作为函数式编程的重要概念，通过现代 C++ 中的函数对象和 lambda 表达式实现，为代码的模块化和灵活性提供了更多可能性。通过固定部分参数，生成新的函数，柯里化让函数处理变得更加高效、灵活和可复用。

在 C++ 中，柯里化（Curry） 和 （部分应用）Partial Application为处理函数式编程提供了一种强大的工具，可以应对各种复杂的场景，提高代码的可读性和可维护性。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/217061.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

crontab 定时检测 Tomcat 状态脚本实现及注意事项

crontab 定时检测 Tomcat 状态脚本实现及注意事项

背景 Jenkins 所在的 Tomcat 总是莫名挂掉&#xff0c;虽然任务配置了 NOKILLME 参数&#xff0c;而且并不是总是发生在编译完成后才挂的。怀疑是机器资源不足导致的&#xff0c;没有依据。最简单的办法是创建一个定时任务&#xff0c;检测 Tomcat 状态&#xff0c;不见了就拉…
阅读更多...
hive 报错return code 40000 from org.apache.hadoop.hive.ql.exec.MoveTask解决思路

hive 报错return code 40000 from org.apache.hadoop.hive.ql.exec.MoveTask解决思路

参考学习 https://github.com/apache/hive/blob/2b57dd27ad61e552f93817ac69313066af6562d9/ql/src/java/org/apache/hadoop/hive/ql/ErrorMsg.java#L47 为啥学习error code 开发过程中遇到以下错误&#xff0c;大家觉得应该怎么办&#xff1f;从哪方面入手呢&#xff1f; 1.百…
阅读更多...
p12 63.删除无头结点无头指针的循环链表中所有值为x的结点 桂林电子科技大学2015年 （c语言代码实现）注释详解

p12 63.删除无头结点无头指针的循环链表中所有值为x的结点 桂林电子科技大学2015年 （c语言代码实现）注释详解

本题代码如下 void delete(linklist* L, int x) {lnode* p *L, * q *L;while (p->next ! q)// 从第一个结点开始遍历链表&#xff0c;直到尾结点的前一个结点{if (p->next->data x)//判断是否等于x{lnode* r p->next;//将r指向x的位置p->next r->next;…
阅读更多...
C语言—一维数组在内存中的存放

C语言—一维数组在内存中的存放

1、先看代码&#xff1a; #define _CRT_SECURE_NO_WARNINGS 1#include<stdio.h> int main() {int arr[]{1,2,3,4,5,6,7,8,9,10}; int szsizeof(arr)/sizeof(arr[0]);int i0;for(i0;i<sz;i){printf("&arr[%d] %p\n",i,&arr[i]);}return 0; } 2、定…
阅读更多...
Spring Cloud 版本升级遇坑记：OpenFeignClient与Gateway的恩怨情仇

Spring Cloud 版本升级遇坑记：OpenFeignClient与Gateway的恩怨情仇

Spring Cloud 版本升级遇坑记&#xff1a;OpenFeignClient与Gateway的恩怨情仇 近日&#xff0c;在对项目中的 Spring Boot、Spring Cloud 以及 Spring Cloud Alibaba 进行版本升级时&#xff0c;遭遇了一个令人头疼的问题&#xff1a;Spring Cloud Gateway 在运行时一直卡住&a…
阅读更多...
计算机组成原理(计算机系统概述)

计算机组成原理(计算机系统概述)

目录 一. 计算机的发展二. 计算机硬件的基本组成2.1 早期冯诺依曼机2.2 现代计算机的结构 三. 各硬件的工作原理3.1 主存储器的基本组成3.2 运算器的基本组成3.3 控制器的基本组成 四. 计算机的工作过程 \quad 一. 计算机的发展 计算机系统 硬件 软件 #mermaid-svg-gp2AsYELE…
阅读更多...
十大排序之选择排序（详解）

十大排序之选择排序（详解）

文章目录 &#x1f412;个人主页&#x1f3c5;算法思维框架&#x1f4d6;前言&#xff1a; &#x1f380;选择排序 时间复杂度O(n^2)&#x1f387;1. 算法步骤思想&#x1f387;2.动画实现&#x1f387; 3.代码实现 &#x1f412;个人主页 &#x1f3c5;算法思维框架 &#x1f…
阅读更多...
基于IDEA+SpringBoot+微服务开发的P2P平台项目

基于IDEA+SpringBoot+微服务开发的P2P平台项目

基于springboot的社区养老医疗综合服务平台 项目介绍&#x1f481;&#x1f3fb; 项目名称&#xff1a;基于P2P的金融项目 一个基于P2P&#xff08;点对点&#xff09;模式的金融服务平台&#xff0c;致力于提供透明、高效、安全的金融服务。我们的目标是连接借款人与投资者&am…
阅读更多...
pat实现基于邻接矩阵表示的深度优先遍历[含非递归写法]

pat实现基于邻接矩阵表示的深度优先遍历[含非递归写法]

文章目录 1.递归2.非递归 1.递归 void DFS(Graph G, int v) {visited[v] 1;printf("%c ", G.vexs[v]);for (int i 0; i < G.vexnum; i) {if (!visited[i] && G.arcs[v][i]) DFS(G, i);} }2.非递归 #include <stack> #include <iostream> …
阅读更多...
如何打造垂直LLM的护城河

如何打造垂直LLM的护城河

B2B人工智能初创企业的一个伟大策略是打造“垂直人工智能”产品&#xff1a;成为特定行业的人工智能助手&#xff0c;比如律师、金融服务、医生。 听起来很简单&#xff1a;你可以利用LLM的超能力&#xff0c;并将其应用于宠物行业的特定数据和用例。 这就是我们在Explain所做的…
阅读更多...
【Clang Static Analyzer 代码静态检测工具详细使用教程】

【Clang Static Analyzer 代码静态检测工具详细使用教程】

Clang Static Analyzer sudo apt-get install clang-tools scan-build cmake .. scan-build make -j4 编译完成之后会在终端提示在哪里查看报错文档： scan-build: 55 bugs found. scan-build: Run scan-view /tmp/scan-build-2023-11-24-150637-6472-1 to examine bug report…
阅读更多...
双向链表超详解——连我奶奶都能学会的复杂链表(带头双向循环)

双向链表超详解——连我奶奶都能学会的复杂链表(带头双向循环)

文章目录 前言一、双向链表的概念二、双向链的结构设计三、双链表的基本功能接口四、双向链表接口的实现4.1、创建结点4.2、初始化链表4.3、打印链表4.4、尾插结点4.5、尾删结点4.6、头插结点4.7、头删结点4.8、在pos结点前面插入4.9、删除pos位置的结点4.10、查找链表中的某个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023