C++函数指针、回调函数、仿函数和lambda函数

函数指针、回调函数、仿函数和lambda函数的关系比较紧密，这里做一个简单的总结

1. 函数指针

函数指针保存的是函数地址，通过函数指针也可以调用对应函数。
函数指针的定义方式：返回值类型 (*指针名) (参数列表)，注意指针名两边的括号不能少
使用typedef可以定义函数指针类型：typedef 返回值类型 (*指针名) (参数列表)
成员函数指针的使用方式略有不同，具体看下面例子

void hello(int a) {
	std::cout << "hello, a=" << a << std::endl;
}

int main()
{
	void (*phello)(int); // 声明 hello 函数的函数指针，名字为 phello
	phello = hello; // 给函数指针赋值，就像声明一个int指针也要赋值一样
	phello(10); // 输出10，使用函数指针调用函数，和使用函数名调用一样

	auto p = hello; // 使用auto推导出函数指针类型，这种方式比较方便
	p(20);  // 输出 20

	typedef void (*hellotype)(int); // 定义了一个类型叫 hellotype，使用方式和int、float一样
	hellotype phello2 = hello; // 定义变量 phello2并赋值，就像 int a=2; 一样
	phello2(30); // 输出 30
	return 0;
}

下面看看成员函数指针的使用：
成员函数指针赋值必须加上&和类限定，具体看例子：

class Demo {
public:
	void func(int a) { std::cout << "this is func, a=" << a << std::endl; }
};

void func1(int a){}
int main()
{
	typedef void(Demo::*PFUNC)(int); // 和普通函数指针相比，要加上类的作用域进行限定
	PFUNC pfunc = &Demo::func;	// 必须用类的成员函数初始化，这里不加 & 无法编译
	// PFUNC pfunc1 = func1;	// 类外的函数不能初始化

	// 根据类是不是new出来的，调用方式也不一样
	Demo* pdemo = new Demo;
	(pdemo->*pfunc)(10);	// 输出 this is func, a=10
	 
	Demo demo;
	(demo.*pfunc)(20);		// 输出 this is func, a=20
	return 0;
}

2. 回调函数

回调函数相当于一个中断处理函数，由别人或系统在符合你设定的条件时自动调用你定义的函数。回调函数就利用了函数指针。
回调函数的作用就是分离调用者和被调用者，调用者不用关心被调用者，它需要知道的，只是存在一个 具有某种特定原型、某些限制条件（如返回值为int）的被调用函数。
回调函数和普通函数的区别

• 对普通函数的调用：调用普通函数后，程序执行立即转向被调用函数执行，直到被调用函数执行完毕后，再返回调用程序继续执行。这个过程为“调用–>等待被调用函数执行完毕–>继续执行”。

• 对回调函数调用：调用程序发出对回调函数的调用后，不等函数执行完毕，立即返回并继续执行。这样，调用程序执和被调用函数同时在执行。当被调函数执行完毕后，被调函数会反过来调用某个事先指定函数，以通知调用程序：函数调用结束。这个过程称为回调（Callback）。

定义回调函数的步骤：1，声明；2，定义；3，设置触发条件，就是在你的函数中把你的回调函数名称转化为地址作为 一个参数，以便于他人或系统调用；

下面是一个简单的回调函数的例子，关于回调函数更多的理解，可参考https://blog.csdn.net/qawsedrf123lala/article/details/119176116

typedef void(*PFUNC)(std::string); // 1.声明

// 2.定义，当满足某个条件，别人就调用这个函数
void func(std::string str) { std::cout << "调用了回调函数，str=" << str << std::endl; }

class Demo {
public:
	void setCondition(PFUNC ptr) { // 设置回调函数的调用条件，或者说注册回调函数
		m_ptr = ptr;
	}

	PFUNC m_ptr;
};
int main()
{
	Demo demo;
	demo.setCondition(func); // 3. 设置条件
	demo.m_ptr("hello"); // 满足条件，别人通过函数指针调用
	// 输出 调用了回调函数，str=hello
	return 0;
}

3. 仿函数/函数对象

函数对象是用作函数的对象；但从实现上说，函数对象是实现了 operator()的类的对象（也就是重载了函数调用操作符的类）。实现了 operator()的类的对象才能保存状态（即类的成员属性的值）

特点：

• 可以像一个普通函数一样，有参数和返回值
• 内部可以拥有自己的状态(其实也就相当于函数内的static变量)，可以通过成员变量的方式被记录下来。
• 可以作为参数传递
• 函数对象通常不定义构造和析构函数，所以在构造和析构时不会发生任何问题，避免了函数调用时的运行时问题

template <typename elementType>
struct DisplayElement {
	void operator() (const elementType &e){ // 重载了()
		cout << e << " ";
	}
};
int main()
{
	vector <int> numsInVec{ 0, 1, 2, 3, -1, -9, 0, -999 };
	for_each(numsInVec.cbegin(), numsInVec.cend(), DisplayElement<int>());
	return 0;
}

