How can I access class instance(object) pointer in “boost::function”?

Question

CClass inst;
boost::function<bool(int)> func = boost::bind(&CClass::Foo, &inst, _1);

In this situation, I want to access inst's pointer(&inst) or address from "func" like below.

CClass* pInstance = func.obj_ptr; (This is just a form that I want)

How can I do?

Answer 1

You cannot. The whole point of boost/std::function is to erase the type that was stored within it. To implement what you're talking about would require re-constituting the type. And since C++ is a statically-typed language, that means the code that calls such a function would have to explicitly provide the type being returned. Something like func.value<TypeName>() .

Even moreso, what you're talking about wouldn't be possible even if that were available. The only type that function knows about is the type it was given . Which is the return value from boost/std::bind . That type is not widely available without digging into the implementation specifics.

So what you're asking for is not possible. Not without storing it elsewhere yourself.

Answer 2

I guess that such member (argument) should be not public within boost::function class. If I am right, you won't be able to do it. At least without some strange operations.

If you really need something similar and are creator of func objects, the most clean way I can imagine right now is: std::pair<boost::function<bool(int)>, CClass *> funcAndObj , then call funcAndObj.first() and get the pointer from funcAndObj.second .

Answer 3

There is a way, with the use of boost::function::target() template method. But since boost::bind return unspecified type, witch do not yet provide a way to access arguments, you will need to write your own binder functor. Here is some example:

class MyClass
{
    public:
    void myMethod()
    {
        std::cout << "This is my Method" << std::endl; 
    }
};

struct MyFunctor
{
    MyFunctor(MyClass* o, void (MyClass::*m)()): object(o),method(m){}
    MyClass* object;
    void (MyClass::*method)();

    void  operator() ()
    {
        return (object->*method)();
    }
};

So now you can access:

MyClass myObject;
boost::function< void() > func= MyFunctor(&myObject, &MyClass::myMethod);
func();

assert( func.target<MyFunctor>()->object == &myObject );

Same as with the boost::any there is no way to have polymorphic access witch the target template method.