Re: [Boost-users] boost::bind for returning a reference?

3 Aug 2006

      Peter Dimov wrote:
...
Paul wrote:
...
I understand why boost::bind() must return a const-reference or a
value, but what I don't understand is, why must I do
boost::bind(...) if I want it to return by reference?
Why must I (the user) deduce the return type myself?
Can you expand your ... a bit in order to help me understand your question 
better?
I'll try and explain without getting too long-winded...

struct AClass
{
    typedef int var_type;
    int var;
};

I want a function that returns a reference to the int, so i can assign stuff to 
it...
bind(&AClass::var,_1) = whatever;

I have a function that returns a reference to a member:

int & get_ref( AClass & a ) { return a.ivar; }

now i want to bind to it:
bind(get_ref,_1) = whatever;

I have a functor that returns a reference to some member

template <class TheClass>
struct GetRef
{
    typename TheClass::var_type & operator()( TheClass & c ) const { return 
c.ivar; }
};

now to bind it to AClass's ivar...

bind( GetRef<AClass>(), _1 ) = whatever;

but if i had a 'BClass' that had a double instead...

struct BClass
{
    typedef double var_type;
    double var;
};

bind( GetRef<BClass>(), _1 ) = whatever;

and if i wanted to do it generically, now i need to do a lot more work...

template <class TheClass>
void doit( TheClass & c )
{
    bind< typename TheClass::var_type & >(&TheClass::var, _1) = whatever;
}

and so on.  this can get a lot more complicated.

my question is, bind() already knows what the type is.  The problem is that it 
always returns a const& or by value.    Can't we have a way of forcing it to 
return a mutable reference when necessary?

I'd like to be able to just do:

template <class TheClass>
void doit( TheClass & c )
{
    bind_ref(&TheClass::var, _1) = whatever;
}

and not have to worry about figuring out the return type myself.

cheers
Paul