回调函数思考

/*
 * 直接调用函数指针,因为函数名即是函数指针
 * int testFun1(int param1,long param2,float param3); //普通函数定义
 * 该函数的类型为int(int,long,float),该类型的函数指针可以定义为如下：
 * int (*pfunc)(int,long,float);	//注意(*pTf)，括在一起
 */
#include <iostream>
using namespace std;

#define TEST_FUNC_ARRAY	 0
#define TEST_CALLBACK	 1


#define MAX_SIZE 3
typedef void (*printf_func)(int num, int cnt);	//定义一个函数指针类型

printf_func func_array[MAX_SIZE] = {NULL};

void printf_func1(int num, int cnt)
{
	for(int i=0; i<(1*cnt); i++){
		cout<< num; 
	}
	cout<<endl<<"func1"<<"over!!"<<endl;
}

void printf_func2(int num, int cnt)
{
	for(int i=0; i<(2*cnt); i++){
		cout<< num; 
	}
	cout<<endl<<"func2"<<"over!!"<<endl;
}

void printf_func3(int num, int cnt)
{
	for(int i=0; i<(3*cnt); i++){
		cout<< num; 
	}
	cout<<endl<<"func3""over!!"<<endl;
}
/*
1.“拉”模式通信（B一直问A你要不要去B房间，当A需要去B房间的时候，B拿钥匙房间打开）
在该模式下，假定对象A要从对象B中获取实时数据信息，“拉”模式的工作机制如下：
（1）对象A开启一个线程，该线程执行一个循环，每隔一定时间间隔，向对象B发出数据请求；
（2）对象B一旦有新的信息，就利用对象B的数据请求，将信息发送给对象B。
注意：该模式的主要问题是需要维护一个循环线程。时间间隔太长会导致，通信的实时性下降；时间间隔太短，会导致CPU浪费太多。
2.“推”模式通信（B把房间的钥匙给A，说A你需要的时候，A自己拿钥匙去开门）
在该模式下，假定对象A要从对象B中获取实时数据信息，“推”模式的工作机制如下：
（1）对象A在调用对象B时，向其传递一个回调函数；
（2）对象B一旦有新的信息，就调用对象A传递过来的函数指针，将最新的信息发送给对象A。
注意：该模式完美解决了“拉“模式产生的问题，不但保证了数据传输的实时性，而且降低了无用的CPU消耗。一般的通信协议，建议采用”推“模式。
*/

/*
 * 被调函数
 */
void printf_func0(int num, int cnt)
{
	for(int i=0; i<cnt; i++){
		cout<< num; 
	}
	cout<<endl<<"func"<<num<<"over!!"<<endl;
}

/*
 * 回调函数
 */
int call_test(int num, int cnt, printf_func pcallback)
{
	pcallback(num, cnt);
	return 0;
}

int main(int argc, char* argv[])
{
	int i = 0;
#if TEST_FUNC_ARRAY
	func_array[0] = printf_func1;
	func_array[1] = printf_func2;
	func_array[2] = printf_func3;

	for(i=0; i<MAX_SIZE; i++){
		func_array[i](2, 3);
	}
#endif

#if TEST_CALLBACK
	call_test(3, 3, printf_func0);	//实际调用
	call_test(3, 6, printf_func0);
	call_test(3, 9, printf_func0);
#endif

	system("pause");
	return 0;
}

上层调用下层：直接调用，粗暴的函数嵌套；
下层调用上层：利用回调，下层定义好接口规范Fun_A(Func_B)，上层按照Func_B这个规范定义回调函数，并注册回调，下层适时地会调用。

回调函数就是函数指针的一种用法