C++回调函数实战总结

回调函数也是普通函数，而不是什么神秘的东西。至于为什么叫回调函数，是因为程序通过参数把该函数的函数指针传递给了其它函数，在那个函数里面调用这个函数指针就相当于调用这个函数，这样的过程就叫回调，而被调用的函数就叫回调函数。看得出来，回调的本质是函数指针传递，所以想要理解回调机制，先要理解函数指针。

一、函数指针用法

1.1 函数指针

函数指针声明：

（1）函数声明

int foo(int);

（2）函数指针声明

  int (*p)(int)=&foo;//& 可以省略

 （3）函数指针使用

 (*p)(10);

  p(10);

举例：

void Invoke(const char* s);

int main()
{
    void (*fp)(const char* s);    //声明一个函数指针(fp)        
    fp = Invoke;                    //将Invoke函数的入口地址赋值给fp
    fp("Hello World!");           //函数指针fp实现函数调用
    return 0;
}

void Invoke(char* s)
{
    std::cout << s << std::endl;
}

在实际编程过程中,通常用宏定义的方式来声明函数指针.

#include <iostream>
#include <string>

//函数指针通常定义一个宏来实现
typedef void (*FP)(const char* s);
void f1(const char* s) { std::cout << s; }
void f2(const char* s) { std::cout << s; }
void f3(const char* s) { std::cout << s; }

void Invoke(const char* s);


int main()
{
	//通过函数指针
	FP fp = nullptr;
	fp = Invoke;
	fp("Hello Worle!");

	//函数指针数组
	FP a[] = { f1,f2,f3 };
	a[0]("Hello Worle! Hello Worle!");

	std::cin.get();
	return 0;
}

void Invoke(const char* s)
{
	std::cout << s << std::endl;
}

二、回调函数

2.1  回调函数

回调函数就是一个通过函数指针调用的函数。如果把函数的指针作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，这就是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的函数(系统)调用的，用于对该事件或条件进行响应。

Callback最本质的特征包括两点：注册和触发

概念：回调函数就是你自己写的一个函数，你需要调用一个中间函数（可以是系统函数也可以是自己写的）并传递一个函数指针给这个函数，而恰好这个函数指针指向那个回调函数，这样，你可以在那个回调函数里完成一些事情。

#include <iostream>
#include <string>

typedef void(*FP)(const char* s);

//定义回调函数
void callback(const char* s)
{
	std::cout << s << std::endl;
}
//定义回调函数的调用函数
void call(FP f,const char* s)
{
	f(s);
}

int main() 
{
	call(callback, "Hello World!");

	std::cin.get();
	return 0;
}

2.2 类的回调函数

常用的回调函数场景是，在一个类A中，有一个普通成员函数a,在类B中，有一个普通成员函数b,在b中，想要回调函数a。

#include <iostream>
 
#include <functional>
 
using namespace std;
using namespace std::placeholders;
 
typedef std::function<void(int,int)> Fun;
 
class B{
	public:
        void call(int a,Fun f)
        {
            f(a,2);
        }
};
 
class Test{
public:
	void callback(int a,int b)
	{
        cout<<a<<"+"<<b<<"="<<a+b<<endl;
	}
 
	void bind()
	{
        Fun fun=std::bind(&Test::callback,this,_1,_2);
		B b;
		b.call(1,fun);
	}
 
};
int main()
{
    Test test;
	test.bind();
	return 0;
}

Test类中的bind函数调用B类中的call函数，b中的call函数又反过来回调Test类中的callback函数。

对上面进行改造

 

#include <iostream>
 
#include <functional>
 
using namespace std;
using namespace std::placeholders;
 
typedef void (*PF)(void *pParam);
class B{
	public:
        void call(PF pf,void *param)
        {
            pf_ = pf;
            param_ = param;
        }
    
        void testcall(){
             (*pf_)(param);
        }
    PF pf_;
    void *param_;
};
 
class Test{
public:
    //回调函数
	static void callback(void *param)
	{
        cout<< "succeed" <<endl;
	}
 
	void bind()
	{
        //注册回调函数
        regCallBack(&Test::callback,this);
	}
    
    void regCallBack(PF pf,void *param)
    {
        B b;
        b.call(pf, param)
    }
 
};
int main()
{
    Test test;
	test.bind();
	return 0;
}

2.3 类中的回调函数必须为静态的成员函数

在注册回调函数时，要求回调函数必须是静态函数或全局函数。

• 如果使用全局函数，会毁坏类的封装性；
• 如果在类中不使用static属性的回调函数，则会出现“invalid use of non-static function”的编译错误。
• 如果在类Class A中使用static属性，将使得该回调函数只能访问类中的静态成员，而无法访问非静态成员，这常常不能满足实际应用的要求。

     通常情况下，要实现成员函数作为回调函数，一种常用的方法就是把该成员函数设计为静态成员函数，但这样做有一个缺点，就是会破坏类的结构性，因为静态成员函数只能访问该类的静态成员变量和静态成员函数，不能访问非静态的，要解决这个问题，需要把对象实例的指针或引用做为参数传给它。

解决方法一：

把要调用该成员函数的对象实例赋值给一个变量，然后通过该变量来调用成员函数

参考文献：

【1】C++ 回调函数总结及回调函数的封装：C++ 回调函数总结及回调函数的封装 - 百度文库

【2】最简单的C/C++回调函数实现： 最简单的C/C++回调函数实现_朱 宏江的博客-CSDN博客_c++实现回调函数

【3】C++回调函数使用心得：C++回调函数使用心得 - chenlife - 博客园

【4】c++类成员函数作为回调函数：c++类成员函数作为回调函数_小胡——uYou的专栏-CSDN博客_c++回调函数

【5】C++ 静态回调函数：C++ 静态回调函数_u014029448的博客-CSDN博客