CallBack Function--1

在C中写回调函数非常方便，C++中定义回调函数要麻烦一些，成员函数牵涉到一个this指针问题。C++中的static成员函数没有this指针，也可以直接作为回调函数使用。C++的成员函数地址是唯一确定的，数据变量地址是可变的，因此编译器使用this指针把这两个部分连接起来，我们调用c++的成员函数，编译器会添加一个this指针到参数中。

有一个类CTest

class CTest
{
public:
void DoMsgFunc1(char* pMsg,int nID)
{
}

void RegiestMsg(int nSrcID,DoMessageFunc pFunc)
{
m_pFunc = pFunc;
}

void HandleMessage(int nMsgID, char* pMsg, int nID)
{
(this->*m_pFunc)(pMsg,nID);
}

private:
DoMessageFunc m_pFunc;
};

定义CTest中的一个回调函数原型：
typedef void (CTest::*DoMessageFunc)(char* pMsg,int nID);
这样在类中就可以直接使用了。

注册回调函数时候，使用如下例子
CTest obj;
obj.RegiestMsg(13,&CTest::DoMsgFunc1);

如果CTest有很多派生类，如
class CTest1 ： public CTest

则CTest1注册回调函数的时候，需要强制转换一下，如下
CTest1 obj1;
obj1.RegiestMsg(11,(DoMessageFunc)&CTest1::DoMsgFunc2);

MFC中的消息映射也是同样的道理，能够进行消息映射的类都是从CCmdTarget派生下来的，看看ON_COMMAND宏定义的实现就明白了。

#define ON_COMMAND(id, memberFxn) /
{ WM_COMMAND, CN_COMMAND, (WORD)id, (WORD)id, AfxSigCmd_v, /
static_cast AFX_PMSG (memberFxn) },

其中AFX_PMSG的定义如下：
typedef void (AFX_MSG_CALL CCmdTarget::*AFX_PMSG)(void)

 

 

 

 

回调函数这个东西使用得比较多,其实所谓的回调函数就是函数指针,但在面向对象编程中,往往我们会使用他们达到很巧的目的,比如说类的封装中;或者用得更多的是实现动态绑定;呵呵这不是C++中传说的多态吗.
先来个简单的介绍函数指针:

Copy code

#include<iostream>
typedef int(*callback)(int);
using namespace std;
class X
{
protected: int xx;
public:
X()
{
xx=11;
// hh=22;
}
static int get_hh(int a)
{
cout<<"函数get_hh"<<endl;
return a;
}
};
class Y
{
private: int xx;
  X   X_class;
  callback lp;
public:
Y()
{
xx=7;
}
int hehe(callback lp)
{
lp(xx);
return xx;
}
void xixi()
{
lp=&X::get_hh;
}
};
int f_xx(int a)
{
cout<<"这是全局函数f_xx:"<<a<<endl;
return a;
}
int main(int argc,char *argv[],char env[])
{
int xx;
callback lp;
xx=111;
cout<<"呵呵！！"<<endl;
cout<<"第一步：函数指针"<<endl<<"---------------------------------------------------------"<<endl;
lp=&X::get_hh;
cout<<"这就是函数指针直接调类中的静态成员函数get_xx:"<<endl;
cout<<lp(xx)<<endl;
lp=&f_xx;
cout<<"这就是函数指针直接全局函数f_xx:"<<lp(xx)<<endl;
cout<<"第二步：跨类回调"<<endl<<"---------------------------------------------------------"<<endl;
Y Y_class;
lp=&X::get_hh;
cout<<"这就是在Y类中调用了X类中的方法"<<endl;
cout<<Y_class.hehe(lp)<<endl;
cin>>xx;
return 0;
}

主要需要注意的是在使用函数指针的时候,如果指向的函数是在某个类中,则该函数必须是静态成员函数
还有函数指针的申明格式,怪怪的哈,呵呵用多了就不觉得了 ,接下来我们用它来干点面向对象因该干的事情:

Copy code

include<iostream>
using namespace std;
typedef int(*callback)(int);
class X
{
public:
int X_test(callback lp,int a)
{
a--;
cout<<"执行回调函数的之前，传入参数变成："<<endl;
cout<<a<<endl;
a=lp(a);
cout<<"执行回调函数的之后，传入参数变成："<<endl;
cout<<a<<endl;
return a;
}
};
class Y
{
protected: int xx;
private : X   X_class;
  callback lp;
public:
Y(int a)
{
xx=a;
}
static int hehe(int a)
{
for(int i=1;i<=10;i++)
{
  a++;
}
return a;
}
void xixi()
{
X c_x;
lp=&hehe;
xx=c_x.X_test(lp,xx);
cout<<"最终结果传到Y类中的xx变成了："<<endl;
cout<<xx<<endl;
}
};
int main(int argc,char *argv[],char env[])
{
int xx;
Y *y_c=new Y(100);
y_c->xixi();
return 0;
}

这样在X类中使用了Y类中的方法,现在我们的X类只是做加法,而减法放在了Y类中.当然这个只是为了便于理解才简化的,只是一个类比,比如一个类实现数据处理而另外一个实现视图处理.是不是??