C++学习笔记：回调函数使用

1、背景介绍：

回调函数其实就是一个通过函数指针调用的函数！假如你把A函数的指针当作参数传给B函数，然后在B函数中通过A函数传进来的这个指针调用A函数，那么这就是回调机制。A函数就是回调函数，而通常情况下，A函数是系统在符合你设定条件的情况下会自动执行，比如Windows下的消息触发等等。那么调用者和被调用者的关系就被拉开了，就像是中断处理函数那样。

函数指针是一个指针，只是这个指针它不像普通的指针指向是是一个变量，此时它指向的是一个函数，也就是它存储的是一个函数的地址，如果我们愿意的话，可以改变这个它的值，让他由指向funA转变为指向funB，那么这个函数指针的作用就改变了。

2、定义使用：

函数指针的声明

typedef 返回类型（*函数指针类型名）（函参列表）;

3、使用例子：

代码：

注意在对函数指针进行赋值的时候，右侧的一定要是函数的指针，并且两者的参数和返回类型相同。

#include <iostream>
typedef void(*Fun)(int,int); //定义函数指针类型
void min(int a,int b);
void max(int a,int b);

void min(int a,int b)
{
    int minvalue=a<b?a:b;
    std::cout<<"min value is "<<minvalue<<"\n";
}

void max(int a,int b)
{
    int maxvalue=a>b?a:b;
    std::cout<<"Max value is "<<maxvalue<<"\n";
}

int main(int argc, char* argv[])
{
    Fun pFun=NULL; //定义函数指针变量pFun
    //pFun=min;//两种赋值方式都支持
    pFun=&min;//
    pFun(1,2);//这里获得最小值
    //pFun=max;
    pFun=&max;
    pFun(1,2);//这里获得最大值
    return 0;
}

运行结果：

4、例子2：

1）包含两种回调方式：变量和指针方式。具体参见代码中的情况2和情况3！

2）无参数的回调和1个参数情况下的回调

#include <iostream>

typedef void(*Fun)(int,int); //定义函数指针类型
void min(int a,int b);
void max(int a,int b);
void min(int a,int b)
{
    int minvalue=a<b?a:b;
    std::cout<<"min value is "<<minvalue<<"\n";
}
void max(int a,int b)
{
    int maxvalue=a>b?a:b;
    std::cout<<"Max value is "<<maxvalue<<"\n";
}
//两个输入参数的调用方法2:通过命名方式
void call2(Fun fun2,int a,int b)
{
    fun2(a,b);
}
//两个输入参数的调用方法3:直接通过方法指针
void call2_1(void(*Fun)(int,int),int a,int b)
{
    (*Fun)(a,b);
}
//无输入参数的情况
typedef void (*Fun0)();
void caller0(Fun0 myfun)
{
    myfun();
}
void func0()
{
    std::cout<<"无输入参数哦!"<<std::endl;

}
//1个输入参数,直接调用
typedef void (*Fun1)(char *p);//另一种函数指针

//被调函数,用户在调用该函数怒时,需要自己实现一个回调函数
void caller1(Fun1 myfun1,char *p)
{
    myfun1(p);
}
//回调函数
void func1(char *p)
{
    std::cout<<p<<std::endl;

}
//可以直接把func1当作一个变量传递给caller,
//caller(func1);
int main(int argc, char* argv[])
{
    std::cout<<"有两个参数的调用情况1:"<<std::endl;
    Fun pFun=NULL; //定义函数指针变量pFun
    //pFun=min;//两种赋值方式都支持
    pFun=&min;//
    pFun(1,2);//这里获得最小值
    //pFun=max;
    pFun=&max;
    pFun(1,2);//这里获得最大值
    std::cout<<"有两个参数的调用情况2:"<<std::endl;
    std::cout<<"调用方式call2(max,5,6)"<<std::endl;
    call2(max,5,6);
    std::cout<<"有两个参数的调用情况3:"<<std::endl;
    std::cout<<"调用方式call2_1(max,10,15)"<<std::endl;
    call2_1(max,10,15);
    std::cout<<"无参数的情况:"<<std::endl;
    caller0(func0);
    std::cout<<"1个参数的情况:"<<std::endl;
    char *s="HelloWorld";
    //Fun1 f1=func1;
    caller1(func1,s);
    return 0;
}

运行结果如下图所示：

附上类中的使用例子：

#include<iostream>
using namespace std;
class A
{public:
	bool OnlyPrint(int a, const std::string &str="helloworld");
	bool A_print(std::string a, int b);//不同情况下调用不同的函数
	bool B_print(std::string a, int b);//注意参数和类型要完全相同
	bool C_print(std::string a, int b);
};

bool A::OnlyPrint(int a, const std::string &str)
{
	bool (A::*func)(std::string, int) =NULL;
	if(str == "A")
	{
		func = &A::A_print;
	}
	else if(str == "B")
	{
		func = &A::B_print;
	}
	else if(str == "C")
	{
		func = &A::C_print;
	}
	else
	{
		return false;
	}
	return (*this.*func)("ImHere",a);
}
bool A::A_print(std::string a, int b)
{
	std::cout<<"print A! and I am A!"<<std::endl;
}
bool A::B_print(std::string a, int b)
{
	std::cout<<"print B! and I am B!"<<std::endl;
}
bool A::C_print(std::string a, int b)
{
	std::cout<<"print C! and I am C!"<<std::endl;
}

int main()
{
	A a1;
	a1.OnlyPrint(10,"B");
	return 0;
}