c++ - Comprender los operadores Pointer-to-Member

pointers compiler-errors

Question

Copié este programa de un libro de práctica de C ++. ¿Qué está pasando detrás de escena?

El resultado esperado es:

suma = 30 suma = 70

#include<iostream>
using namespace std;

class M
{
    int x;
    int y;
public:
    void set_xy(int a, int b)
    {
        x=a;
        y=b;
    }
    friend int sum(M m);
};

int sum (M m);
//so far so good, problem begins from here. what''s happening after here?
{                               
    int M ::*px = &M ::x;
    int M ::*py = &M ::y;
    M *pm =&m;
    int s= m.*px+ pm->*py;
    return s;
}

int main()
{
    M n;
    void (M :: *pf)(int, int) = &M ::set_xy;
    (n.*pf)(10, 20);
    cout <<"sum=" << sum(n) << endl;

    M *op= &n;
    (op-> *pf)(30,40);
    cout << "sum=" << sum(n)<< endl;

    cin.ignore();
    getchar();
    return 0;
}

Answer 1

El problema se debe a espacios en blanco adicionales en op-> *pf :

 (op->*pf)(30,40);  // ok

Creo que @fefe probablemente haya dicho la razón en el comentario. ->* es un operador único, similar a .* . Entonces, si esos 2 están separados, entonces dará como resultado una sintaxis diferente, lo que da un error de compilación.

Answer 2

Eche un vistazo a Puntero a datos de clase . Y para el error, -> * es un operador, no puede poner un espacio entre ellos.

Answer 3

iammilind me apuntó al error; op-> *pf debe cambiarse para que tenga ->* juntos como un solo operador - un puntero al operador miembro (no pudo encontrar un mejor enlace). El espacio en blanco en op ->* pf es perfectamente válido.

Eso es lo mismo para algo como i++ ; ++ es un operador único y causará un error si intentas tener i+ + .

Ahora por lo que está haciendo. El ejemplo es un puntero a una función miembro . pf se declara como una función miembro de la class M , que toma dos argumentos int con un tipo de retorno void . Se está inicializando para apuntar a la función M::set_xy .

Interior main :

• n es de tipo M , por lo tanto, para usar pf para llamar a set_xy de n , usaría el operador .* : (n.*pf)(10, 20); . Eso es equivalente a n.set_xy(10, 20); .

• Como op es de tipo M* (un puntero a un objeto M ), necesitará usar el operador ->* y llamar a la función señalada por pf como: (op->*pf)(30, 40); , que es equivalente a op->set_xy(30, 40);

sum interna:

• Los ejemplos son simplemente punteros a variables miembro / instancia, a diferencia de las funciones miembro. Simplemente está demostrando cómo se sumarían mx y my uso de esos tipos de punteros.