数学建模社区-数学中国

标题: 在C++ Builder中定义事件 [打印本页]

作者: xShandow 时间: 2004-11-17 19:28
标题: 在C++ Builder中定义事件
<

>在C++ BUILDER中，事件是一种委托模型，它是对消息的封装。如果你用过VC，你就知道在VC中并不存在什么事件，而只有消息处理函数，而在C++ BUILDER中则是由事件处理函数来负责响应消息。同是，事件本身也是一指针，它是一个闭包，通常在C++ BUILDER中有两种事件：通知类型事件（即TNOTIFYEVENT,对WINDOWS消息的封装）和自定义事件。除此之外，我们也知道事件是通过一个虚拟函数来点燃的，比如说ONEXIT事件是由DOEXIT虚拟函数点燃的,下面我写一个自定义事件,很明显以下我写的代码中的事件将是对WM_MYMESSAGE消息的封装.
.h File
#include <....>
.....
#define WM_MYMESSAGE WM_USER+100
typedef void __fastcall (__closure *TMyEvent)(TObject *Sender,Param1,Param2,......);
<

>class TMyControl:public TWinControl
{
private:
TMyEvent FOnMyEvent;//保存指向事件的指针.
void __fastcall DoSomething(TMessage &Message);
public:
BEGIN_MESSAGE_MAP
VCL_MESSAGE_HANDLER(WM_MYMESSAGE,TMessage,DoSomething);
END_MESSAGE_MAP(TControl);
protected:
virtual void __fastcall DoMyEvent(Param1,........);//由这个虚拟函数来触发事件
virtual void __fastcall WndProc(TMessage &Message);
__published:
.........
__property TMyEvent OnMyEvent={read=FOnMyEvent,write=FOnMyEvent};
.....
};
<

>.cpp File
<

>//Omiting constructor and deconstructor
//Virtual function,which will spring the event:TMyEvent
void __fastcall TMyControl:

oMyEvent(Param1,.....)
{
if(FOnMyEvent)
{
FOnMyEvent(this,Param1,Param2,.....Paramn);
}
}
//Message Handler
void __fastcall TMyControl:

oSomething
{
//TODAdd your code here....
}
void __fastcall TMyControl::WndProc(TMessage &Message)
{
if(Message.Msg==WM_MYMESSAGE)
{
DoMyEvent(Message.WParam,.....);
}
......
}
按照上而的代码,我们就会在OBJECT INSPECTOR中看到一个ONMYEVENT事件,和其它事件一样,用户只要将代码写到这里来就可以响应消息并根据应用的需求来给出这个事件触发时的行为,上面代码是随手写的,请各位自已加以调整.
<

> 
<

>__closure是一个很奇妙的东西!很不错,很可惜,VC不支持!目前也只有Borland的编译器支持.

作者: madio 时间: 2004-11-17 19:56
<

>__closure是一个很奇妙的东西!很不错,很可惜,VC不支持!目前也只有Borland的编译器支持<

>能不能说说奇妙之处呀！

作者: xShandow 时间: 2004-11-18 09:31
<

>说一个不是太标准的吧,他可以当成一个函数指针来使用.<

>我就拿C++Builder里的帮助给你看看吧.<

>__closure<

>The __closure keyword is used to declare a special type of pointer to a member function. In standard C++, the only way to get a pointer to a member function is to use the fully qualified member name, as shown in the following example: <

>class base<

>{
 public:
void func(int x) { };
};
typedef void (base::* pBaseMember)(int);
int main(int argc, char* argv[])
{
 base baseObject;
 pBaseMember m = &base::func; // Get pointer to member 'func'
 // Call 'func' through the pointer to member
 (baseObject.*m)(17);
 return 0;
}<

>However, you cannot assign a pointer to a member of a derived class to a pointer to a member of a base class. This rule (called contravariance) is illustrated in the following example:<

>class derived: public base<

>{
 public:
void new_func(int i) { };
};
int main(int argc, char* argv[])
{
 derived derivedObject;
 pBaseMember m = &derived::new_func; // ILLEGAL
 return 0;
}<

>The __closure keyword extension allows you to skirt this limitation, and more. Using a closure, you can get a pointer to member function for an object (i.e. a particular instance of a class). The object can be any object, regardless of its inheritance hierarchy. The object抯 this pointer is automatically used when calling the member function through the closure. The following example shows how to declare and use a closure. The base and derived classes provided earlier are assumed to be defined.<

>int main(int argc, char* argv[])<

>{
 derived derivedObject;
 void (__closure *derivedClosure)(int);
 derivedClosure = derivedObject.new_func; // Get a pointer to the 'new_func' member.
 // Note the closure is associated with the
 // particular object, 'derivedObject'.
 derivedClosure(3); // Call 'new_func' through the closure.
 return 0;
}<

>Closures also work with pointers to objects, as illustrated in this example:<

>void func1(base *pObj)<

>{
// A closure taking an int argument and returning void.
void ( __closure *myClosure )(int);<

> // Initialize the closure.<

> myClosure = pObj->func;<

> // Use the closure to call the member function.<

> myClosure(1);
return;
}<

>int main(int argc, char* argv[])<

>{
 derived derivedObject;
 void (__closure *derivedClosure)(int);
 derivedClosure = derivedObject.new_func; // Same as before...
 derivedClosure(3);
 // We can use pointers to initialize a closure, too.
 // We can also get a pointer to the 'func' member function
 // in the base class.
 func1(&derivedObject);
 return 0;
}<

>Notice that we are passing a pointer to an instance of the derived class, and we are using it to get a pointer to a member function in the base class - something standard C++ does not allow us to do.
Closures are a key part of the C++ Builder RAD environment. They give us the ability to assign an event handler in the Object Inspector. For example, a TButton object has an event called OnClick. In the TButton class, the OnClick event is a property that uses the __closure keyword extension in its declaration. The __closure keyword allows us to assign a member function of another class (typically a member function in a TForm object) to the property. When you place a TButton object on a form, and then create a handler for the button抯 OnClick event, C++ Builder creates a member function in the button抯 TForm parent, and assigns that member function to the OnClick event of TButton. This way, the event handler is associated with that particular instance of TButton, and no other.

作者: xShandow 时间: 2004-11-18 09:33
从C++Builder的帮助里看,显示__closure很高明.他出现了,直接可以让C++支持事件处理.

欢迎光临数学建模社区-数学中国 (http://www.madio.net/)