Qu'est-ce que -> * opérateur en C ++?

Question

C ++ continue à me surprendre. Aujourd'hui, j'ai découvert le -> * opérateur. Il est surchargeable, mais je ne sais pas comment l'invoquer. Je réussi à le surcharger dans ma classe mais je n'ai pas la moindre idée comment l'appeler.

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;
}

edit:

Merci à la réponse. Pour appeler la fonction surchargée i écris

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

Answer 1

L'opérateur ->* surchargé est un opérateur binaire (alors que .* est pas surchargeable). Il est interprété comme un opérateur binaire ordinaire, donc en vous cas d'origine afin d'appeler cet opérateur, vous devez faire quelque chose comme

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

Qu'est-ce que vous lisez dans la réponse du Piotr applique à la intégré opérateurs, pas à votre une surcharge. Ce que vous appelez dans votre exemple supplémentaire est également le intégré opérateur, pas votre surcharge un. Pour appeler l'opérateur surchargé vous devez faire ce que je fais dans mon exemple ci-dessus.

Answer 2

Tout comme .*, ->* est utilisé avec des pointeurs vers des membres. Il y a sur C ++ FAQ LITE toute une section dédié aux pointeurs -à-membres.

#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

Comme tout autre opperator, vous pouvez également appeler explicitement:

a.operator->*(2);