回调函数

最新推荐文章于 2021-06-30 00:29:19 发布

qican_7

最新推荐文章于 2021-06-30 00:29:19 发布

阅读量9.6k

点赞数 37

分类专栏：后端开发文章标签：回调函数

本文链接：https://blog.csdn.net/qican_7/article/details/100669020

版权

后端开发专栏收录该内容

43 篇文章 1 订阅

订阅专栏

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

其实回调就是一种利用函数指针进行函数调用的过程.

为什么要用回调呢?比如我要写一个子模块给你用,来接收远程socket发来的命令.当我接收到命令后,需要调用你的主模块的函数, 来进行相应的处理.但是我不知道你要用哪个函数来处理这个命令,我也不知道你的主模块是什么.cpp或者.h,或者说,我根本不用关心你在主模块里怎么处理它,也不应该关心用什么函数处理它......怎么办呢？使用回调!

—— lone wolf

使用回调函数实际上就是在调用某个函数（通常是API函数）时，将自己的一个函数（这个函数为回调函数）的地址作为参数传递给那个函数。而那个函数在需要的时候，利用传递的地址调用回调函数，这时你可以利用这个机会在回调函数中处理消息或完成一定的操作。

—— 某专家

回调函数，就是由你自己写的。你需要调用另外一个函数，而这个函数的其中一个参数，就是你的这个回调函数名。这样，系统在必要的时候，就会调用你写的回调函数，这样你就可以在回调函数里完成你要做的事。

—— 绿叶

回调函数是应用程序提供给Windows系统DLL或其它DLL调用的函数，一般用于截获消息、获取系统信息或处理异步事件。应用程序把回调函数的地址指针告诉DLL，而DLL在适当的时候会调用该函数。回调函数必须遵守事先规定好的参数格式和传递方式，否则DLL一调用它就会引起程序或系统的崩溃。通常情况下，回调函数采用标准WindowsAPI的调用方式，即__stdcall，当然，DLL编制者可以自己定义调用方式，但客户程序也必须遵守相同的规定。在__stdcall方式下，函数的参数按从右到左的顺序压入堆栈，除了明确指明是指针或引用外，参数都按值传递，函数返回之前自己负责把参数从堆栈中弹出。

—— jufengfeng

看了这么多的资料，我只将每位的定义总结一下就一句话：使用回调函数实际上就是在调用某个函数（通常是API函数）时，将自己写的一个函数（这个函数就是回调函数）的地址作为参数传递给那个函数。回调其实就是提供使用某模块的一种方法。回调函数就好比是一个中断处理函数。

3. 回调函数的作用？应该在什么情况下使用？

用过STL的人都知道，在STL中众多算法和程序都用到回调函数，这实现了一种策略。只要任何符合我的标准的函数和计算都可以用我这个公式。你可以实现各种各样的回调函数，只要符合我的格式就能用。就上面的程序来说，你只要函数格式符合cllback第二个参数的格式不论你给别人做饭、铺床叠被都可以正常工作。这就是回调的作用，把回调实现留给别人。这是一个用法。
有一位朋友用分层的概念来解释了回调机制：callback函数为B层，main函数和print函数为A层，A层调用了B层的回调函数callmeback，而B层的回调函数调用了A层的实现函数print。说白了B层就是一个接口。

有一位朋友用分层的概念来解释了回调机制：callback函数为B层，main函数和print函数为A层，A层调用了B层的回调函数callmeback，而B层的回调函数调用了A层的实现函数print。说白了B层就是一个接口。
最后要注意的是：回调函数要么是全局函数，要么是静态函数！


#include <stdio.h>
//回调函数
int ADD(int (*callback)(int,int), int a, int b){
	return (*callback)(a,b);//此处回调add函数...
}
//普通函数
int add(int a, int b){
	return a + b;
}
 
int main(void){
	printf("%d\n",add(1,2));
	printf("%d\n",ADD(add,1,2));
	return 0;
}

C回调函数

C++回调函数扩展自C回调函数，要想理解C++回调函数，先要理解C回调函数。我们通过一个实例来讲解C回调函数的使用方法。

//callbackTest.c
//1.定义函数onHeight（回调函数）
//@onHeight 函数名
//@height   参数
//@contex   上下文
void onHeight(double height, void* contex)
{
	sprint("current height is %lf",height);
}

//2.定义onHeight函数的原型
//@CallbackFun 指向函数的指针类型
//@height      回调参数，当有多个参数时，可以定义一个结构体
//@contex      回调上下文，在C中一般传入nullptr，在C++中可传入对象指针
typedef void (*CallbackFun)(double height, void* contex);

