C/C++之回调函数
今天讨论下C/C++中的回调函数。
在理解“回调函数”之前,首先讨论下函数指针的概念。
函数指针
(1)概念:指针是一个变量,是用来指向内存地址的。一个程序运行时,所有和运行相关的物件都是需要加载到内存中,这就决定了程序运行时的任何物件都可以用指针来指向它。函数是存放在内存代码区域内的,它们同样有地址,因此同样可以用指针来存取函数,把这种指向函数入口地址的指针称为函数指针。
(2)先来看一个Hello World程序:
int main(int argc,char* argv[])
{
printf("Hello World!\n");
return 0;
}
然后,采用函数调用的形式来实现:
void Invoke(char* s);
int main(int argc,char* argv[])
{
Invoke("Hello World!\n");
return 0;
}
void Invoke(char* s)
{
printf(s);
}
用函数指针的方式来实现:
void Invoke(char* s);
int main()
{
void (*fp)(char* s); //声明一个函数指针(fp)
fp=Invoke; //将Invoke函数的入口地址赋值给fp
fp("Hello World!\n"); //函数指针fp实现函数调用
return 0;
}
void Invoke(char* s)
{
printf(s);
}
由上知道:函数指针函数的声明之间唯一区别就是,用指针名(*fp)代替了函数名Invoke,这样这声明了一个函数指针,然后进行赋值fp=Invoke就可以进行函数指针的调用了。声明函数指针时,只要函数返回值类型、参数个数、参数类型等保持一致,就可以声明一个函数指针了。注意,函数指针必须用括号括起来 void (*fp)(char* s)。
实际中,为了方便,通常用宏定义的方式来声明函数指针,实现程序如下:
typedef void (*FP)(char* s);
void Invoke(char* s);
int main(int argc,char* argv[])
{
FP fp; //通常是用宏FP来声明一个函数指针fp
fp=Invoke;
fp("Hello World!\n");
return 0;
}
void Invoke(char* s)
{
printf(s);
}
函数指针数组
下面用程序对函数指针数组来个大致了解:
#include <iostream>
#include <string>
using namespace std;
typedef void (*FP)(char* s);
void f1(char* s){cout<<s;}
void f2(char* s){cout<<s;}
void f3(char* s){cout<<s;}
int main(int argc,char* argv[])
{
void* a[]={f1,f2,f3}; //定义了指针数组,这里a是一个普通指针
a[0]("Hello World!\n"); //编译错误,指针数组不能用下标的方式来调用函数
FP f[]={f1,f2,f3}; //定义一个函数指针的数组,这里的f是一个函数指针
f[0]("Hello World!\n"); //正确,函数指针的数组进行下标操作可以进行函数的间接调用
return 0;
}
回调函数
(1)概念:回调函数,顾名思义,就是使用者自己定义一个函数,使用者自己实现这个函数的程序内容,然后把这个函数作为参数传入别人(或系统)的函数中,由别人(或系统)的函数在运行时来调用的函数。函数是你实现的,但由别人(或系统)的函数在运行时通过参数传递的方式调用,这就是所谓的回调函数。简单来说,就是由别人的函数运行期间来回调你实现的函数。
(2)标准Hello World程序:
int main(int argc,char* argv[])
{
printf("Hello World!\n");
return 0;
}
将它修改成函数回调样式:
//定义回调函数
void PrintfText()
{
printf("Hello World!\n");
}
//定义实现回调函数的"调用函数"
void CallPrintfText(void (*callfuct)())
{
callfuct();
}
//在main函数中实现函数回调
int main(int argc,char* argv[])
{
CallPrintfText(PrintfText);
return 0;
}
修改成带参的回调样式:
//定义带参回调函数
void PrintfText(char* s)
{
printf(s);
}
//定义实现带参回调函数的"调用函数"
void CallPrintfText(void (*callfuct)(char*),char* s)
{
callfuct(s);
}
//在main函数中实现带参的函数回调
int main(int argc,char* argv[])
{
CallPrintfText(PrintfText,"Hello World!\n");
return 0;
}
至此,对回调函数应该有了一个大致的了解。
https://blog.csdn.net/bingbaobei/article/details/51782990
转载来自http://blog.163.com/ssou_1985/blog/static/2953203620123361340352/
看了人家的例子,比看那么多定义好多了。一看就明白了。好人啊!老外把国人玩的不是人了。国人还自己玩自己。非把一个简单的东西复杂化。叫那么难理解!!完啦,窝里斗的典型!!!!!!!!
回调函数:我的理解。假设 A是回调函数,B是调用者,B参数里一个是指向A的函数指针,即回调A,同时另外的参数传递给A作为参数。A可以是多个函数的统一指向,只要函数参数个数相同即可。
WINDOWS回调函数:永远不会被程序中的其他函数或子程序调用。只能由操作系统调用。因此,windows可以通过传递不同参数给回调函数达到和程序沟通的目的。
那么:B调用A,A也有参数,有参数就要赋值才行。所以B函数内部给A参数赋值。B调用A,A又利用了B给的参数。
A就是回调函数。B就是调用者。
int* func(int params, ...); //这就是指针函数
当一个函数的返回值是一个指针时,该函数就是一个指针函数。
函数代码是程序的算法指令部分,它们和数组一样也占用存储空间,都有相应的地址。
同比指针变量指向数组首地址,也可以使用指针变量指向函数代码的首地址,指向函数代码首地址的指针变量称为函数指针。
回调函数参数可以空或者定义成void类型。方便不同类型的数据传入。通用性强。
int sort_function( const void *a, const void *b); //参数类型是void 两个参数。传入参数可以任意类型。更通用。 回调函数的实现,参数也用void。类型由调用者传的参数决定。
#include<stdio.h>
// 方法指针的格式为:int (*ptr)(char *p) 即:返回值(指针名)(参数列表)
typedef int (*CallBackFun)(char *p); // 为回调函数命名,类型命名为 CallBackFun,参数为char *p 。
//下面是两个被调用者,就是回调函数的实现。回调函数是他们的统一格式。
int Afun(char *p)
{ // 方法 Afun,格式符合 CallBackFun 的格式,因此可以看作是一个 CallBackFun
printf("Afun 回调打印出字符%s!\n", p);
return 0;
}
int Cfun(char *p) { // 方法 Bfun,格式符合 CallBackFun 的格式,因此可以看作是一个 CallBackFun
printf("Cfun 回调打印:%s, Nice to meet you!\n", p);
return 0;
}
/*********************************************************************/
//下面的这些是调用者:有几种方式,看你喜欢哪种
int call(CallBackFun pCallBack, char *p)
{ // 执行回调函数,方式一:通过命名方式
printf("call 直接打印出字符%s!\n", p);
pCallBack(p);
return 0;
}
/*********************************************************************/
int call2(char *p, int (*ptr)())
{ // 执行回调函数,方式二:直接通过方法指针
printf("==============\n", p);
(*ptr)(p);
}
/*********************************************************************/
int call3(char *p, CallBackFun pCallBack)
{ // 执行回调函数,方式一:通过命名方式
printf("--------------\n", p);
pCallBack(p);
}
/*********************************************************************/
int main()
{
char *p = "hello";
call(Afun, p); //调用Afun回调函数,传递参数*P给Afun函数
call(Cfun, p); //调用Cfun回调函数,传递参数*P给Afun函数
call2(p, Afun); //调用Afun回调函数,传递参数*P给Afun函数
call2(p, Cfun); //调用Cfun回调函数,传递参数*P给Afun函数
call3(p, Afun); //调用Afun回调函数,传递参数*P给Afun函数
call3(p, Cfun); //调用Cfun回调函数,传递参数*P给Afun函数
// int i = getchar();
// printf("Input: %c \n", i);
return 0;
}
/*********************************************************************/
Linux下的编译、输出:
[jhliu@localhost src]$ gcc -o func_callback func_callback.c
[jhliu@localhost src]$ ./func_callback
call 直接打印出字符hello!
Afun 回调打印出字符hello!
==============
call 直接打印出字符hello!
Cfun 回调打印:hello, Nice to meet you!
==============
Afun 回调打印出字符hello!
==============
Cfun 回调打印:hello, Nice to meet you!
--------------
Afun 回调打印出字符hello!
--------------
Cfun 回调打印:hello, Nice to meet you!
[jhliu@localhost src]$
成为C++高手之回调函数
置顶 2016年05月19日 05:03:51 牛搞 阅读数:11211更多
所属专栏: 成为C++高手
上一节的排序函数只能正向排序,那我们需要反向排序怎么办?可以增加一个参数嘛,传入TRUE,就表示要正向排,传入FALSE,就表示要反向排。要改变排序方向,只需改变两项比较时是用大于号还是小于号即可。但是这里有更高级的玩法,即传入的参数不是一个BOOL型值,而是一个函数指针。
函数名本身就是一个指针,调试时看函数名,其值就是一个地址。但在逻辑上不能把函数名叫函数指针,必须另创建一个指针指向这个函数,通过这个指针调用函数才叫回调。
函数指指与变量指针没实质区别,都是保存一个表示内存位置的整数,但编译器必须能区分指针的类型才行。所以函数指针在定义时必须指定其类型。所以要为函数定义类型。函数类型是由函数返回值类型、参数数量、参数类型决定,与函数的实现无关。就是长一个样的函数都是同一类型。
我们这里增加一个参数,传入的函数指针指向一个比较函数,仅代替“arr[j]>arr[j+1]”部分。比较函数必须有两个参数指向要比较的元素的序号,返回必须是BOOL型数据,表示比较结果。if语句跟据比较函数返回值决定是否交换位置。
#include <stdio.h>
//定义比较函数类型
typedef int (*CompareFunc)(int *,int ,int );
//前置声明排序函数,第三个参数是比较函数类型
void sort(int * ,int ,CompareFunc);
//返回非0数表示比较成功,返回0表示失败
int compare1(int *arr,int a,int b){
return arr[a]>arr[b];
}
int compare2(int *arr,int a,int b){
return arr[a]<arr[b];
}
int main(int argc, const char * argv[]) {
int arr[]={22,33,45,1,2,7,66,554,23424234,22};
//排序,第三个参数可以传入两个比较函数之一
sort(arr,sizeof(arr)/sizeof(int),compare1);
//打印排序后的数组
for(int i=0;i<sizeof(arr)/sizeof(int);i++){
printf("%d ",arr[i]);
}
return 0;
}
//第一个参数是要排序的数组,第二个是数组两元素的数量
void sort(int *arr ,int count,CompareFunc compare_func){
int i;
//外层循环是倒着来的
for(i=count-1;i>0;i--){
int j;
for(j=0;j<i;j++){
//调用比较函数进行比较
if(compare_func(arr,j,i)){
int tmp = arr[j];
arr[j]=arr[i];
arr[i]=tmp;
}
}
}
}
改用回调函数有什么好处呢?此处并不明显,甚至更麻烦。但试想这种情况:如果我们数组中不是简单数值,而是一个结构。比如扑克牌,一张牌至少有两个属性:花色和点数,对应到结构中就是两个成员变量。当牌发到玩家手中后,是乱序的,玩家需要整理好其顺序。不同的游戏有不同的排序规则,那我们可以为每种游戏规则都写一个不同的排序函数,或者这样做:排序函数固定,只为每种不同的游戏写不同的比较函数。这增强了排序代码的重用性。
上一篇:成为C++高手之for循环