¿Qué es -> * operador en C++?

Question

C++ sigue sorprendiéndome. Hoy me enteré del operador -> *. Es sobrecargable pero no tengo idea de cómo invocarlo. Logré sobrecargarlo en mi clase, pero no tengo ni idea de cómo llamarlo.

struct B { int a; }; 

struct A 
{ 
    typedef int (A::*a_func)(void); 
    B *p; 
    int a,b,c; 
    A() { a=0; } 
    A(int bb) { b=b; c=b; } 
    int operator + (int a) { return 2; } 
    int operator ->* (a_func a) { return 99; } 
    int operator ->* (int a) { return 94; } 
    int operator * (int a) { return 2; } 
    B* operator ->() { return p; } 


    int ff() { return 4; } 
}; 


void main() 
{ 
    A a; 
    A*p = &a; 
    a + 2; 
} 

edición:

Gracias a la respuesta. Para llamar a la función sobrecargada escribo

void main() 
{ 
    A a; 
    A*p = &a; 
    a + 2; 
    a->a; 
    A::a_func f = &A::ff; 
    (&a->*f)(); 
    (a->*f); //this 
} 

Answer 1

El sobrecargado ->* operador es un operador binario (mientras .* no es sobrecargable). Se interpreta como un operador binario ordinario, por lo que en que el caso original con el fin de llamar a ese operador que tiene que hacer algo como

A a; 
B* p = a->*2; // calls A::operator->*(int) 

Lo que se lee en la respuesta de la Piotr aplica al incorporada operadores, no a tu sobrecargado. Lo que usted llama en su ejemplo agregado también es el operador incorporado, no su operador sobrecargado. Para llamar al operador sobrecargado, debes hacer lo que hago en mi ejemplo anterior.

Answer 2

Al igual que .*, ->* se utiliza con punteros a los miembros. Hay una sección completa on C++ FAQ LITE dedicada a punteros a miembros.

#include <iostream> 

struct foo { 
    void bar(void) { std::cout << "foo::bar" << std::endl; } 
    void baz(void) { std::cout << "foo::baz" << std::endl; } 
}; 

int main(void) { 
    foo *obj = new foo; 
    void (foo::*ptr)(void); 

    ptr = &foo::bar; 
    (obj->*ptr)(); 
    ptr = &foo::baz; 
    (obj->*ptr)(); 
    return 0; 
} 

Answer 3

Al igual que cualquier otra opperator, también puede llamar explícitamente:

a.operator->*(2);