rfg@ics.uci.edu (Ron Guilmette) (12/31/89)
I have a couple of questions regarding explicit and implicit casting of
pointers to member functions.
For reasons that I will not go into here, I would like to write a generalized
function which accepts a pointer to an object and another pointer to a
"member function" of that object. This function should then simply apply
the passed function to the passed object. Simple right?
Well, let's complicate it a bit. Let's say that my `apply' function is
written to accept a pointer to a base class object, and likewise a pointer
to a member function of that same base class. No problem so far.
Now however, if I want to call my `apply' function for an object of
a derived class, I find that there are certain things that my `apply'
function is not allowed to do. Specifically, while I can call my `apply'
function with a pointer to an object of a derived class (and this pointer
will get implicitly casted to a pointer to an object of the base class)
I find that I *cannot* likewise call my `apply' function with a pointer to a
member function of the derived class.
Actually, different C++ language processors do different things in such cases.
As noted below, Cfront 2.0 and G++ 1.36.1 treat such calls differently.
Here is the (short) annotated example:
----------------------------------------------------------------------------
struct base {
void base_member_func (void);
};
typedef base* base_p;
typedef void (base::*base_mfp) (void);
void apply (base_p bp, base_mfp bmfp)
{
(bp->*bmfp) ();
}
struct derived : public base {
void derived_member_func (void);
};
main ()
{
derived* dp = new derived;
apply (dp, base::base_member_func); // OK for both Cfront and G++
apply (dp, derived::base_member_func); // OK for both Cfront and G++
// Cfront: error: bad argument 2 type for apply(): (base_mfp expected)
// G++: warning: contravariance violation for method types ignored
apply (dp, derived::derived_member_func);
// Cfront: error: cast to pointer to member void (base::*)()
// G++: OK
apply (dp, (base_mfp) derived::derived_member_func);
}
----------------------------------------------------------------------------
G++ allows explicit type conversions of `pointer-to-derived-member-func' to
type `pointer-to-base-member-func' without complaint, and it also provides
implicit conversions of this sort (with mystical warnings).
Cfront however, disallows both explicit and implicit conversions of this
type, thus making my `apply' function entirely less useful.
The 2.0 Reference Manual is not very helpful in deciding the legality of
such conversions. With respect to *implicit* conversions it states (4.8) that:
"A pointer to a member of a class may be converted to a pointer to a
member of a class derived from that class provided..."
and further:
"The rule for conversion of pointers to members of (from pointer to member
of base to pointer to member of derived) appears inverted compared to
the rule for pointer to objects... This inversion is necessary to insure
type safety."
This all sounds reasonable and correct. However with respect to *explicit*
conversions, the manual (5.4) states:
"A pointer to member may be explicitly converted to into a different
pointer to member type when the two types are both pointers to members
of the same class or when the two types are pointers to member functions
of classes derived from each other."
That last part of totally mystifying! How can two classes be "derived from
each other"?????? That makes no sense. Obviously, a part of the intent here
was to allow the same type of conversions that you can legally do *implicitly*
to also be legal as *explicit* casts, but what other types of conversions
should also be legal when an explicit cast is used? Who knows?
The bottom line is that (regardless of what the manual *currently* says) I know
what I want to do, and I know that I can do it "safely", however Cfront refuses
to let me do it and G++ (inconsistantly) gripes at me when (some) such
conversions are applied.
I believe that explicit conversions from `pointer-to-derived-member-function'
to `pointer-to-base-member-function' should be legal. Such conversions are
really not all that different from the (legal) case of explicitly casting a
`pointer-to-base-object' to `pointer-to-derived-object' (which *are* allowed).
Such explicit casts can potentially be `type-unsafe' however they need not
always be so. In the tradition of C, users should not be prevented from
doing (potentially) stupid things. Doing so might also unnecessarily prevent
them from doing briliant things!
If explicit conversions of the sort I suggest *are* allowed in future, a
special restriction may need to be applied specifically for virtual
functions (because there are other complications for such cases). In the
case of non-virtual functions however, explicit conversions of this type
can be performed safely and (it seems) they should be allowed.
---------------------------------------
One final question. In the example above, what is the type of the expression
`derived::base_member_func' in the second call to apply?
Both Cfront and G++ seem to think that the type of this parameter is really
`void (base::*)(void)'. I infer this from the fact neither Cfront nor G++
flag any warnings or errors on the second call to apply() in the example
shown above. They do however give an error and a warning (respectively)
when (in the next call to apply) the parameter `derived::derived_member_func'
is supplied.
This seems wrong to me. I believe that the type of `derived::base_member_func'
should be `void (derived::*)(void)' and *not* `void (base::*)(void)'.
I believe that it makes more sense to say that any expression of the general
form `X::Y' (where Y is a member function) is of type:
<return-type> (X::*) (<formal-arg-types>)
regardless of whether or not Y was declared directly within X or was inherited
into X from some base class.
The current 2.0 reference manual gives no clues regarding the `official'
answer to this typing question. Clarification would be appreciated.
// rfg