There appears to be a defect in bound_memfunc_ptr. This occurs when
using boost::bind macro to bind an object with its class member function
for use with the boost::function pointer.
For example, when using boost::bind to bind an object and associated
class member function to a pointer like this:
class A
{
public:
void some_function(int i){};
};
A a1;
boost::function pfa1;
pfa1 = boost::bind(&A::some_function, &a1, _1);
...the bound_memfunc_ptr.memfunc_ptr is populated with the address of
A::some_function. However, the bound_memfunc_ptr.obj_ptr apears to be
uninitialized. (pfa1.functor.bound_memfunc_ptr.obj_ptr has an address of
0xcccccccc in MSVC 2005)
The function pointer works just fine to make calls. Internally the
functor is storing the address of a1. However the address of a1 is not
exposed through the bound_memfunc_ptr interface. I have assumed that
the obj_ptr member which is of type void* is supposed to be the address
of a1.
Since a1's address is not exposed, it is not possible to distinguish
between boost::function pointers that point to a1's member
some_function() and any other object of class A. With this condition
boost::function is unsuitable for use in an observer design pattern
since there is no way to distinguish which boost::function pointer
points to an observer when an observer wants to remove itself
(unsubscribe) from an event.
So, does anybody have any recommendations? Is the obj_ptr member
supposed to be what I think it is, or is it for another purpose? Is
there any other way to get at the address of a bound object, so that the
boost::function pointer can be uniquely identified?
Thanks in advance,
~Ben