//3.定义注册回调函数
//@registHeightCallback 注册函数名
//@callback             回调函数原型
//@contex               回调上下文
void registHeightCallback(CallbackFun callback, void* contex)
{
	double h=100;
	callback(h,nullptr);
}

//4.main函数
void main()
{
	//注册onHeight函数，即通过registHeightCallback的参数将onHeight函数指针
	//传入给registHeightCallback函数，在registHeightCallback函数中调用
	//callback就相当于调用onHeight函数。
	registHeightCallback(onHeight，nullptr);
}

程序的运行结果是：
current height is 100
很多时候，注册的时候并不调用回调函数，而是在其他函数中调用，那我们可以定义一个CallbackFun全局指针变量，在注册的时候将函数指针赋给它，在要调用的调用它。如

//定义全局指针变量
CallbackFun* m_pCallback;
//定义注册回调函数
void registHeightCallback(CallbackFun callback, void* contex)
{
	m_pCallback = callback;
}
//定义调用函数
void printHeightFun(double height)
{
	m_pCallback(height,nullptr);
}
//main函数
void main()
{
	//注册回调函数onHeight
	registHeightCallback(onHeight,nullptr);
	//打印height
	double h=99;
	printHeightFun(99);
}

程序的运行结果是：
current height is 99

C++回调函数

C++回调函数扩展自C，与C略有不同的是，C++可以使用全局函数和静态函数作为回调函数。考虑到全局函数会破坏封装性，所以一般都用静态成员函数。故除了理解函数指针，还要理解静态成员函数，具体一点是在静态成员函数中访问非静态成员函数的方法，因为我们很可能需要获取静态成员函数中的数据。

使用场景描述

比如说你使用了别人提供的sdk，这个sdk可能来自供应商，也有可能来自你的同事，他就提供给你一个注册回调函接口，比如就下面这个，你可以通过回调函数获取到height（某种传感器的实时返回的数据），你要怎么做？

C++回调函数定义

//CallbackFun类型
//@CallbackFun 指向函数的指针类型
//@height      回调参数，当有多个参数时，可以定义一个结构体
//@contex      回调上下文，在C中一般传入nullptr，在C++中可传入对象指针
typedef void (*CallbackFun)(double height, void* contex);

//注册回调函数接口
//@registHeightCallback 注册函数名
//@callback             回调函数原型
//@contex               回调上下文
void registHeightCallback(CallbackFun callback, void* contex)

首先，你要定义一个静态成员函数并注册。

//sensorTest.cpp
//接收数据类class Sensor
class Sensor{
public:
	Sensor(){}
	~Sensor(){}
	//定义回调函数onHeight
	static void onHeight(double height, void* contex)
	{
		cout << "current height is  " << height << endl;
	}
	//定义注册回调函数
	void registCallback()
	{
		registHeightCallback(onHeight, this);
	}
}

//main 函数
void main()
{
	Sensor sens;
	sens.registCallback();
}

运行程序，我们发现控制台一直在打印
current height is **
说明我们的回调函数正确实现了。到这一步不难，只要掌握基本的回调函数概念都能实现。
现在我们有这样一种情况，我们有另外一个类，要在这个类里面实时打印获取的数据，要怎么做呢？

静态成员函数访问非静态成员函数的方法

我们知道静态成员函数中是只能出现静态变量和静态函数的，但是有些时候真的需要访问非静态成员函数或变量，比如我上面说的那种情况。让我们先来实现对同一个类中的非静态成员函数的访问。
修改class Sensor如下

//接收数据类class Sensor
class Sensor{
public:
	Sensor(){}
	~Sensor(){}
	//定义回调函数onHeight
	static void onHeight(double height, void* contex)
	{
		//cout << "current height is  " << height << endl;
		Sensor* sen = (Sensor*)contex;
		if(sen)  //注意判断sen是否有效
			sen->getHeight(height);
	}
	//定义注册回调函数
	void registCallback()
	{
		registHeightCallback(onHeight, this);
	}
	//新增的成员函数
	void getHeight(double height)
	{
		cout << "current height is  " << height << endl;
	}
}

如此修改之后，得到与修改前一样的效果（实时打印height），关键点在于注册回调函数的时候将Sensor对象的指针传给了contex，在回调函数中又将contex转换为Sensor对象指针，所以能调用普通函数。
同理，如果注册时传入某一个对象的指针，就可以在回调函数中对该对象进行操作，这就是我们可以在一个对象中回调另一个对象的思想。

