Descripción de los operadores de Pointer-to-Member

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 extra en op-> *pf:

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

I pensar que @fefe tiene probabilidad dijo 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 Pointer to class data. Y para el error, -> * es un operador, no puede poner un espacio entre ellos.

Answer 3

iammilind me apruebo el error; op-> *pf debe cambiarse para que tenga ->* juntos como un solo operador - un pointer to member operator (no se pudo encontrar un enlace mejor). 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 intenta y tiene i+ +.

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

Dentro main:

• n es de tipo M, por lo tanto, con el fin de utilizar pf llamar set_xy de n tendrá que utilizar el operador de .*: (n.*pf)(10, 20);. Eso es equivalente a n.set_xy(10, 20);.

• Desde op es de tipo M* (un puntero a un objeto M), tendrá que utilizar el operador ->* y llamar a la función a la que apunta pf como: (op->*pf)(30, 40);, lo que equivale a op->set_xy(30, 40);

Dentro sum:

• Los ejemplos son simplemente de punteros a las variables miembro/instancia, en contraposición a functi miembro ons. Simplemente está demostrando cómo se sumarían m.x y m.y usando esos tipos de punteros.