函数式编程学习总结

大概了解了一下函数式编程，总的来说可以说，函数式编程就是一种体现函数当成普通变量的思想的编程方法，其中函数指针就是变量，而具体的函数，包括lambda函数就是常量。
学习过程中的代码如下：

#include <iostream>
#include <vector>
#include <map>
#include <functional>
#include <algorithm>
using namespace std;

//函数式编程的实现:函数指针
  //Q:什么是函数指针
  //A:函数指针是一种特殊类型的指针变量(指向函数)

  //Q:函数指针是任何函数都可以指向吗
  //A:不是,函数指针有类型之分,函数指针的类型会在声明是给出,特定类型的函数指针只能指向特定类型的函数

  //Q:如何声明一个函数指针,或者说不同函数指针的类型怎么区分
  //A:eg1:int (*f)(int, int) 其中int(* )(int, int)就是类型, f为函数指针变量
  //  eg2:using funType = int (*)(int, int); funType f;

  //Q:为什么没有函数变量
  //A:不需要,只需要一个函数就够了，应该工厂只需要一台机器,我们没有必要复制一台功能一模一样的机器

  //总结:函数指针和普通数据类型的指针几乎一致,只是一个指向特定类型的函数(由返回值，参数个数及类型唯一决定), 另一个则指向特定数据类型的变量
/*int main() {
    int m_plus(int, int);
    //函数指针声明
    int(*f)(int, int); //或者：using T = int(*)(int, int); T f;(简单的声明方法) 
    //函数指针赋值
    f = m_plus;//或者：f = &m_plus(这里是为了可以把函数指针当成一种引用
    //函数指针使用
    cout << f(1, 2) << endl; //*f不可以(规定吧，没有什么为什么)
    system("pause");
    return 0;    
}*/



//函数指针的作用
//A1:简化代码
//A2:函数变量化(可以把该指针看成是函数的一种引用), 一个函数指针可以代表该类型下不同的函数, 甚至可以作为函数参数, 使得函数功能具有范式的特点
/*int main() {
#if 0
//例子1：给出3个int型整数a、b、c,当c=0时，求a+b, 当c=1时，求a-b, 当c=2时，求a*b, 当c=3时， 求a/b
    int m_plus(int, int);
    int m_minus(int, int);
    int m_multiply(int, int);
    int m_devide(int, int);
    int a, b, c;
    cin >> a >> b >> c;
    using funType = int(*)(int, int);
    map<int, funType> m = { {0, &m_plus}, {1, m_minus}, {2, m_multiply}, {3, m_devide} };//加不加引号都可以
    cout << m[c](a, b);
    system("pause");
    return 0;
#else
//例子2：实现f(g(x) = 2(g(x))的效果
    int f(int, int(*)(int));
    int g1(int);
    int g2(int);
    int g3(int);
    int x;
    cout << "输入x：";
    cin >> x;
    cout << "f(2*x) = " << f(x, g1) << endl;
    cout << "f(2*x^2) = " << f(x, g2) << endl;
    cout << "f(2*x^3) = " << f(x, g3) << endl;
    system("pause");
    return 0;
#endif
}*/




//lambda表达式
//Q:lambda表达式有什么用
//A1:实现了函数的数值化,可以把一个lambda表达式看成一个数值(该表达式会返回一个函数指针)
//A2:与函数指针配合实现了数据类型定义变量的效果(int x = 0)
//A3:返回一个函数
/*int main() {
#define SEL 5
#if (SEL == 1)
    //例子1:用lambda表达式实现a%b函数
    auto f = [](int a, int b) { return a % b; };
    int a, b;
    cin >> a >> b; 
    cout << f(a, b);
    system("pause");
    return 0;
#elif (SEL == 2)
    //例子2:给出3个int型整数a、b、c,当c=0时，求a+b, 当c=1时，求a-b, 当c=2时，求a*b, 当c=3时， 求a/b
    map<int, int(*)(int, int)> m = {
        {0,[](int a, int b) {return a + b;}},
        {1,[](int a, int b) {return a - b;}},
        {2,[](int a, int b) {return a * b;}},
        { 3,[](int a, int b) {return a / b;}}
    };
    int a, b, c;
    cin >> a >> b >> c;
    cout << m[c](a, b);
    system("pause");
#elif(SEL == 3)
    //例子3:假设不使用map，仍使用if-else的语句，你能通过传递lambda表达式作函数参数的形式，在main函数外，仅实现一个函数compute来实现加减乘除求余这5种运算吗？
    int compute(int(*)(int, int), int, int);
    int a, b, c;
    cin >> a >> b >> c;
    if (c == 0)
        cout << compute([](int a, int b) {return a + b; }, a, b);
    else if (c == 1)
        cout << compute([](int a, int b) {return a - b; }, a, b);
    else if (c == 2)
        cout << compute([](int a, int b) {return a * b;}, a, b);
    else
        cout << compute([](int a, int b) {return a / b;}, a, b);
    system("pause");
    return 0;
#elif(SEL == 4)
    //例子4:返回一个函数
    function<int(int, int)>g();
    auto i = g();
    cout << i(1, 2);
    system("pause");
    return 0;
#endif
}*/

