C++Talk.NET

jeffz_2002@yahoo.com · Guest

/*
Hello,

To implement a C++ simulation I was working on, I started looking at
Vladimir Batov's code from CUJ, Feb 2001 ("Callbacks Made Easy with the
Observer-Mediator Design Patterns"). Most of the code is
straightforward, but I can't follow the central mechanism behind his
design that lets it work. I've boiled the problem down to the code
below -- specifically the function doSomethingVoidPtr, where casting a
function pointer's signature to a different signature lets the code
bypass the compiler's type checking of function arguments. The console
output follows the code.

As shown in line A, the function pointer doSomething gets cast to a
different signature. In line B, this function pointer is then called
with an address to an A, which has previously been cast to a void *.
Somehow, though I'm not sure how, the program manages to take this
address-of-an-A-as-ptr-to-void and convert it to a const A& argument,
as required by doSomething. Question: How and why does it do this? I
assumed that C++'s compiler would balk at this, but it compiled.

Some extra notes:
- I had to cast the whole function's signature to an f_t, I couldn't
just call doSomething with a void *.
- when I call this function pointer with a void * which contains an
address to a B (line C), the program gives garbage. It seems the code
is casting the void* to A's bit pattern (terminology?), and so trying
to get x_ from the non-A object gives crap (or will
crash program).

Thanks,

Jeff

P.S.: For the curious, the point in question in Batov's code is in the
method Parcel::call, where the function pointer member_callback_ is
given an event and a pointer-to-void sender. member_callback_ is then
cast to a different signature [typedef void (Callee::*MemberCallback)
(const Event&, void*)], when the Parcel object is created ... see the
macro #FAMILY in signals.h. Unfortunately, the article doesn't really
go into the casting of the of function pointer to different types,
which is unfortunate, since it's the trick that allows his pattern to
work.

*/

#include <iostream>
using namespace std;

struct A {
A(int x) : x_(x) {};
int x_;
};

struct B {};

void doSomething(const A& a) {
cout << "doSomething: " << a.x_ << endl;
}

void doSomethingVoidPtr(void* a) {
typedef void (*f_t)(void *);

// line A - casting doSomething to different signature.
f_t myFun = (f_t)doSomething;

// line B - calling the function, passing in a void* arg.
(*myFun)(a);
}

int main() {
A a(42);
cout << "Calling with an A: ";
doSomething(a);

void* p = &a;
// doSomething(p); // doesn't compile.
cout << "Calling with a void* pointing at an A: ";
doSomethingVoidPtr(p);

B b;
void* vb = &b;
cout << "Calling with a void* pointing at a B: ";
doSomethingVoidPtr(vb); // line C

return 0;
}

/* Output:
Calling with an A: doSomething: 42
Calling with a void* pointing at an A: doSomething: 42
Calling with a void* pointing at a B: doSomething: 586179681
*/

/* FYI:
$ g++ --version
g++ (GCC) 3.3.1 (cygming special)

Thanks! Jeff
*/

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

jeffz_2002@yahoo.com · Guest

// Hi folks, I just realized I could simplify the code for my question:

#include <iostream>
using namespace std;

struct A {
A(int x) : x_(x) {};
int x_;
};

struct B {};

void doSomething(const A& a) { cout << "doSomething: " << a.x_ << endl;
}

int main() {
A a(42);
B b;

typedef void (*void_func_void_ptr_arg)(void *);

void_func_void_ptr_arg f = (void_func_void_ptr_arg)doSomething; //
line A

void* vpa = &a;
(*f)(vpa); // line B ... prints "doSomething: 42"

void* vpb = &b;
(*f)(vpb); // line C ... prints "doSomething: 1089" (garbage)

return 0;
}

// Thanks, Jeff

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Jack Klein · Guest

On 27 Jun 2005 06:43:16 -0400, [email]jeffz_2002 (AT) yahoo (DOT) com[/email] wrote in
comp.lang.c++.moderated: