What are the Pointer-to-Member ->* and .* Operators in C++?

Question

Yes, I've seen this question and this FAQ, but I still don't understand what ->* and .* mean in C++.
Those pages provide information about the operators (such as overloading), but don't seem to explain well what they are.

What are ->* and .* in C++, and when do you need to use them as compared to -> and .?

Answer 1

I hope this example will clear things for you

//we have a class struct X {    void f() {}    void g() {} };  typedef void (X::*pointer)(); //ok, let's take a pointer and assign f to it. pointer somePointer = &X::f; //now I want to call somePointer. But for that, I need an object X x; //now I call the member function on x like this (x.*somePointer)(); //will call x.f() //now, suppose x is not an object but a pointer to object X* px = new X; //I want to call the memfun pointer on px. I use ->* (px ->* somePointer)(); //will call px->f(); 

Now, you can't use x.somePointer(), or px->somePointer() because there is no such member in class X. For that the special member function pointer call syntax is used... just try a few examples yourself ,you'll get used to it

Answer 2

EDIT: By the way, it gets weird for virtual member functions pointers.

For member variables:

struct Foo {    int a;    int b; };   int main () {     Foo foo;     int (Foo :: * ptr);      ptr = & Foo :: a;     foo .*ptr = 123; // foo.a = 123;      ptr = & Foo :: b;     foo .*ptr = 234; // foo.b = 234; } 

Member functions are almost the same.

struct Foo {    int a ();    int b (); };   int main () {     Foo foo;     int (Foo :: * ptr) ();      ptr = & Foo :: a;     (foo .*ptr) (); // foo.a ();      ptr = & Foo :: b;     (foo .*ptr) (); // foo.b (); }