Re: Application's pointer problem
BigDavid wrote:
Hi guys !
I try to work with application's pointers in c++ , and .. I have some
problems !
I have base class that contain definition of pointer to application.
This application's pointer assigned as argument to another application
that exist in this class.
The definition of the base class look like this:
class Base{
//DB
protected:
typedef int (CTMonitorBase::*pFoo) ();
//api
protected:
void Run(pFoo _apFoo);
};
This base class derived to another class. This class contain
application which suitable to the definition of the application's
pointers.
The definition of the class look like this:
class Inheritor : public Base{
int y1;
int z1;
public:
bool UserFunc(); //another new application.
int zoo(); //suitable to the definition of pFoo
pointer.
};
When i try to invoke from UserFunc application to Run application with
the pointer of zoo application
bool Inheritor::UserFunc()
{
Run(zoo);
}
I got the following error:
error C2664: 'void __thiscall Base::Run(int (__thiscall Base::*)(void)'
: cannot convert parameter 1 from
'int (void)' to 'int (__thiscall Base::*)(void)'
None of the functions with this name in scope match the target
type
There are two errors with this program. The first error is that the
program is not using the correct syntax to obtain zoo's member function
pointer. To obtain a member function pointer, the program must supply
the class name and apply the address of operator (&):
Run( &Inheritor::zoo );
The second error is that although Run() is now passed zoo's member
function pointer correctly - the Inheritor member pointer cannot be
used as a Base member pointer - even though Inheritor derives from
Base. Member function pointers, as it turns out, are "contravariant" -
meaning that instead of a derived type being able to fill in for a base
type, it's the base type that is able to fill in for the derived type.
So while an Inheritor member pointer cannot be used as a Base member
pointer, a Base member pointer can be used as an Inheritor member
pointer - meaning that one solution would be to declare pFoo an
Inheritor member function pointer. Alternately, zoo() could be declared
a virtual function in Base and Run could be passed &Base::zoo as its
parameter.
None of these solutions are particularly attractive. Generally, there
is little reason for a C++ program to use member function pointers as
method parameters. It is almost always clearer and easier for a program
just to declare virtual methods in a class interface and then pass
pointers or references to instances of the class as parameters. For
example, instead of accepting an Inheritor member function pointer -
Run() could accept a Base pointer (or reference). And because Base
would declare a virtual (and possibly abstract) zoo() method, Run() can
call its parameter's zoo() method and be sure that the call is
dispatched appropriately based on the dynamic type of its parameter.
Greg
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]