下面这个例子说明仿函数有自己的状态和作为参数传递

// 利用成员count记录函数调用的次数，这是普通函数没有的
class MyPrint {
public:
	int operator()(int a, int b) {
		this->count++;
		return a + b;
	}
	int count=0;
};
void test01() {
	MyPrint my_print;
	int res1 = my_print(10, 20);
	int res2 = my_print(10, 20);
	int res3 = my_print(10, 20);
	std::cout << "调用次数：" << my_print.count << std::endl; // 输出 调用次数：3
}


void func(MyPrint &mp, int x, int y) {
	int res = mp(x, y);
	std::cout << "func函数中输出：" << res;  // 30
}
void test02() {
	MyPrint my_print; // 创建的函数对象，当作参数传递
	func(my_print, 10, 20);
}

int main()
{
	test01();
	test02();
	return 0;
}

4. lambda函数

lambda函数是匿名函数，可将 lambda 表达式视为包含公有 operator( )的匿名结构（或类），从这种意义上说，lambda 表达式属于函数对象。
lambda函数的作用：

• 作为函数的参数，类似回调函数的作用
• 可以在某个函数的函数体内直接定义,省了一步在外面定义函数的操作，相当于函数定义可以嵌套函数定义
  语法：[捕捉列表] (参数) mutable ->返回值类型 {函数体}

编译器见到lambda表达式：[](const int& element) {cout << element << ' '; }，自动将其展开为如下形式：

struct NoName 
{ 
 void operator () (const int& element) const 
 { 
 cout << element << ' '; 
 } 
}; 

因为 lambda 表达式是一个变量，所以，就可以“按需分配”，随时随地在调用点“就地”定义函数，限制它的作用域和生命周期，实现函数的局部化。在 C++ 里，每个 lambda 表达式都会有一个独特的类型，而这个类型只有编译器才知道，我们是无法直接写出来的，所以必须用 auto，也可以尽量使用匿名lambda表达式。

lambda不能有默认参数，因此，一个lambda调用的实参永远和形参数目一样
lambda变量的捕获：

• “[=]”表示按值捕获所有外部变量，表达式内部是值的拷贝，并且不能修改；
• “[&]”是按引用捕获所有外部变量，内部以引用的方式使用，可以修改；
• 也可以在“[]”里明确写出外部变量名，指定按值或者按引用捕获，C++ 在这里给予了非常大的灵活性。例如：a,&b,拷贝a，引用=，&a，&b，除ab引用，其余拷贝，&，a，b。除ab拷贝，其余引用
• 在对应位置有mutatble关键字，才能修改函数对象参数。否则报错。可以有，也可以没有，但有才能修改。lambda默认是const，也就是不能修改本地变量。

被捕获的变量值是在lambda创建时拷贝，而不是调用时拷贝，与函数参数不同。

如果想指定lambda函数的返回类型，要使用尾置返回类型

void case1() {
	int x = 33;
	auto f1 = [=]() {
		//x += x; // 会报错，x只读，不允许修改，加上mutable就可以修改
		// f1=[x]()mutable (){x+=x}，这种方式就可以
	};
	auto f2 = [&]() {
		x += x;
		cout << "f2:" << x << endl; // 66
	};
	auto f3 = [=, &x]() {
		x += 20;
		cout << "f3:" << x << endl; //86
	};
	f2();
	f3();
	cout << x << endl;  // 86
    
    int a = 10;
	a = [&a]()mutable->int {a += 10; return a; }(); //有返回值，注意最后的小括号
}

泛型化的lambda：

C++14后，利用auto实现lambda的泛型化

void case2() {
	auto func = [](const auto &x) {
		cout << x << endl;
	};
	func(10); // 参数类型是int
	func(3.14); // 参数类型是double
	func("hello world"); // 参数类型是string
}

void forEach(const std::vector<int>& values, const std::function<void(int)>& func)
{
	for (int value : values)
		func(value);
}
int main()
{
	std::vector<int> values = { 1,2,3,4,5 };
	int a = 10;
	forEach(values, [=](int value) {std::cout << a << std::endl; });// =代表值传入所有变量，即拷贝这个变量传入
	forEach(values, [&](int value) {std::cout << a << std::endl; });// &代表引用传入
	forEach(values, [a](int value) {std::cout << a << std::endl; });
	return 0;
}

最后给一个小例子：

void printValue(int value)
{
	std::cout << value << std::endl;
}
void forEach(const std::vector<int>& values, void(*func)(int))
{
	for (int value : values)
		func(value);
}
int main()
{
	std::vector<int> values = { 1,2,3,4,5 };
	forEach(values, printValue);
	forEach(values, [](int value) {std::cout << value << std::endl; }); //通过使用lambda函数简化
	return 0;
}