function<int(int, int)>g() {
    return [](int a, int b) {return a + b; };
}

//函数指针的更好替代:function标准库类型
/*int main() {
    function<int(int, int)> f = [](int a, int b) {return a + b;};
    cout << f(1, 2) << endl;
    system("pause");
    return 0;
}*/

//functional库中的其他函数(function好比变量, 其他函数好比常量)
/*int main() {
#define SEL 3
#if (SEL == 1)
    //例子1:
    auto i = plus<int>();
    cout << i(1, 2) << endl;
    cout << minus<int>()(2, 1) << endl;
    cout << divides<double>()(2.5, 2) << endl;
    cout << modulus<int>() (8, 3) << endl;
    cout << negate<int>()(3) << endl;
    cout << equal_to<int>()(2, 2) << endl;
    cout << not_equal_to<int>()(2, 3) << endl;
    cout << greater<int>()(3, 2) << endl;
    cout << greater_equal<int>()(3, 2) << endl;
    cout << less<double>()(3.2, 4.5) << endl;
    cout << less_equal<int>()(3, 2) << endl;
    cout << logical_and<int>()(3, 2) << endl;
    cout << logical_or<int>()(3, 2) << endl;
    cout << logical_not<int>()(3) << endl;
    system("pause");
    return 0;
#elif (SEL == 2)
    //例子2:
    map<int, function<int(int, int)>> m = {
        {0, plus<int>()}, {1, minus<int>()},
        {2, multiplies<int>()}, {3, divides<int>()}
    };
    int a, b, c;
    cin >> a >> b >> c;
    cout << m[c](a, b);
    system("pause");
    return 0;
#elif (SEL == 3)
    //例子3:排序的应用
    vector<int> v = { 2, 5, 4, 1, 3 };
    sort(v.begin(), v.end(), greater<int>());
    for (int i : v)
        cout << i << " ";
    system("pause");
    return 0;
#endif
}*/

//练习
double compute1(double a, double b, function<double(double)> f) {
    return (f(b) + f(a)) * (b - a) / 2;
}
double fun1(double k, double m, double x) {  //1次函数
    return k * x + m;
}
function<double(double)>fun1ForApplication(int k, int m) {  //返回或者产生具体的一次函数(k, m确定)
    return [k, m](double x) {return fun1(k, m, x);};//捕获，相当于把
}
int main() {
#define SEL 2
#if (SEL == 1)
    //练习1：求一次函数的积分
    cout << "2x + 10 在 (3, 7) 范围内的积分为:";
    cout << compute1(3, 7, [](double x) { return 2 * x + 10; });
#elif (SEL == 2)
    //练习2：用科里化的方式对上述练习进行改进(捕获)
    auto i = fun1ForApplication(2, 10);  //i 为 2 * x + 10 的函数
    cout << compute1(3, 7, i) << endl;
#endif
    system("pause");
    return 0;
}

int m_plus(int a, int b) {
    return a + b;
}
int m_minus(int a, int b) {
    return a - b;
}
int m_multiply(int a, int b) {
    return a * b;
}
int m_devide(int a, int b) {
    return a / b;
}
int f(int x, int(*g)(int)) {
    return 2 * g(x);
}
int g1(int x) {
    return x;
}
int g2(int x) {
    return x * x;
}
int g3(int x) {
    return x * x * x;
}
int compute(int(*f)(int, int), int a, int b) { //f为二元运算函数
    return f(a, b);
}