• 不可变性：在函数式编程里，数据一旦创建就不可改变。比如在传统 C++ 中，我们可能会这样写代码：

int a = 5;
a = 10; // 修改变量a的值

int add(int num) { return num + 5;
}int result = add(5); // result为10，没有修改传入的参数

• 高阶函数：是指接受函数作为参数，或者返回一个函数的函数。C++ 中的std::for_each 就是一个高阶函数的例子：

#include <iostream>
#include <algorithm>
#include <vector>void print(int num)
{    std::cout << num << " ";
}int main()
{    std::vector<int> vec = {1, 2, 3, 4, 5};std::for_each(vec.begin(), vec.end(), print);return 0;
}

• 闭包：闭包是一个函数对象，它可以捕获其创建环境中的变量。在 C++ 中，Lambda 表达式就常用来创建闭包。例如：

#include <iostream>
#include <vector>int main() 
{    int factor = 2;auto multiply = [factor](int num) {return num * factor;    };    std::vector<int> vec = {1, 2, 3};    for (int num : vec) {        std::cout << multiply(num) << " ";    }    return 0;
}

• 惰性求值：惰性求值是指表达式只有在真正需要结果时才进行计算。在 C++ 中，虽然没有像某些函数式编程语言那样原生支持惰性求值，但我们可以通过一些技巧来模拟。比如自定义一个延迟计算的类模板。

#include <iostream>
#include <algorithm>
#include <vector>int main() 
{    std::vector<int> vec = {5, 3, 1, 4, 2};    std::sort(vec.begin(), vec.end(), [](int a, int b) {        return a < b;    });    for (int num : vec) {        std::cout << num << " ";    }    return 0;
}

1. 简化程序结构，因为优化了函数命名与函数传参；
2. 提高程序运行效率，因为优化了函数调用、函数返回等消耗；
3. 适用于简单功能的函数优化；

#include <iostream>int main(int argc, char **argv)
{int num1 = 5;int num2 = 6;auto func_add = [&num1,num2]()  //num1可修改,num2不可修改{num1 = 7;return num1 + num2;};auto func_add1 = [=](int a, int b){a = 1;  //这里修改的只是形参a/b的值，不会改变num1与num2的值b = 1;return a + b;};auto func_add2 = [&]{// num1 = 1;  //按引用传递，可用可修改num1与num2的值return num1 + num2;};std::cout<<func_add()<<std::endl;std::cout<<"num1 = "<<num1<<" num2 = "<<num2<<std::endl;std::cout<<func_add1(num1,num2)<<endl;std::cout<<"num1 = "<<num1<<" num2 = "<<num2<<std::endl;std::cout<<func_add2()<<endl;std::cout<<"num1 = "<<num1<<" num2 = "<<num2<<std::endl;return 0;
}

• 函数对象的定义和使用：函数对象是一个类或结构体，它重载了函数调用运算符"()"。例如：

#include <iostream>
#include <string>
#include <functional>using namespace std;template <typename T>
class Add
{
public:Add() = default;void operator()(T &&a, T &&b)  //重载函数运算符，采用的是万能引用{cout<<a+b<<endl;}
};int main(int argc ,char **argv)
{Add<int> c_add;c_add.operator()(5,6);  //利用成员函数的形式调用c_add(5,6);    //采用函数成员方式plus<int> p1;cout<<p1(5,6)<<endl;  //使用系统函数对象库return 0;
}

• STL 中的函数对象：C++ STL 中提供了很多预定义的函数对象，如std::plus、std::less 等。例如使用std::plus 来对两个数求和：

#include <iostream>
#include <functional>int main() 
{    std::plus<int> plus_op;    int result = plus_op(5, 3);    std::cout << result << std::endl;   return 0;
}

#include <iostream>
#include <numeric>
#include <vector>int main() {std::vector<int> vec = {1, 2, 3, 4, 5};    int sum = std::accumulate(vec.begin(), vec.end(), 0);    std::cout << sum << std::endl;    return 0;
}

1. 函数对象比一般函数更灵活，因为它可以拥有状态（state），事实上，对于相同的函数对象可以设置两个状态不同的实例；普通函数没有状态；
2. 每个函数对象都有其类型，因为你可以将函数对象的类型当做template参数传递，从而指定某种行为；
3. 执行速度上，函数对象通常比函数指针更快；

