成员静态函数和回调函数的灵活应用

定义函数回调函数有两种方法

使用typedey定义函数指针

typedef int (*func)(void*);

如果有两个库之间不想产生依赖关系，但又需要访问相应的函数和得到返回值，例如：

1. 前端点击了abort按钮，希望后台的复杂计算停止下来，但当后台的函数启动后，是无法实时，获得前端的操作的。
2. 这样就引入了我们今天的话题，给算法传入一个前端的函数，然后在后台执行这个回调函数。

class algorithm {

public：
	viod run(func callBack)
	{
		//do something
		void* para[2]; //传给前端的传输
		int aa;
		para[0] = &aa;
		if(callBack() == -1)
		{
		}
	};
}

class deskOperator{
public：
	bool isAbort(){m_isAbort = true；};
	//这个回调函数得是静态的
	static int myFunCalled(void* para)
	{
		//para 可以是一个存放指针得数组，每个元素可以存放任意类型的变量的地址；解引用就能得到丰富的参数
		void** pParas = (void**)para;
		int IntPara = *(int*)pParas[0];
		if(IntPara == 5)
		{
			if(!m_isAbort)
			{
				return 0;
			}
			
		}
		else
		{
			return -1;
		}
	}
	viod clickAbort(void)
	{
		algorithm* algor = new algorithm();
		func myFuuc = deskOperator::myFunCalled;
		algor.run(myFuuc);//这是一个很耗时的函数，同时也需要监听前端的停止动作
	}
	
	static bool m_isAbort; //这样的情况下左右的对象都是相同值
	//所以还可以考虑不用静态成员，这样实现动态获得m_isAbort；解决办法就是在传给算法回调函数时，将前端的地址也一并传过去，然后算法再将这个地址传回来，我们强制转换为deskOperator的对象，然后调用deskOperator(实例).m_isAbort,这样就可以了。
}

使用 std::function<void(void*)> 包装

后面补齐
补齐，20240308

#include <string>
#include <iostream>
#include <functional>

using namespace std;

typedef int integer;

typedef std::function<void(int para)> AisName; // 类型提升,现在 AisName是一个函数指针类型了
typedef int(*funcPtr)(void*); // 类型提升,现在 funcPtr 是一个函数指针类型了
using OtherMethed = std::function<void(int para)>; // 取别名

class TestCallback {

public:
	int num = 5;
	void call(void(*callback)(int));
};

//普通函数就是全局函数，有自己的地址
void callBack1(int num)
{
	cout << "func1的num = " << num << endl;
}

void TestCallback::call(void(*callback)(int))
{
	cout << "调用回调" << endl;
	callback(this->num);
}

int main()
{
	AisName myFuc1 = callBack1;
	myFuc1(5);

	OtherMethed myFuc2 = callBack1;
	myFuc2(6);

	TestCallback t;
	t.call(callBack1);
	//t.call(&myFuc1); //不是指针
}