【STL十四】函数对象（function object）_仿函数（functor）——lambda表达式

一、函数对象（function object）

• 定义：定义了一个operator（）的对象，就叫函数对象（function object）。
• 函数对象又被叫做仿函数（functor）。

注意：

• 函数对象是一个类（or结构体、模板类），不是一个函数。
• 函数对象重载“（）”操作符，使得类可以像函数那样调用。

安装参数分
如果函数对象，有一个参数，叫一元函数对象。
如果函数对象，有二个参数，叫二元函数对象。
如果函数对象，有三个参数，叫多元函数对象。

二、函数对象优点

• 函数对象通常不定义构造函数和析构函数，所以在构造和析构不会发生问题
• 函数对象可以有自己的状态；（超出了普通函数的概念）
• 模板函数对象使得函数对象具有通用性。

三、分类

• 用户定义函数对象
• std::内置函数对象
• lambda表达式

四、头文件

• 用户自己定义的函数无头文件，
• std内建函数对象
  头文件如下

// 内置函数对象
#include<functional>

五、用户定义函数对象demo

• Print就是函数对象
• Print()(“HELLO WORLD”);//匿名函数对象

#include <iostream>
//
using namespace std;

class Print
{
public:
    void operator()(const char str[])
    {
        cout << str << endl;
    }
};

int main() {
    Print ob;

    ob("hello world");

    Print()("HELLO WORLD");//匿名函数对象
    
}

输出

hello world
HELLO WORLD

• 函数对象可以有自己的状态?
  demo

#include <iostream>
//#include<functional>
using namespace std;

class Print
{
public:
    void operator()(const char str[])
    {
        cout << str << endl;
        m_sum++;
    }
    int m_sum = 0;
};

int main() {
    Print ob;

    ob("hello world");
    ob("hello jx");
    cout << ob.m_sum << endl;
    
}

输出

hello world
hello jx
2

• 当然以上你可以写成模板，or同时重载int类型的，都是可以的

  • 重载int类型的

#include <iostream>
//#include<functional>
using namespace std;

struct Print
{
public:
    void operator()(const char str[])
    {
        cout << str << endl;
    }
    void operator()(int num)
    {
        cout << num << endl;
    }
};

int main() {
    Print ob;

    ob("hello world");

    Print()("HELLO WORLD");

    ob(110);
    
}

• 模板函数对象使得含对象具有通用性?
  • 模板

#include <iostream>
#include<string>
using namespace std;

template<typename T>
class Print
{
public:
    void operator()(T temp)
    {
        cout << temp << endl;
        m_sum++;
    }
    int m_sum = 0;
};

int main() {
    Print<string> ob;

    ob("hello world");
    ob("hello jx");
    cout << ob.m_sum << endl;
    
    Print<int> ob2;
    ob2(123);
    ob2(123);
}

输出

hello world
hello jx
2
123
123

六、std::内建函数对象

• stl内建了一些函数对象，分为算术运算、比较、逻辑运算、位运算；
• 其实，这些内建函数对象，都是配合容器和算法使用的，但是我们还没有讲解郭算法，所以做个不设计算法的简单的demo.

1、 算术运算函数对象

• 1.1、分类
  
• 1.2、demo

#include <iostream>
#include<functional>
using namespace std;

int main() {
    std::plus<int>  add;
    cout << "add(2, 3) = " << add(2, 3) << endl; //2+3 = 5

    std::minus<int> sub;
    cout << "sub(2, 3) = " << sub(2, 3) << endl; //2-3 = -1

    std::multiplies<int> mul;
    cout << "mul(2, 3) = " << mul(2, 3) << endl; //2*3 = 6

    std::divides<int> div;
    cout << "div(2, 3) = " << div(2, 3) << endl; //2/3 = 0

    std::modulus<int> mod;
    cout << "mod(2, 3) = " << mod(2, 3) << endl; //2%3 = 2

    std::negate<int> neg;
    cout << "neg(2) = " << neg(2) << endl; //neg(2) = -2 
        
}

输出

add(2, 3) = 5
sub(2, 3) = -1
mul(2, 3) = 6
div(2, 3) = 0
mod(2, 3) = 2
neg(2) = -2

2、比较

• 2.1、分类
  
• 2.2、demo

#include <iostream>
#include<functional>
using namespace std;

int main() {
    std::equal_to<int> ob1;
    cout << "ob1(1, 2) = " << ob1(1, 2) << endl;

    std::not_equal_to<int> ob2;
    cout << "ob2(1, 2) = " << ob2(1, 2) << endl;

    std::greater<int> ob3;
    cout << "ob3(1, 2) = " << ob3(1, 2) << endl;

    std::less<int> ob4;
    cout << "ob4(1, 2) = " << ob4(1, 2) << endl;

    std::greater_equal<int> ob5;
    cout << "ob5(1, 2) = " << ob5(1, 2) << endl;

    std::less_equal<int> ob6;
    cout << "ob6(1, 2) = " << ob6(1, 2) << endl;
}

输出

ob1(1, 2) = 0
ob2(1, 2) = 1
ob3(1, 2) = 0
ob4(1, 2) = 1
ob5(1, 2) = 0
ob6(1, 2) = 1

3、逻辑运算

• 3.1、分类
  
