Re: Pointers to Members question

From:

"Victor Bazarov" <v.Abazarov@comAcast.net>

Newsgroups:

comp.lang.c++

Date:

Mon, 24 Sep 2007 09:59:09 -0400

Message-ID:

<fd8frd$34p$1@news.datemas.de>

James Kanze wrote:

On Sep 21, 10:36 pm, "Victor Bazarov" <v.Abaza...@comAcast.net> wrote:

Ben Thomas wrote:

Is this code okay and compliant with the standard. As far as I
understand it is correct but I just want to make sure.

#include <iostream>
using namespace std;

class Base {
public:
  typedef void (Base::*PMethod)(void);
  void Invoke (PMethod p) {(this->*p)();}
};

class Derived : public Base {
public:
  void Method (void) {cout << "Hello World" << endl;}
};

int main (void) {
  Derived x;
  // *** Is the static_cast correct here ? Or could this leads
  // to undefined behavior on some platform / compiler ?
  x.Invoke(static_cast<Base::PMethod>(&Derived::Method));
  return 0;
}

Generally speaking, a member of derived is NOT a member of base,
and that's why the conversion does not exist, and you have to resort
to some tricks (like casts) to silence the compiler that complains
otherwise. The static cast (as I understand it) would be called for
if you have a pointer to member of 'Base' ('Base::*ptr'), somehow
it was converted to a pointer to a member of 'Derived' ('Derived::*')
and then your base wants to call it. Then, since _originally_ the
pointer *was* to a member of 'Base', you're ok to use 'static_cast'.
If the pointer *never was* to a member of 'Base', casting is *not*
the right thing to do. You're correct suspecting that the behaviour
is undefined.

I think you've got it backwards. Pointer to member casts work
the opposite of normal pointer casts. There is an implicit D::*
to B::* conversion (no cast needed).

Nope. *You* got it backwards. Every member of 'B' is a member of
'D' as well (by inheritance), so 'B::*' ==> 'D::*' requires no special
syntax, its implicit (modulo all the "available" and "unambiguous"
cruft). [conv.mem]/2.

For the pointers to *objects*, however, it's reverse: Every 'D' is
a 'B' (modulo "available" and "unambiguous"), so conversion from 'D*'
to 'B*' is implicit.

A static_cast is needed
for D::* to B::*, however, and the using it is only legal if the
B it is used with is actually a D. Which is the case above. So
while the above may be as ugly as sin, it is perfectly legal
(and was used for callbacks in one GUI library---XViews, I
think---that was widely used in the past).

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask