C++
Pointeurs aux membres

Syntaxe

• En supposant une classe nommée Class ...

  • tapez * ptr = & Class :: member; // pointe uniquement sur les membres statiques
  • type Class :: * ptr = & Class :: member; // pointe vers des membres de classe non statiques

• Pour les pointeurs vers des membres de classe non statiques, compte tenu des deux définitions suivantes:

  • Instance de classe;
  • Classe * p = & instance;

• Pointeurs vers les variables membres de classe

  • ptr = & Class :: i; // pointe sur la variable i dans chaque classe
  • instance. * ptr = 1; // L'instance d'accès i
  • p -> * ptr = 1; // Accéder à p's i

• Pointeurs vers les fonctions des membres de la classe

  • ptr = & Class :: F; // pointe sur la fonction 'F' dans chaque classe
  • (instance. * ptr) (5); // Appel de l'instance F
  • (p -> * ptr) (6); // Appelez p's F

Pointeurs vers des fonctions membres statiques

Une fonction membre static est comme une fonction C / C ++ ordinaire, sauf avec la portée:

• Il se trouve dans une class , son nom doit donc être décoré du nom de la classe;
• Il est accessible, public , protected ou private .

Donc, si vous avez accès à la fonction membre static et que vous la décorez correctement, vous pouvez pointer sur la fonction comme toute fonction normale en dehors d'une 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()

Pointeurs vers les fonctions membres

Pour accéder à une fonction membre d'une classe, vous devez avoir un "handle" pour l'instance particulière, soit comme instance elle-même, soit comme un pointeur ou une référence à celle-ci. Étant donné une instance de classe, vous pouvez pointer vers plusieurs de ses membres avec un pointeur vers membre, SI vous obtenez la syntaxe correcte! Bien sûr, le pointeur doit être déclaré comme étant du même type que celui sur lequel vous pointez ...

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()

Contrairement aux pointeurs vers les variables membres (dans l'exemple précédent), l'association entre l'instance de classe et le pointeur membre doit être étroitement liée à des parenthèses, ce qui semble un peu étrange (comme si les éléments .* Et ->* ne sont pas étranges) assez!)

Pointeurs vers les variables membres

Pour accéder à un membre d'une class , vous devez avoir un "handle" pour l'instance particulière, soit comme instance elle-même, soit comme un pointeur ou une référence à celle-ci. Étant donné une instance de class , vous pouvez pointer vers plusieurs de ses membres avec un pointeur vers membre, SI vous obtenez la syntaxe correcte! Bien sûr, le pointeur doit être déclaré comme étant du même type que celui sur lequel vous pointez ...

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 syntaxe du pointeur sur membre nécessite des éléments syntaxiques supplémentaires:

• Pour définir le type du pointeur, vous devez mentionner le type de base, ainsi que le fait qu'il se trouve dans une classe: int Class::*ptr; .
• Si vous avez une classe ou une référence et que vous voulez l' utiliser avec un pointeur à membre, vous devez utiliser le .* Opérateur (semblable au . Opérateur).
• Si vous avez un pointeur sur une classe et que vous souhaitez l'utiliser avec un pointeur sur membre, vous devez utiliser l'opérateur ->* (similaire à l'opérateur -> ).

Pointeurs vers des variables membres statiques

Une variable membre static est juste comme une variable C / C ++ ordinaire, sauf avec la portée:

• Il se trouve dans une class , son nom doit donc être décoré du nom de la classe;
• Il est accessible, public , protected ou private .

Donc, si vous avez accès à la variable membre static et que vous la décorez correctement, vous pouvez pointer vers la variable comme toute variable normale en dehors d'une 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()