The return type of operator ->*

When one calls a member function one has to contract information about the
instance of the class and the member fn one wishes to use. This can take
time to do if the instance is identified by a pointer to the base class and
the function is virtual. If one is in a tight loop and the member and
instance do not change within the loop it seems to make sense to evaluate
((pobject)->*(mfn)) once outside the loop and then use the result inside the
loop.

Unfortunately the following precursor (it uses no polymorphism) code already
crashes VS2008 and g++!

This seems a shame, as it seems to point to a correct C++ style solution for
the very real problem of inefficiency of large tight loops with
polymorphism. I have heard of people doing really nasty hacks to overcome
this difficulty in practise (accessing the vtable directly etc).

More generally, is there an understanding of the correct return types and
signature family for the binary operator operator ->* one should compare
with when one overloads this operator?

int f ( int arg) {return ++arg;}

struct B
{
int f ( int arg){return ++arg;}
typedef int (B::*mfn_t)( int );
};

template <typename T>
void loop(T fn, int arg)
{
for (int i = 0; i < 8; ++i)
arg = fn(arg);
};

int main(int argc, char* argv[])
{
loop(::f,3);
B::mfn_t mfn(&B::f);
B* pobject = new B;
int ans = ((pobject)->*(mfn)) (4);
loop(((pobject)->*(mfn)),3);
delete pobject;
return 0;
}

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