可调用对象和Lambda表达式

可调用对象：
        函数

        函数指针

        函数对象

        Lambda表达式(匿名函数)

01 函数对象

如果一个类实现了"函数调用运算符()"的重载，那么这个类的对象称为函数对象(仿函数)

函数对象的行为，类似于函数，可以被调用

#include <iostream>

using namespace std;

// 小于对象
class Less {
	private:
		int val_;
	public:  
		Less(int v = 0) : val_{v} {}

		// 重载函数调用运算符 ()
		void operator()() { // 重载了()
			cout << "operator()-----1" << endl;
		}
		bool operator()(int v) { // 重载了()
			cout << "operator()-----2" << endl;
			return v <= val_;
		}
        
        void set(int v) {
            val_ = v;
        }
	};

int main() {
    Less l{20}; // l就是一个可调用对象,拥有函数的行为和特征
    l();
    cout << l(25) << endl;
    
    l.set(30);
    cout << l(25) << endl;

    return 0;
}

函数对象和普通函数相比较，函数对象有什么好处？

        可以携带附加的数据，函数对象可以拥有自己的属性和行为

主要用途：

        除了函数的基本用法

        在标准库中，有很多常用的算法(全局变量)都使用到了函数对象

        如：

                find_if：查找算法，可以在一个指定区间内查找一个符合条件的元素

                这些算法在使用的时候，都需要接受一个“一元谓词对象”(可调用对象)用来描述一个条件

#include <iostream>
#include <algorithm> // find_if

using namespace std;

// 小于对象
class Less {
    private:
        int val_;
    public:  
        Less(int v = 0):val_{v} {}

        // 重载函数调用运算符 ()
        void operator()() { // 重载了()
            cout << "operator()-----1" << endl;
        }
        bool operator()(int v) { // 重载了()
            cout << "operator()-----2" << endl;
            return v <= val_;
        }

        void set(int v) {
            val_ = v;
        }
};

bool foo(int x) { // 有一个参数的可调用对象---->一元谓词
    cout << "foo" << endl;
    return x < 20;
}

int main() {
    Less l{5}; // l就是一个可调用对象,拥有函数的行为和特征
    l();
    cout << l(10) << endl;
    cout << "===============" << endl;
    l.set(35);
    cout << l(10) << endl;
    cout << "===============" << endl;

    int arr[10] = {38, 25, 73, 58, 46, 87, 29, 16, 34, 61};
    // 在指定的区间内查找一个指定的值
    int *p = find(arr, arr + 10, 58); // 返回查找到的元素的地址,如果没找到,则返回区间末尾
    cout << *p << endl;
    // 在一个区间内,查找第一个符合条件的元素
    // 条件--->谓词对象(一元谓词),是使用可调用对象描述的一个条件
    // 返回区间内,第一个让"可调用对象"返回真的元素的"迭代器"
    p = find_if(arr, arr + 10, foo); // 返回区间内,第一个让foo返回真的元素,第一个小于20的元素
    cout << *p << endl;

    cout << "===============" << endl;
    p = find_if(arr, arr + 10, l); // 返回区间内,第一个让l返回真的元素,第一个小于35的元素
    cout << *p << endl;
    
    return 0;
}

02 lambda匿名函数用法详解

lambda被用来表示一种匿名函数，所谓匿名函数，简单地理解就是没有名称的函数，又常被称为lambda函数或者lambda表达式

lambda匿名函数的定义方式：

[外部变量访问方式说明符](参数) mutable noexcept/throw() ->返回值类型 {
    函数体；
}

其中各部分的含义分别为：
(1) [外部变量访问方式说明符] ----- 不能被省略

[]方括号用于向编译器表明当前是一个lambda表达式,其不能被省略

在方括号内部,可以注明当前lambda函数的函数体中可以使用哪些“外部变量”

所谓外部变量,指的是和当前lambda表达式位于同一作用域内的所有局部变量

(2) (参数)

和普通函数的定义一样,lambda匿名函数也可以接收外部传递的多个参数

不能设置默认值

和普通函数不同的是,如果不需要传递参数,可以连同()小括号一起省略

(3) mutable

此关键字可以省略，如果使用，则之前的()小括号将不能省略(参数个数可以为0)

默认情况下，对于值传递方式引入的外部变量，不允许在lambda表达式内部修改它们的值(可以
理解为这部分变量都是const常量)，而如果想修改它们，就必须使用mutable关键字

注意：对于以值传递方式引入的外部变量，lambda表达式修改的是拷贝的那一份，
      并不会修改真正的外部变量

(4) noexcept / throw()

可以省略，如果使用，则之前的()小括号将不能省略(参数个数可以是0)

默认情况下，lambda函数的函数体中可以抛出任何类型的异常，而标注noexcept关键字，
则表示函数体内不会抛出任何异常

使用throw()可以指定lambda函数内部可以抛出的异常类型

如果lambda函数标有noexcept而函数体内抛出了异常，又或者使用throw()限定了异常类型而
函数体内抛出了非指定类型的异常，这些异常无法使用try-catch捕获，会导致程序执行失败

(5) ->返回值类型

指明lambda匿名函数的返回值类型

如果lambda函数体内只有一个return语句，或者该函数返回void
则编译器可以自行推断出返回值类型，此情况下可以直接省略->返回值类型

(6) 函数体

和普通函数一样，lambda匿名函数包含的内部代码都放置在函数体中

该函数体内除了可以使用指定传递进来的参数以外，还可以使用指定的外部变量以及
全局范围内的所有全局变量

需要注意的是,外部变量会受到以值传递还是以引用传递方式引入的影响,而全局变量则不会
换句话说,在lambda表达式内可以使用任意一个全局变量,必要时还可以直接修改它们的值