C++
Pekare till medlemmar

Syntax

• Förutsatt att en klass heter Class ...

  • typ * ptr = & Klass :: medlem; // Peka endast på statiska medlemmar
  • typ Klass :: * ptr = & Klass :: medlem; // Peka på icke-statiska klassmedlemmar

• För pekare till icke-statiska klassmedlemmar, med följande två definitioner:

  • Klassinstans;
  • Klass * p = & instans;

• Pekare på variabler för klassmedlemmar

  • ptr = & klass :: i; // Peka på variabel i varje klass
  • instans. * ptr = 1; // Accessinstansens i
  • p -> * ptr = 1; // Access p's i

• Pekare på klassmedlemfunktioner

  • ptr = & klass :: F; // Peka på att fungera 'F' i varje klass
  • (. Instans * ptr) (5); // Ring instansens F
  • (P -> * ptr) (6); // Ring p's F

Pekare på statiska medlemsfunktioner

En static medlemsfunktion är precis som en vanlig C / C ++ -funktion, utom med omfattning:

• Det är inne i en class , så det behöver sitt namn dekorerat med klassnamnet;
• Det har tillgänglighet, med public , protected eller private .

Så om du har tillgång till den static medlemsfunktionen och dekorerar den på rätt sätt kan du peka på funktionen som alla normala funktioner utanför en 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()

Pekare på medlemsfunktioner

För att få åtkomst till en medlemsfunktion i en klass måste du ha ett "handtag" till den specifika instansen, som antingen själva instansen, eller en pekare eller referens till den. Med en klassinstans kan du peka på olika av dess medlemmar med en pekare-till-medlem, OM du får syntaxen korrekt! Naturligtvis måste pekaren förklaras vara av samma typ som vad du pekar på ...

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

Till skillnad från pekare på medlemsvariabler (i föregående exempel), måste kopplingen mellan klassinstansen och medlemspekaren bindas tätt tillsammans med parenteser, vilket ser lite konstigt ut (som om .* Och ->* inte är konstigt tillräckligt!)

Pekare på medlemsvariabler

För att få tillgång till en medlem i en class , måste du ha en "handtag" i särskilda fall, antingen som exempel själv, eller en pekare eller referens till den. Givet en class exempel kan du peka på flera av sina medlemmar med en medlem pekare till, om du får syntaxen korrekt! Naturligtvis måste pekaren förklaras vara av samma typ som vad du pekar på ...

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

Syntaxen för pekaren till medlem kräver några extra syntaktiska element:

• För att definiera pekartypen måste du nämna bastypen samt att det finns i en klass: int Class::*ptr; .
• Om du har en klass eller referens och vill använda den med en medlem pekare till, måste du använda den .* Operatör (besläktad med . Operatör).
• Om du har en pekare till en klass och vill använda den med en pekare-till-medlem måste du använda operatören ->* (liknande till -> operatören).

Pekar på statiska medlemsvariabler

En static medlemsvariabel är precis som en vanlig C / C ++ -variabel, utom med omfattning:

• Det är inne i en class , så det behöver sitt namn dekorerat med klassnamnet;
• Det har tillgänglighet, med public , protected eller private .

Så om du har tillgång till den static medlemsvariabeln och dekorerar den på rätt sätt kan du peka på variabeln som alla normala variabler utanför en 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()