C++
Aanwijzingen voor leden

Syntaxis

• Uitgaande van een klasse met de naam Class ...

  • type * ptr = & Class :: lid; // Wijs alleen naar statische leden
  • type Klasse :: * ptr = & Klasse :: lid; // Wijs naar niet-statische Class-leden

• Voor verwijzingen naar niet-statische klassenleden, gegeven de volgende twee definities:

  • Klasse instantie;
  • Klasse * p = & instantie;

• Verwijzingen naar variabelen van klassenleden

  • ptr = & Class :: i; // Wijs naar variabele i binnen elke klasse
  • exemplaar. * ptr = 1; // Toegangsinstantie i
  • p -> * ptr = 1; // Toegang tot p's i

• Aanwijzingen voor lidfuncties van Klasse

  • ptr = & Klasse :: F; // Wijs naar functie 'F' binnen elke klasse
  • (. Bijvoorbeeld * ptr) (5); // Bel instantie F
  • (P -> * ptr) (6); // Bel p's F

Aanwijzingen voor statische lidfuncties

Een static lidfunctie is net als een gewone C / C ++ -functie, behalve met scope:

• Het zit in een class , dus het heeft zijn naam nodig versierd met de klasnaam;
• Het heeft toegankelijkheid, met public , protected of private .

Dus als u toegang hebt tot de static lidfunctie en deze correct decoreert, kunt u naar de functie verwijzen zoals elke normale functie buiten een 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()

Aanwijzingen voor lidfuncties

Om toegang te krijgen tot een lidfunctie van een klasse, moet u een "handle" hebben voor de specifieke instantie, zoals de instantie zelf, of een pointer of verwijzing ernaar. Gegeven een klasse-instantie, kunt u naar verschillende van zijn leden wijzen met een pointer-to-member, ALS u de syntaxis correct krijgt! Natuurlijk moet de aanwijzer van hetzelfde type worden verklaard als waarnaar u verwijst ...

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

In tegenstelling tot verwijzingen naar lidvariabelen (in het vorige voorbeeld), moet de associatie tussen de klasse-instantie en de lidwijzer nauw worden samengebonden tussen haakjes, wat een beetje vreemd lijkt (alsof de .* En ->* niet vreemd zijn genoeg!)

Verwijzingen naar lidvariabelen

Om toegang te krijgen tot een lid van een class , moet u een "handle" hebben voor de specifieke instantie, zoals de instantie zelf, of een pointer of verwijzing ernaar. Gegeven een class instantie, kunt u naar verschillende van zijn leden wijzen met een pointer-to-member, ALS u de syntaxis correct krijgt! Natuurlijk moet de aanwijzer van hetzelfde type worden verklaard als waarnaar u verwijst ...

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

De syntaxis van pointer-to-member vereist enkele extra syntactische elementen:

• Om het type van de aanwijzer te definiëren, moet u het basistype vermelden, evenals het feit dat het zich binnen een klasse bevindt: int Class::*ptr; .
• Als u een klasse of referentie en het wilt gebruiken met een pointer-to-lid, moet u het te gebruiken .* Operator (verwant aan de . Operator).
• Als u een aanwijzer naar een klasse hebt en deze met een aanwijzer naar lid wilt gebruiken, moet u de operator ->* gebruiken (vergelijkbaar met de -> operator).

Verwijzingen naar statische lidvariabelen

Een static lidvariabele is net als een gewone C / C ++ variabele, behalve met scope:

• Het zit in een class , dus het heeft zijn naam nodig versierd met de klasnaam;
• Het heeft toegankelijkheid, met public , protected of private .

Dus als u toegang hebt tot de static lidvariabele en deze correct decoreert, kunt u naar de variabele verwijzen zoals elke normale variabele buiten een 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()