4 questions about ->* overload

[walkinginwater]

I have 4 question about the operator ->* overloading:
first:The operator–>* is a binary operator
but when we define the implementation of it we just take one argument, i don't know why , can somebody give me an explanation?
Second:From the following example, i have no idea about the usefulness of ->*overloading,it is too troublesome to create the FunctionObject class. Can we just forbidden the overloading of it??
third:why the statement "w->pmf*" can work?
the output of this is : operator->*
FunctionObject constructor
Fourth:why we cannot use the statement: w->*pmf(12);

#include <iostream>
using namespace std;

class Dog 
{
public:
  int run(int i) const 
  { cout << "run\n";  
    return i; 
  }
    typedef int (Dog::*PMF)(int) const;//define the pointer to the member function
  
  class FunctionObject // operator->* must return an object that has an operator(),
  {                    //so we should first create a class to store the information
  private:             // that we need to implement the () function
    Dog* ptr;    PMF pmem;
  public:
    FunctionObject(Dog* wp, PMF pmf) : ptr(wp), pmem(pmf)
	{       cout << "FunctionObject constructor\n";    }
    
	int operator()(int i) const 
	{ cout << "FunctionObject::operator()\n";
      return (ptr->*pmem)(i); // Make the call
    }
  };
//the definition of the operator->* overloading
  FunctionObject operator->*(PMF pmf) 
  { cout << "operator->*" << endl;
    return FunctionObject(this, pmf);
  }
};
 
int main()
{ Dog w;
  Dog::PMF pmf = &Dog::run;
  cout << (w->*pmf)(1) << endl; 
  w->pmf*;//why this can work
  //w->pmf*(12) //error C2064: term does not evaluate to a function taking 1 arguments
} ///:~

[MrViggy]

What does 'operator->*' do? I'm not familiar with this operator (as a single operator, and not 'operator->' and 'operator *').

Viggy

[Marc G]

What does 'operator->*' do? I'm not familiar with this operator (as a single operator, and not 'operator->' and 'operator *').

It's the most obscure operator of C++, and almost never used.
It's a pointer to member operator. See http://msdn.microsoft.com/library/de...perator_29.asp

[MrViggy]

Wow, that's annoying!



So, in their (MSDN) example:

(pObject->*pMemberFunc) (6);

Is this the same as:

(*(pObject->pMemberFunc))(6);

Viggy

[Marc G]

No, ->* or .* is 1 operator for pointer to a member function of a class. But I don't know the details myself.
Apparently MS even removed some example that is present in my offline MSDN. I'll post it below:

// expre_Expressions_with_Pointer_Member_Operators.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;

class Testpm {
public:
   void m_func1() { cout << "m_func1\n"; }
   int m_num;
};

// Define derived types pmfn and pmd.
// These types are pointers to members m_func1() and
// m_num, respectively.
void (Testpm::*pmfn)() = &Testpm::m_func1;
int Testpm::*pmd = &Testpm::m_num;

int main() {
   Testpm ATestpm;
   Testpm *pTestpm = new Testpm;

// Access the member function
   (ATestpm.*pmfn)();
   (pTestpm->*pmfn)();   // Parentheses required since * binds
                        // less tightly than the function call.

// Access the member data
   ATestpm.*pmd = 1;
   pTestpm->*pmd = 2;

   cout  << ATestpm.*pmd << endl
         << pTestpm->*pmd << endl;
}

Output of the above code:
m_func1
m_func1
1
2

In the preceding example, a pointer to a member, pmfn, is used to invoke the member function m_func1. Another pointer to a member, pmd, is used to access the m_num member.


Another example:

// expre_Expressions_with_Pointer_Member_Operators2.cpp
// C2440 expected
class BaseClass
{
public:
BaseClass(); // Base class constructor.
void Func1();
};

// Declare a pointer to member function Func1.
void (BaseClass::*pmfnFunc1)() = &BaseClass::Func1;

class Derived : public BaseClass
{
public:
Derived();  // Derived class constructor.
void Func2();
};

// Declare a pointer to member function Func2.
void (Derived::*pmfnFunc2)() = &Derived::Func2;

int main()
{
BaseClass ABase;
Derived ADerived;

(ABase.*pmfnFunc1)();   // OK: defined for BaseClass.
(ABase.*pmfnFunc2)();   // Error: cannot use base class to
                        // access pointers to members of
                        // derived classes. 
(ADerived.*pmfnFunc1)();   // OK: Derived is unambiguously
                           // derived from BaseClass. 
(ADerived.*pmfnFunc2)();   // OK: defined for Derived.
}

The result of the .* or –>* pointer-to-member operators is an object or function of the type specified in the declaration of the pointer to member. So, in the preceding example, the result of the expression ADerived.*pmfnFunc1() is a pointer to a function that returns void. This result is an l-value if the second operand is an l-value.

[MrViggy]

Thanks. Still seems rather confusing to me.



Viggy

[Marc G]

Thanks. Still seems rather confusing to me.



Viggy

Yes, I wouldn't advise to use them
If you need pointer to member functions, just use something like boost::bind, which is much better in my opinion.