C++
Hinweise auf Mitglieder

Syntax

• Angenommen, eine Klasse namens Class ...

  • type * ptr = & Class :: member; // Nur auf statische Member zeigen
  • type Class :: * ptr = & Class :: member; // Zeigen Sie auf nicht statische Klassenmitglieder

• Für Zeiger auf nicht statische Klassenmitglieder die folgenden zwei Definitionen

  • Klasseninstanz;
  • Klasse * p = & Instanz;

• Zeiger auf Klassenmitgliedsvariablen

  • ptr = & Class :: i; // Zeige auf die Variable i innerhalb jeder Klasse
  • Instanz. * ptr = 1; // Zugriff auf die Instanz i
  • p -> * ptr = 1; // Zugriff auf p's i

• Zeiger auf Klassenmitgliedsfunktionen

  • ptr = & Class :: F; // Zeigen Sie auf die Funktion 'F' in jeder Klasse
  • (Instanz. * ptr) (5); // Aufruf der Instanz F
  • (p -> * ptr) (6); // Rufe ps F auf

Zeiger auf statische Memberfunktionen

Eine static Memberfunktion ist wie eine normale C / C ++ - Funktion, mit Ausnahme des Gültigkeitsbereichs:

• Es befindet sich in einer class und muss daher mit dem Klassennamen versehen werden.
• Es ist zugänglich, mit public , protected oder private .

Wenn Sie also Zugriff auf die static Member-Funktion haben und diese korrekt dekorieren, können Sie wie jede normale Funktion außerhalb einer class auf die Funktion verweisen:

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

Zeiger auf Elementfunktionen

Um auf eine Member-Funktion einer Klasse zuzugreifen, benötigen Sie einen "Handle" für die jeweilige Instanz, entweder als Instanz selbst oder als Zeiger oder Verweis darauf. Bei einer Klasseninstanz können Sie auf verschiedene Member mit einem Zeiger auf Member zeigen. WENN Sie die Syntax korrekt erhalten! Natürlich muss der Zeiger so deklariert werden, dass er dem Typ entspricht, auf den Sie zeigen.

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

Im Gegensatz zu Zeigern auf Member-Variablen (im vorherigen Beispiel) muss die Zuordnung zwischen der Klasseninstanz und dem Member-Zeiger eng mit Klammern verbunden sein, was ein wenig seltsam aussieht (als wären die .* Und ->* nicht seltsam genug!)

Zeiger auf Membervariablen

Um auf ein Member einer class zuzugreifen, benötigen Sie einen "Handle" für die jeweilige Instanz, entweder als Instanz selbst oder als Zeiger oder Verweis darauf. Bei einer class können Sie auf verschiedene Member mit einem Zeiger auf Member zeigen. WENN Sie die Syntax korrekt erhalten! Natürlich muss der Zeiger so deklariert werden, dass er dem Typ entspricht, auf den Sie zeigen.

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

Die Syntax von pointer-to-member erfordert einige zusätzliche syntaktische Elemente:

• Um den Typ des Zeigers zu definieren, müssen Sie den Basistyp sowie die Tatsache int Class::*ptr; , dass er sich innerhalb einer Klasse befindet: int Class::*ptr; .
• Wenn Sie eine Klasse oder Referenz haben und sie benutzen wollen mit einem Zeiger-to-Mitglied, müssen Sie die verwenden .* Operator (verwandt mit dem . Operator).
• Wenn Sie einen Zeiger auf eine Klasse haben und ihn mit einem Zeiger auf Mitglied verwenden möchten, müssen Sie den Operator ->* (ähnlich dem Operator -> ).

Zeiger auf statische Membervariablen

Eine static Member-Variable ist wie eine gewöhnliche C / C ++ - Variable, mit Ausnahme des Gültigkeitsbereichs:

• Es befindet sich in einer class und muss daher mit dem Klassennamen versehen werden.
• Es ist zugänglich, mit public , protected oder private .

Wenn Sie also Zugriff auf die static Membervariable haben und diese korrekt dekorieren, können Sie wie jede normale Variable außerhalb einer class auf die Variable zeigen:

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