Dynamic function call

Daniel.Andersson@combitechsystems.com Daniel.Andersson@combitechsystems.com
Thu Jun 14 08:04:00 GMT 2001

Thanks for your answer!

> >-----Original Message-----
> >From: Daniel.Andersson@combitechsystems.com
> >Sent: 14 June 2001 13:10
> > The idéa of my code is that all the object that is created 
> within a thread
> >attaches it self to a dispatcher. This is done so that they 
> can receive
> >messages that are sent to that thread. Every object attaches 
> it self in a
> >list that means that when a message is sent to that position 
> in the list
> >then every attached object receives that message.
> >
> >Doesn't the linker support this kind of dynamic calls?
>   Sounds very much like a C++ virtual function call to me.  
> Nothing to do
> with the linker at all.
> >-----clip from the attachfunction in dispatcher-----
> >
> >void CDispatcher::Attach(CCommon* pMsgHandler, Receiver_t RecObj)
> >{
> > AttachedObjects[RecObj] = pMsgHandler;
> >}
> >----endclip------
>   Ok, so for each receiver type, you have an array entry that 
> points to
> the object that wants to receive the messages.  I got the 
> impression from
> the way you described this above that you wanted a *list* of 
> objects of a
> particular type, so they could all receive the message, but 
> you could easily
> extend that code to make a singly-linked list, using a next 
> item pointer in
> the base class CCommon.

Well, i really dont want a list but an array that holds pointers to the
functions that a want to call. I have declared AttachedObjects as "CCommon

> >-----clip from the caller of dispatcher-----
> >Dispatcher.Attach(this, USERS);
> >----endclip------
>   See, that will be the only object that gets messages for 
> USERS: if there
> was already one registered, it will be overwritten in the array. 

I see what you mean but that is not a problem at this time since only one
object wants the message.

> >Here comes all the different ways that i have tried so far. 
> I want to be
> >able to use the first one but is doesn't work. The array 
> AttachedObjects
> >declared as a CBase* AttachedObjects[N] so it will contain 
> of a lot of
>   CBase * ? Do you not mean CCommon * ?  Or is CCommon 
> derived from CBase,
> and the other class types (CUsers, CCar, CNodeman ?) derived 
> from CCommon ?
> >pointers to all the attached objects. None of the three 
> alternatives below
> >works!! The only thing that works is when i hardcode the 
> object name in the
> >function (see clip below)
> >
> >Any hints?
>   It would have been good if you'd told us in what way it 
> doesn't work.
> Does the code fail to compile, or does it just do the wrong thing when
> it executes ?

When i run the line "AttachedObjects[msgRaw->Receiver]->EventHandler(msgRaw)
then i get a "sig trap" from GDB. I assume that this means that i have made
a reference to a memory that isn't available and that the reason for this is
a pointer that has a strange value. However, when i take a look at all the
attached objects (CAR, NODEMANAGER, USERS) in the AttachedObjects[] then
they all reside within RAM so i think that they have correct memory values
in their registered "this"-pointers. 

> >Alt 1
> >AttachedObjects[(msgRaw->Receiver)]->EventHandler(msgRaw);
>   Looking at your code, I would expect that it does compile 
> (although you
> should have shown us the definition of EventHandler), but 
> runs wrong.  And
> here's the problem: all the pointers in the AttachedObjects 
> array are of
> type CCommon *, so the function that gets called here is
> CCommon::EventHandler.  What you really want I assume is for 
> it to call
> (type derived from CCommon)::EventHandler, but the compiler 
> can't do that
> by default, because it doesn't know what type of object the 
> array entry
> points to: it knows that it points to a CCommon object, but 
> it doesn't know
> that that might be the CCommon base part of a derived object.
>   This is exactly the sort of situation that virtual 
> functions were made
> for!  If you declare EventHandler to be a virtual function in 
> the CCommon
> class definition, that means that every object of type 
> CCommon, and every
> object of a type derived from CCommon, will carry around a 
> pointer to the
> EventHandler function for that particular type.  This means 
> that when the
> only pointer you have to the object is of CCommon * type, the 
> compiler will
> still be able to compile code to get to the correct function, 
> by looking
> up the function's address from the actual object itself.
>   For more info, refer to a C++ textbook on the subject of virtual
> functions.

I do have declared the base class (CCommon) function to be virtual: "virtual
void EventHandler(MessageRaw_t *pMsg);" since i always want to override it
with my functions in the derived classes.

Can it be something with my environment that doesn't handle this dynamic
calls to functions?


Want more information?  See the CrossGCC FAQ, http://www.objsw.com/CrossGCC/
Want to unsubscribe? Send a note to crossgcc-unsubscribe@sourceware.cygnus.com

More information about the crossgcc mailing list