On Sep 25, 7:13 am, WaterWalk <toolmas...@163.comwrote:
Hello. I thought I understood member function pointers, but in fact I
don't. Consider the following example:
class Base
{
public:
virtual ~Base() {}
};
class Derived : public Base
{
public:
void test()
{
printf("Derived::test()\n");
}
};
typedef void (Derived::*funcD) ();
typedef void (Base::*funcB) ();
int main()
{
funcD fd = &Derived::test;
funcB fb = static_cast<funcB>(fd);
Derived d;
Base *pb = &d;
(pb->*fb)(); // will print "Derived::test()" !
return 0;
}
To my surprise, this code works!
It's guaranteed by the standard. At least one major GUI
framework used something like this for its callbacks. (But it
surprised me as well when I first encountered it, and I had to
verify in the standard that it was well defined.)
However, if the Base class doesn't have any virtual functions,
the above code won't compile, or cause runtime error.
It should work, regardless. At least one major compiler (VC++),
however, uses a broken implementation of pointers to member functions
by
default; if you're using VC++, you probably need the /vmg option.
At the same time, in section 15.5.1 of BS's "The C++
Programming Language", it states that a pointer to base class
member can be assigned to a pointer to derived class member,
but not vice versa.
There's an implicit conversion of Derived::* to Base::*. You
need a static_cast to go the other direction, and when using the
resulting Base::*, it's undefined behavior unless the Base
object is actually a Derived.
I'm lost. Please help me figure out how it works.
How it works is the implementors problem. Normally, a pointer
to member function will be a struct with quite a bit of
information: whether the function is virtual or not, the actual
address of the function, if it's not, or its index in the
vtable, if it is, any offset or correction needed for the this
pointer, etc. And calling through a pointer to member involves
evaluating all this information. Alterantively, an
implementation may use a "trampoline"; when you take the address
of a pointer to member, it creates a small function which does
whatever is necessary to call the function, given the address of
the object. And conversions like the above involve modifying
the information or generating a new trampoline.
And show me where in the c++ standard allows this kind of
usage.
§5.2.9/10:
An rvalue of type "pointer to member of D of type cv1 T"
can be converted to an rvalue of type "pointer to member
of B" of type cv2 T, where B is a base class (clause 10)
of D, if a valid standard conversion from "pointer to
member of B of type T" to "pointer to member of D of
type T" exists (4.11), and cv2 is the same
cv-qualification as, or greater cv-qualification than,
cv1.69) The null member pointer value (4.11) is
converted to the null member pointer value of the
destination type. If class B contains the original
member, or is a base or derived class of the class
containing the original member, the resulting pointer to
member points to the original member. Otherwise, the
result of the cast is undefined. [ Note: although class
B need not contain the original member, the dynamic type
of the object on which the pointer to member is
dereferenced must contain the original member; see 5.5.
--end note ]
--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34