#include <iostream>
#include <functional>
int add(int a, int b) {return a + b;
}
int main() {std::function<int(int, int)> func = add; std::cout << func(3, 4) << std::endl; return 0;
}

#include <iostream>
#include <functional>
int main() {std::function<int(int, int)> func = [](int a, int b) {return a * b;};std::cout << func(3, 4) << std::endl; return 0;
}

#include <iostream>
#include <functional>
struct Subtract {int operator()(int a, int b) const {return a - b;}
};
int main() {std::function<int(int, int)> func = Subtract();std::cout << func(5, 3) << std::endl; return 0;
}

• 泛型编程：模板函数中，可将不同类型可调用对象（函数指针、Lambda、函数对象等）包装后作为参数传递，使模板函数能处理多种调用逻辑，增强代码通用性与灵活性。例如编写通用算法模板，可接收不同比较规则的函数包装器实现自定义排序等操作。
• 回调函数 ：在事件驱动编程（如图形界面开发、网络编程 ）中，常需设置回调函数。用函数包装器可方便存储和管理这些回调，在特定事件发生时调用。如注册按钮点击事件回调，可将处理逻辑写成普通函数、Lambda 等，再用函数包装器管理并传递给按钮组件。
• 异步编程 ：多线程或异步任务场景下，函数包装器可存储要在新线程或异步环境执行的函数。如使用std::thread创建线程时，可将函数包装器作为线程执行任务，方便管理任务逻辑。
• 日志记录与性能监控 ：通过包装器，可在函数执行前后添加日志记录代码，记录输入参数、执行时间等信息，辅助调试和性能优化；也能进行性能分析，记录函数执行耗时、资源占用等指标。
• 权限验证与异常处理 ：在函数执行前，利用包装器进行权限验证，确保只有有权限用户能调用；执行过程中捕获异常并处理，如打印错误信息、进行重试等操作 ，增强程序稳定性与安全性。

#include <iostream>
#include <functional>
using namespace std;template <typename T>
class Add
{
public:T operator()(T a, T b, T c){print();return a + b;}void operator()(const T &a){cout << a << endl;}void print(){cout << "function add!" << endl;}int m_result;
};int add(int a, int b, int c)
{cout << "a = " << a << " b = " << b << endl;return a + b + c;
}int main()
{//普通函数function<int(int,int)> my_add = std::bind(add,std::placeholders::_1,std::placeholders::_2,0);cout << my_add(5,6) << endl;function<int()> my_add2 = std::bind(add,7,8,0);cout << my_add2() << endl;//lambda表达式auto lambda_func = [=](int a, int b, int c){return a + b + c;};function<int(int,int)> my_add3 = std::bind(lambda_func,std::placeholders::_2,std::placeholders::_1,0);cout << my_add3(3,4) << endl;function<int()> my_add4 = std::bind(lambda_func,3,4,0);cout << my_add4() << endl;//函数对象Add<int> c_add;function<int(int,int)> my_add5 = std::bind(c_add,std::placeholders::_2,std::placeholders::_1,0);cout << my_add5(4,5) << endl;function<int()> my_add6 = std::bind(c_add,5,6,0);cout << my_add6() << endl;return 0;
}

• 数据处理：在处理大量数据时，函数式编程可以让代码更简洁和易于理解。比如对一个包含学生成绩的数组进行筛选，找出成绩大于 80 分的学生，使用函数式编程风格的代码可能如下：

#include <iostream>
#include <vector>
#include <algorithm>
struct Student {    std::string name;    int score;
};int main() 
{    std::vector<Student> students = {{"Alice", 85}, {"Bob", 70}, {"Charlie", 90}};    std::vector<Student> high_scores;    std::copy_if(students.begin(), students.end(), std::back_inserter(high_scores), [](const Student& s) {return s.score > 80;    });    for (const auto& student : high_scores) {        std::cout << student.name << " : " << student.score << std::endl;    }    return 0;
}

• 并发编程：函数式编程的不可变性等特性在并发编程中很有优势，因为不可变的数据不用担心多线程访问时的竞争问题。例如，在使用std::async 进行异步任务时，可以传递函数式风格的函数对象。

• 机器学习：在机器学习领域，函数式编程可以用于数据预处理、模型训练过程中的函数组合等场景。比如对数据集进行一系列的变换操作，可以通过组合不同的函数来实现。