C++
Punteros a los miembros

Sintaxis

• Suponiendo una clase llamada Clase ...

  • type * ptr = & Class :: member; // Solo para miembros estáticos
  • tipo Class :: * ptr = & Class :: member; // Apunta a miembros de la clase no estáticos

• Para los punteros a miembros de clase no estáticos, dadas las siguientes dos definiciones:

  • Instancia de clase;
  • Clase * p = & instancia;

• Punteros a las variables miembro de la clase

  • ptr = & Class :: i; // Punto a la variable i dentro de cada clase
  • instancia. * ptr = 1; // Acceso a la instancia de i
  • p -> * ptr = 1; // acceso p's i

• Punteros a funciones de miembro de clase

  • ptr = & Class :: F; // Punto a la función 'F' dentro de cada clase
  • (instancia. * ptr) (5); // Llamar a la instancia de F
  • (p -> * ptr) (6); // Llamar p's F

Punteros a funciones miembro estáticas

Una función miembro static es como una función C / C ++ ordinaria, excepto con alcance:

• Está dentro de una class , por lo que necesita su nombre decorado con el nombre de la clase;
• Tiene accesibilidad, con public , protected o private .

Por lo tanto, si tiene acceso a la función miembro static y la decora correctamente, puede señalar la función como cualquier función normal fuera de una class :

typedef int Fn(int); // Fn is a type-of function that accepts an int and returns an int

// Note that MyFn() is of type 'Fn'
int MyFn(int i) { return 2*i; }

class Class {
public:
    // Note that Static() is of type 'Fn'
    static int Static(int i) { return 3*i; }
}; // Class

int main() {
    Fn *fn;    // fn is a pointer to a type-of Fn

    fn = &MyFn;          // Point to one function
    fn(3);               // Call it
    fn = &Class::Static; // Point to the other function
    fn(4);               // Call it
 } // main()

Punteros a funciones miembro

Para acceder a una función miembro de una clase, debe tener un "identificador" para la instancia en particular, ya sea como la instancia en sí, o un puntero o una referencia a ella. Dada una instancia de clase, puedes apuntar a varios de sus miembros con un puntero a miembro, ¡SI obtienes la sintaxis correcta! Por supuesto, el puntero debe ser declarado del mismo tipo que lo que está apuntando a ...

typedef int Fn(int); // Fn is a type-of function that accepts an int and returns an int

class Class {
public:
    // Note that A() is of type 'Fn'
    int A(int a) { return 2*a; }
    // Note that B() is of type 'Fn'
    int B(int b) { return 3*b; }
}; // Class

int main() {
    Class c;          // Need a Class instance to play with
    Class *p = &c;    // Need a Class pointer to play with

    Fn Class::*fn;    // fn is a pointer to a type-of Fn within Class

    fn = &Class::A;   // fn now points to A within any Class
    (c.*fn)(5);       // Pass 5 to c's function A (via fn)
    fn = &Class::B;   // fn now points to B within any Class
    (p->*fn)(6);      // Pass 6 to c's (via p) function B (via fn)
} // main()

A diferencia de los punteros a las variables miembro (en el ejemplo anterior), la asociación entre la instancia de la clase y el puntero del miembro debe vincularse estrechamente entre paréntesis, lo que parece un poco extraño (como si .* Y ->* no fueran extraños ¡suficiente!)

Punteros a variables miembro

Para acceder a un miembro de una class , debe tener un "identificador" para la instancia en particular, ya sea como la instancia en sí, o como un puntero o una referencia a ella. Dada una instancia de class , puedes apuntar a varios de sus miembros con un puntero a miembro, ¡SI obtienes la sintaxis correcta! Por supuesto, el puntero debe ser declarado del mismo tipo que lo que está apuntando a ...

class Class {
public:
    int x, y, z;
    char m, n, o;
}; // Class

int x;  // Global variable

int main() {
    Class c;        // Need a Class instance to play with
    Class *p = &c;  // Need a Class pointer to play with

    int *p_i;       // Pointer to an int

    p_i = &x;       // Now pointing to x
    p_i = &c.x;     // Now pointing to c's x

    int Class::*p_C_i; // Pointer to an int within Class

    p_C_i = &Class::x; // Point to x within any Class
    int i = c.*p_C_i;  // Use p_c_i to fetch x from c's instance
    p_C_i = &Class::y; // Point to y within any Class
    i = c.*p_C_i;      // Use p_c_i to fetch y from c's instance

    p_C_i = &Class::m; // ERROR! m is a char, not an int!

    char Class::*p_C_c = &Class::m; // That's better...
} // main()

La sintaxis de puntero a miembro requiere algunos elementos sintácticos adicionales:

• Para definir el tipo de puntero, debe mencionar el tipo base, así como el hecho de que está dentro de una clase: int Class::*ptr; .
• Si usted tiene una clase o de referencia y desea utilizarlo con un puntero a miembro-, es necesario utilizar el .* Operador (afín al . Operador).
• Si tiene un puntero a una clase y desea usarlo con un puntero a miembro, debe usar el operador ->* (similar al operador -> ).

Punteros a variables miembro estáticas

Una variable miembro static es como una variable C / C ++ ordinaria, excepto con alcance:

• Está dentro de una class , por lo que necesita su nombre decorado con el nombre de la clase;
• Tiene accesibilidad, con public , protected o private .

Por lo tanto, si tiene acceso a la variable miembro static y la decora correctamente, entonces puede señalar la variable como cualquier variable normal fuera de una class :

class Class {
public:
    static int i;
}; // Class

int Class::i = 1; // Define the value of i (and where it's stored!)

int j = 2;   // Just another global variable

int main() {
    int k = 3; // Local variable

    int *p;

    p = &k;   // Point to k
    *p = 2;   // Modify it
    p = &j;   // Point to j
    *p = 3;   // Modify it
    p = &Class::i; // Point to Class::i
    *p = 4;   // Modify it
} // main()