C++中的回调函数

普通函数作为回调函数

和C语言大致相同

typedef int (*pGeneralFun)(int, int);                // 定义函数指针
int sum(int a, int b) {
	return a + b;
}
void result(pGeneralFun fun, int a, int b) {      // 定义接口函数，在接口函数内实现回调函数的调用
	cout << (*fun)(a, b) << endl;
}

int main()
{
	result(sum, 1, 2);
	return 0;
}

类的成员函数作为回调函数

类的静态成员函数作为回调函数

在类外定义接口函数

typedef int(*pGeneralFun)(int, int);              // 类的静态成员函数的函数指针与普通函数一致
class Test {
public:
	static int Max(int a, int b) {
		return a >= b ? a : b;
	}
};
void result(pGeneralFun fun, int a, int b) {    // 类的静态成员函数的接口函数定义与普通函数一样
	cout << (*fun)(a, b) << endl;
}

int main()
{
	result(Test::Max, 1, 2);
	return 0;
}

在类内定义接口函数

typedef int(*pGeneralFun)(int, int);              // 类的静态成员函数的函数指针与普通函数一致
class Test {
public:
	static int Max(int a, int b) {
		return a >= b ? a : b;
	}
	void result(pGeneralFun fun, int a, int b) {    // 在类内部定义接口函数，定义形式与类外一样
		cout << (*fun)(a, b) << endl;
	}
};

int main()
{
	Test test;
	test.result(Test::Max, 5, 6);           // 调用在类内定义的接口函数
	return 0;
}

在类A中定义回调函数，在类B中定义接口函数

typedef int (*pGeneralFun)(int, int);
class A{
public:
    static int Max(int a, int b){             // 在类 A 中定义回调函数
        return a>=b?a:b;
    }
};
class B{
public:
    void result(pGeneralFun fun, int a, int b){
        cout<<(*fun)(a, b)<<endl;
    }
};
void main(){
    B b;
    A a;
    b.result(A::Max, 4, 5);
}

小结：

当类内的成员函数为静态成员函数时，将该函数作为回调函数，使用的方式与普通函数基本上没有区别。只是当接口函数定义在类的内部时，调用接口函数要使用对象名。

类的非静态成员函数作为回调函数

在类外定义接口函数

class Test;                             // 在定义函数指针之前必须先声明类
typedef int (Test::* pClassFun)(int, int);                         // 定义函数指针
class Test {
public:
	int sum(int a, int b) {
		return a + b;
	}
};
void result(Test* test, pClassFun fun, int a, int b) {       // 在定义接口函数时要传入一个对象
	cout << (test->*fun)(a, b) << endl;
}

int main()
{
	Test test;
	result(&test, &Test::sum, 3, 4);               // 对于非静态成员，要使用&来创建指向成员的指针
	return 0;
}

在类内定义接口函数

class Test;
typedef int(Test::* pClassFun)(int, int);
class Test {
public:
	int sum(int a, int b) {
		return a + b;
	}
	void result(pClassFun fun, int a, int b) {
		cout << (this->*fun)(a, b) << endl;               // 必须要用隐含的 this 指针来指向传入的函数
	}
};

int main()
{
	Test test;
	test.result(&Test::sum, 3, 4);
	return 0;
}

在类 A 内定义回调函数，在类 B 内定义接口函数

方式一

class A;                  // 必须先声明类 A
typedef int(A::* pClassFun)(int, int);
class A {
public:
	int sum(int a, int b) {
		return a + b;
	}
};
class B {
public:
	void result(A* test, pClassFun fun, int a, int b) {
		cout << (test->*fun)(a, b) << endl;
	}
};

int main()
{
	A a;
	B b;
	b.result(&a, &A::sum, 2, 3);
	return 0;
}

转载自：https://blog.csdn.net/xhj_enen/article/details/83789038