C++
Puntatori ai membri

Sintassi

• Supponendo una classe chiamata Class ...

  • scrivi * ptr = & Class :: member; // Indica solo membri statici
  • digitare Class :: * ptr = & Class :: member; // Indica i membri della classe non statici

• Per i puntatori ai membri della classe non statici, date le seguenti due definizioni:

  • Istanza di classe;
  • Classe * p = & istanza;

• Puntatori alle variabili dei membri della classe

  • ptr = & Class :: i; // Punta alla variabile i all'interno di ogni classe
  • istanza. * ptr = 1; // Accedi all'istanza i
  • p -> * ptr = 1; // Accedi a p i

• Puntatori alle funzioni dei membri della classe

  • ptr = & Class :: F; // Punta a funzionare 'F' in ogni classe
  • (. Esempio * ptr) (5); // Chiama l'istanza F
  • (P -> * PTR) (6); // Chiama p F

Puntatori a funzioni membro statiche

Una funzione membro static è proprio come una normale funzione C / C ++, tranne con scope:

• È all'interno di una class , quindi ha bisogno del suo nome decorato con il nome della classe;
• Ha accessibilità, con public , protected o private .

Quindi, se hai accesso alla funzione membro static e la decori correttamente, puoi indicare la funzione come qualsiasi normale funzione al di fuori di 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()

Puntatori alle funzioni membro

Per accedere a una funzione membro di una classe, è necessario disporre di un "handle" per l'istanza particolare, come l'istanza stessa o un puntatore o un riferimento ad essa. Data un'istanza di classe, puoi puntare a vari dei suoi membri con un puntatore-membro, SE si ottiene la sintassi corretta! Ovviamente, il puntatore deve essere dichiarato dello stesso tipo di quello a cui si sta puntando ...

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 differenza dei puntatori alle variabili membro (nell'esempio precedente), l'associazione tra l'istanza di classe e il puntatore membro deve essere strettamente associata a parentesi, che sembra un po 'strana (come se il .* E ->* non siano strani abbastanza!)

Puntatori alle variabili membro

Per accedere a un membro di una class , è necessario disporre di un "handle" per l'istanza particolare, come l'istanza stessa o un puntatore o un riferimento ad esso. Data un'istanza di class , puoi puntare a vari dei suoi membri con un puntatore-membro, SE si ottiene la sintassi corretta! Ovviamente, il puntatore deve essere dichiarato dello stesso tipo di quello a cui si sta puntando ...

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 sintassi del puntatore-membro richiede alcuni elementi sintattici aggiuntivi:

• Per definire il tipo di puntatore, è necessario menzionare il tipo di base, oltre al fatto che si trova all'interno di una classe: int Class::*ptr; .
• Se si dispone di una classe o di riferimento e si desidera utilizzare con un membro puntatore-a-, è necessario utilizzare il .* Operatore (simile al . Operatore).
• Se si ha un puntatore a una classe e si desidera utilizzarlo con un puntatore a membro, è necessario utilizzare l'operatore ->* (simile all'operatore -> ).

Puntatori a variabili membro statiche

Una variabile membro static è proprio come una normale variabile C / C ++, tranne con scope:

• È all'interno di una class , quindi ha bisogno del suo nome decorato con il nome della classe;
• Ha accessibilità, con public , protected o private .

Quindi, se hai accesso alla variabile membro static e la decori correttamente, puoi puntare alla variabile come qualsiasi variabile normale al di fuori di 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()