函数指针-仿函数-Lambda表达式

函数指针

将函数赋给一个变量 可以用于函数传递 常用来扩展函数能力

#include <vector>
//函数指针的表示 (*func_pointer)( data_types arg1, data_types arg2, ...,data_types argn);
void Foreach(const vector<int> & v, void(*func)(int a)){
    for(int value:v)：
        func(value);
}

void print(int a){
    cout << a << endl;
}

int main()
{
    vector<int> valus = {1,2,3,4};
    Foreach(valus, print) ;//print代表对里面的数据进行某种操作    
    Foreach(valus,[](int v){cout << v << endl}) //lambda 表达式 【】表示捕获方式       
}

仿函数

定义：仿函数(functor)，就是使一个类的使用看上去像一个函数。其实现就是类中实现一个operator这个类就有了类似函数的行为，就是一个仿函数类了。
仿函数的语法几乎和我们普通的函数调用一样，不过作为仿函数的类，都必须重载 operator() 运算符。因为调用仿函数，实际上就是通过类对象调用重载后的 operator() 运算符。

一个仿函数的例子

class StringAppend {
public:
    explicit StringAppend(const string& str) : ss(str){}
    void operator() (const string& str) const {
         cout << str << ' ' << ss << endl;
    }
private:
    const string ss;
};

int main() {
    StringAppend myFunctor2("and world!");
    myFunctor2("Hello");
}


输出：
Hello and world!

如果编程者要将某种“操作”当做算法的参数，一般有两种方法：
（1）一个办法就是先将该“操作”设计为一个函数，再将函数指针当做算法的一个参数，利用函数指针实现；
（2）将该“操作”设计为一个仿函数（就语言层面而言是个 class），再以该仿函数产生一个对象，并以此对象作为算法的一个参数。

方法二的优点就是易于拓展。

假设我们现在有一个数组，数组中存有任意数量的数字，我们希望能够统计出这个数组中大于 10 的数字的数量
利用函数指针：

#include <iostream>
using namespace std;

int RecallFunc(int *start, int *end, bool (*pf)(int)) {
    int count=0;
    for(int *i = start; i != end+1; i++) {
    	count = pf(*i) ? count+1 : count;
    }
    return count;
}

bool IsGreaterThanTen(int num) {
	return num>10 ? true : false;
}

int main() {
	int a[5] = {10,100,11,5,19};
    int result = RecallFunc(a, a+4, IsGreaterThanTen);
    cout<<result<<endl;
    return 0;
}

如果此时希望将判定的阈值也作为一个变量传入，在不改变RecallFunc函数的情况下，利用函数指针是没办法实现的。
利用仿函数

#include <iostream>
using namespace std;

class IsGreaterThanThresholdFunctor {
public:
	explicit IsGreaterThanThresholdFunctor(int t):threshold(t){}
	bool operator() (int num) const {
		return num > threshold ? true : false;
	}
private:
	const int threshold;
};

int RecallFunc(int *start, int *end, IsGreaterThanThresholdFunctor myFunctor) {
	int count = 0;
	for (int *i = start; i != end + 1; i++) {
		count = myFunctor(*i) ? count + 1 : count;
	}
	return count;
}

int main() {
	int a[5] = {10,100,11,5,19};
	int result = RecallFunc(a, a + 4, IsGreaterThanThresholdFunctor(10));
	cout << result << endl;
}

lambda 表达式

声明Lambda表达式
Lambda表达式完整的声明格式如下：

[capture list] (params list) mutable exception-> return type { function body }

各项具体含义如下

capture list：捕获外部变量列表
params list：形参列表
mutable指示符：用来说用是否可以修改捕获的变量
exception：异常设定
return type：返回类型
function body：函数体
此外，我们还可以省略其中的某些成分来声明“不完整”的Lambda表达式，常见的有以下几种：

序号 格式

1	[capture list] (params list) -> return type {function body}
2	[capture list] (params list) {function body}
3	[capture list] {function body}

其中：

• 格式1声明了const类型的表达式，这种类型的表达式不能修改捕获列表中的值。
• 格式2省略了返回值类型，但编译器可以根据以下规则推断出Lambda表达式的返回类型： （1）：如果function body中存在return语句，则该Lambda表达式的返回类型由return语句的返回类型确定； （2）：如果function body中没有return语句，则返回值为void类型。
• 格式3中省略了参数列表，类似普通函数中的无参函数。

讲了这么多，我们还没有看到Lambda表达式的庐山真面目，下面我们就举一个实例。

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

bool cmp(int a, int b)
{
    return  a < b;
}

int main()
{
    vector<int> myvec{ 3, 2, 5, 7, 3, 2 };
    vector<int> lbvec(myvec);

    sort(myvec.begin(), myvec.end(), cmp); // 旧式做法
    cout << "predicate function:" << endl;
    for (int it : myvec)
        cout << it << ' ';
    cout << endl;

    sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });   // Lambda表达式
    cout << "lambda expression:" << endl;
    for (int it : lbvec)
        cout << it << ' ';
}

我们使用STL的sort函数，需要提供一个谓词函数（谓词，其实就是一个判断式，说白了就是一个返回bool值的函数或者仿函数。）。如果使用C++11的Lambda表达式，我们只需要传入一个匿名函数即可，方便简洁，而且代码的可读性也比旧式的做法好多了。
有函数指针的地方 一般都可以用lambda表达式替代

捕获外部变量

Lambda表达式通过在最前面的方括号[]来明确指明其内部可以访问的外部变量，这一过程也称过Lambda表达式“捕获”了外部变量。

#include <iostream>
using namespace std;

int main()
{
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    f(); // 输出：123

    //或通过“函数体”后面的‘()’传入参数
    auto x = [](int a){cout << a << endl;}(123); 
}

类似参数传递方式（值传递、引入传递、指针传递），在Lambda表达式中，外部变量的捕获方式也有值捕获、引用捕获、隐式捕获。

1、值捕获

值捕获和参数传递中的值传递类似，被捕获的变量的值在Lambda表达式创建时通过值拷贝的方式传入，因此随后对该变量的修改不会影响影响Lambda表达式中的值。

示例如下：

int main()
{
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    a = 321;
    f(); // 输出：123
}

引用捕获

使用引用捕获一个外部变量，只需要在捕获列表变量前面加上一个引用说明符&。如下：

int main()
{
    int a = 123;
    auto f = [&a] { cout << a << endl; }; 
    a = 321;
    f(); // 输出：321
}

隐式捕获

上面的值捕获和引用捕获都需要我们在捕获列表中显示列出Lambda表达式中使用的外部变量。除此之外，我们还可以让编译器根据函数体中的代码来推断需要捕获哪些变量，这种方式称之为隐式捕获。隐式捕获有两种方式，分别是[=]和[&]。[=]表示以值捕获的方式捕获外部变量，[&]表示以引用捕获的方式捕获外部变量。

隐式值捕获示例：

int main()
{
    int a = 123;
    auto f = [=] { cout << a << endl; };    // 值捕获
    f(); // 输出：123
}

隐式引用捕获示例：

int main()
{
    int a = 123;
    auto f = [&] { cout << a << endl; };    // 引用捕获
    a = 321;
    f(); // 输出：321
}