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<void, int> 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