C++
Wskaźniki do członków

Składnia

• Zakładając klasę o nazwie Klasa ...

  • wpisz * ptr = & Class :: member; // Wskaż tylko elementy statyczne
  • wpisz Class :: * ptr = & Class :: member; // Wskaż niestatyczne elementy klasy

• Dla wskaźników do niestatycznych członków klasy, biorąc pod uwagę następujące dwie definicje:

  • Instancja klasy;
  • Klasa * p = & instance;

• Wskaźniki do zmiennych składowych klasy

  • ptr = & Class :: i; // Wskaż zmienną i w każdej klasie
  • instancja. * ptr = 1; // Dostęp do instancji i
  • p -> * ptr = 1; // Access p's i

• Wskaźniki do funkcji składowych klasy

  • ptr = & Class :: F; // Wskaż funkcję „F” w każdej klasie
  • (instancja. * ptr) (5); // Wywołanie instancji F.
  • (p -> * ptr) (6); // Zadzwoń do P.

Wskaźniki do statycznych funkcji składowych

static funkcja składowa jest jak zwykła funkcja C / C ++, z wyjątkiem tego, że obejmuje:

• Jest w class , więc jej nazwa musi być ozdobiona nazwą klasy;
• Ma dostępność, public , protected lub private .

Tak więc, jeśli masz dostęp do funkcji członka static i odpowiednio ją dekorujesz, możesz wskazać tę funkcję jak każdą normalną funkcję poza 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()

Wskaźniki do funkcji składowych

Aby uzyskać dostęp do funkcji składowej klasy, musisz mieć „uchwyt” do konkretnej instancji, jako samej instancji lub wskaźnik lub odwołanie do niej. Biorąc pod uwagę instancję klasy, możesz wskazać różne jej elementy za pomocą wskaźnika do elementu, JEŻELI poprawna składnia jest! Oczywiście wskaźnik musi zostać zadeklarowany jako tego samego typu, co wskazujesz ...

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

W przeciwieństwie do wskaźników do zmiennych składowych (w poprzednim przykładzie), powiązanie między instancją klasy a wskaźnikiem składowym musi być ściśle powiązane z nawiasami, co wygląda trochę dziwnie (jakby .* I ->* nie były dziwne dość!)

Wskaźniki do zmiennych składowych

Aby uzyskać dostęp do członka class , musisz mieć „uchwyt” do konkretnej instancji, jako samej instancji lub wskaźnik lub odwołanie do niej. Biorąc pod uwagę instancję class , możesz wskazać różne jej elementy za pomocą wskaźnika do elementu, JEŻELI poprawna składnia jest! Oczywiście wskaźnik musi zostać zadeklarowany jako tego samego typu, co wskazujesz ...

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

Składnia wskaźnika do elementu wymaga dodatkowych elementów składniowych:

• Aby zdefiniować typ wskaźnika, należy wspomnieć o typie podstawowym, a także o tym, że należy on do klasy: int Class::*ptr; .
• Jeśli masz klasę lub odniesienie i chcesz go używać z członkiem pointer-to-trzeba użyć .* Operator (zbliżony do . Operatora).
• Jeśli masz wskaźnik do klasy i chcesz go używać ze wskaźnikiem do elementu, musisz użyć operatora ->* (podobnie jak operator -> ).

Wskaźniki do statycznych zmiennych składowych

static zmienna składowa jest jak zwykła zmienna C / C ++, z wyjątkiem tego, że ma zakres:

• Jest w class , więc jej nazwa musi być ozdobiona nazwą klasy;
• Ma dostępność, public , protected lub private .

Jeśli więc masz dostęp do static zmiennej członka i odpowiednio ją ozdobisz, możesz wskazać zmienną jak każdą normalną zmienną spoza 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()