• 3.2、demo

#include <iostream>
#include<functional>
using namespace std;

int main() {
    std::logical_and<bool> l_and;
    cout << "l_and(1, 0) = " << l_and(1, 0) << endl;

    std::logical_or<int> l_or;
    cout << "l_or(1, 0) = " << l_or(1, 0) << endl; 

    std::logical_not<int> l_not;
    cout << "l_not(2) = " << l_not(2) << endl; 
}

输出

l_and(1, 0) = 0
l_or(1, 0) = 1
l_not(2) = 0

4、位运算

• 4.1、分类
  
  • demo

• 1、“与” 运算（&）:只有两个位都是1的时候结果才是1，否则是0;如1&1=1，1&0=0，0&1=0，0&0=0
• 2、“或” 运算（|）:只要有一个是1，结果就是1。如：1|0=1，0|1=1，1|1=1，0|0=0
• 3、“异或” 运算（^）:相同为0，不同为1；0|0=0，0|1=1，1|0=1，1|1=0
• 4、取反运算（~）：就是0=1，1=0

#include <iostream>
#include<functional>
using namespace std;

int main() {
    std::bit_and<int> b_and;
    cout << "b_and(1, 2) = " << b_and(1, 2) << endl;

    std::bit_or<int> b_or;
    cout << "b_or(1, 2) = " << b_or(1, 2) << endl;

    std::bit_xor<int> b_xor;
    cout << "b_xor(2,3) = " << b_xor(2,3) << endl;

    std::bit_not<bool> b_not;
    cout << "b_not(1) = " << b_not(1) << endl;
}

输出

b_and(1, 2) = 0
b_or(1, 2) = 3
b_xor(2,3) = 1
b_not(1) = 1

bit_not有问题，因为bool的取反，应该是0，但是输出是1，原因未知；

七、lambda表达式

使用 STL 时，往往会大量用到函数对象，为此要编写很多函数对象类。有的函数对象类只用来定义了一个对象，而且这个对象也只使用了一次，编写这样的函数对象类就有点浪费。
而且，定义函数对象类的地方和使用函数对象的地方可能相隔较远，看到函数对象，想要查看其 operator() 成员函数到底是做什么的也会比较麻烦。

• 对于只使用一次的函数对象类，能否直接在使用它的地方定义呢？Lambda 表达式能够解决这个问题。使用 Lambda 表达式可以减少程序中函数对象类的数量，使得程序更加优雅。

1、简介

• lambda expressions = lambda表达式（也叫闭包——Colsure)
• lambda表达式也是匿名函数对象
• lambda表达式也是一种仿函数、

2、作用

• 很方便的定义函数、并被别的函数调用。

3、定义

Lambda 表达式的定义形式如下：

[]中括号里面是一下捕获变量，或者为空。

[捕获变量] (参数表) -> 返回值类型
{
   函数主体
}

auto f=[](int a, int b) ->int
{
return a+b;
};

“捕获变量”可以是=或&，表示{}中用到的、定义在{}外面的变量在{}中是否允许被改变。=表示不允许，&表示允许。当然，在{}中也可以不使用定义在外面的变量。“-> 返回值类型”可以省略。

4、最简单的demo

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

int main() {
    auto f = [](int a, int b)
    {
        return a < b;
    };

    cout << f(2, 3);
}

输出

1

5、标准用法

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

int main() {
   // 定义lambda表达式，不使用变量捕获
    auto f = [](int a, int b) ->int
    {
        return a + b;
    };
    cout << f(1, 2) << endl;
}

输出

3

6、变量捕获（capture clause)

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

int main() {
    int M = 10;
    int N = 3;

    auto f = [&M, N](int a) ->int
    {
        M = 20;
        return N*a;
    };
    cout << f(3) << endl;
    cout << M << endl;
}

输出

9
20

• 变量捕获：就是方括号中的部分，让我们的匿名函数可以访问、甚至修改函数外部的变量。
• 如果是空，表示不捕获任何变量。
• [&M]——如果变量前有引用&，则是按引用捕获——可以修改外围变量的值。
• [M]——如果变量前没引用&，则是按值捕获——不可以修改外围变量的值。
• [&]——只写引用，按照引用捕获所有的封闭范围中的变量；
• [=]——只写等号，所有变量都按值捕获；
• [&, = M]——单独制定一些变量按照值捕获，其他变量按照引用捕获；
• [this]——如果在某个class中使用匿名函数，可以使用this捕获当前实例的指针。
• c++17后还可以使用[*this]按值捕获该实例。
• c++14后，可以在捕获语句中定义新的变量，并初始化。（这些变量无需出现在匿名函数外围环境中）

auto f = [&M, N, k=5](int a) ->int
    {
        M = 20;
        return N*a*k;
    };

• c++14后，参数列表支持auto类型

[](auto a, auto b){return a+b;}

参考：
1、C++ STL 容器库 中文文档
2、STL教程：C++ STL快速入门
3、https://www.apiref.com/cpp-zh/cpp/header.html
4、https://en.cppreference.com/w/cpp/container
5、哔哩哔哩_HexUp_清晰易懂，现代C++最好用特性之一：Lambda表达式用法详解
6、WIKI教程_C ++标准库_C++ Library - <iterator>