回调对象

现在开始解决之前提出的问题，本质是不变的，回调是指针传递，可以是函数指针，也可以是对象指针。

//先定义一个类class DataPrint
//打印数据类class DataPrint
class DataPrint{
public:
	DataPrint(){}
	~DataPrint(){}
	void printHeight(double height)
	{
		cout << "print height is " << height << endl;
	}
}

//要在类Sensor中增加DataPrint的指针和一个DataPrint指针赋值函数，class Sensor修改为
//接收数据类class Sensor
class Sensor{
public:
	Sensor(){}
	~Sensor(){}
	//定义回调函数onHeight
	static void onHeight(double height, void* contex)
	{
		DataPrint* dp = (DataPrint*)contex;
		if(dp)  //注意判断dp是否有效
			dp->printHeight(height);
	}
	//定义注册回调函数
	void registCallback()
	{
		registHeightCallback(onHeight, m_pDataPrint );
	}
	//新增的成员函数
	void getHeight(double height)
	{
		//cout << "current height is  " << height << endl;
	}
	void setDataPrint(DataPrint* dp)
	{
		m_pDataPrint = dp;
	}
private:
	DataPrint* m_pDataPrint;
}

//main主函数
void main()
{
	DataPrint* dp=new DataPrint();
	Sensor* sens=new Sensor();
	//注意这两句的顺序不能颠倒
	sens->setDataPrint(dp);
	sens->registCallback();
}

这样就能实现在另一个类中取得回调函数的数据，如果无法保证DataPrint的实例化一定在Sensor之前，我们可以这样做

//先定义一个类class DataPrint
//打印数据类class DataPrint
class DataPrint{
public:
	DataPrint(){}
	~DataPrint(){}
	void printHeight(double height)
	{
		cout << "print height is " << height << endl;
	}
}

//要在类Sensor中增加DataPrint的指针和一个DataPrint指针赋值函数，class Sensor修改为
//接收数据类class Sensor
class Sensor{
public:
	Sensor(){}
	~Sensor(){}
	//定义回调函数onHeight
	static void onHeight(double height, void* contex)
	{
		Sensor* sen= (Sensor*)contex;
		if(sen)  //注意判断sen是否有效
			sen->getHeight(height);
	}
	//定义注册回调函数
	void registCallback()
	{
		registHeightCallback(onHeight, m_pDataPrint );
	}
	//新增的成员函数
	void getHeight(double height)
	{
		if(m_pDataPrint )
			m_pDataPrint ->printHeight(height);
	}
	void setDataPrint(DataPrint* dp)
	{
		m_pDataPrint = dp;
	}
private:
	DataPrint* m_pDataPrint;
}

//main主函数
void main()
{
	DataPrint* dp=new DataPrint();
	Sensor* sens=new Sensor();
	//注意这两句的顺序可以颠倒
	sens->setDataPrint(dp);
	sens->registCallback();
}

两个的区别是一个直接注册指定类的对象指针，另一个注册当前类的对象指针，间接调用另一个类的对象指针。

更复杂的讨论

刚才讨论的问题稍微复杂一点了，不过应该也容易理解，但是我们在实际项目中遇到的情况可能比这个复杂。比如在有层次的软件工程中，回调函数在底层，显示数据的类在上层，我们要如何把底层的数据显示到上层去？容易想到的是上层调用底层，如开个timer刷新，但这是不对的，你无法做到实时调用，你需要的是一个异步的机制，即底层一发生上层就能接收到。
怎么做呢？还是一样的道理，把上层的类的对象指针传给底层，这时底层需要包含上层的头文件，但这是不对的，上层已经包含了底层的头文件，它们不能互相包含，如何解决这个问题？那就要用到C++继承的特性，首先在底层定义一个基类，然后在上层继承它，在上层实例化这个继承类后，将其指针设置给底层，底层对该指针的操作就是对继承类对象的操作，以此实现数据的传递。

参考：

[1] https://www.jianshu.com/p/26784d962f58

[2] https://blog.csdn.net/weixin_40237626/article/details/82801409

[3] https://blog.csdn.net/sinat_38183777/article/details/83958887

[4] https://blog.csdn.net/yidu_fanchen/article/details/80513359

qican_7

关注

37
点赞
踩
254

收藏

觉得还不错? 一键收藏
1
评论
回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。其实回调就是一种利用函数指针进行函数调用的过程.为什么要用回调呢?比如我要写一个子模块给你用,来接收远程socket发来的命令...
复制链接

扫一扫

专栏目录