C++
Указатели для участников

Синтаксис

• Предполагая класс с именем Class ...

  • type * ptr = & Class :: member; // Указывать только на статические члены
  • type Class :: * ptr = & Class :: member; // Указываем нестатические члены класса

• Для указателей на нестатические члены класса, учитывая следующие два определения:

  • Экземпляр класса;
  • Класс * p = & instance;

• Указатели на переменные класса

  • ptr = & Class :: i; // Указывать на переменную i внутри каждого класса
  • instance. * ptr = 1; // Доступ к экземпляру экземпляра i
  • p -> * ptr = 1; // Доступ к p i

• Указатели на функции члена класса

  • ptr = & Класс :: F; // Точка к функции 'F' внутри каждого класса
  • (. * Экземпляр PTR) (5); // Вызов экземпляра F
  • (Р -> * PTR) (6); // Вызов p's F

Указатели на статические функции-члены

static функция-член аналогична обычной функции C / C ++, за исключением области:

• Он находится внутри class , поэтому ему нужно его имя, украшенное именем класса;
• Он имеет доступ к public , protected или private .

Итак, если у вас есть доступ к static функции-члену и правильно ее украсить, вы можете указать на функцию, как на любую нормальную функцию вне 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()

Указатели на функции-члены

Чтобы получить доступ к функции-члену класса, вам нужно иметь «дескриптор» для конкретного экземпляра, как самого экземпляра, так и указателя или ссылки на него. Учитывая экземпляр класса, вы можете указать на различные его члены с указателем на член, если вы правильно поняли синтаксис! Конечно, указатель должен быть объявлен того же типа, что и указатель на ...

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

В отличие от указателей на переменные-члены (в предыдущем примере), связь между экземпляром класса и указателем-членом должна быть тесно связана с круглыми скобками, что выглядит немного странным (как будто .* И ->* не странны довольно!)

Указатели на переменные-члены

Чтобы получить доступ к члену class , вам нужно иметь «дескриптор» для конкретного экземпляра, как самого экземпляра, так и указателя или ссылки на него. Учитывая экземпляр class , вы можете указать на различные его члены с указателем на член, если вы правильно поняли синтаксис! Конечно, указатель должен быть объявлен того же типа, что и указатель на ...

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

Синтаксис указателя на член требует некоторых дополнительных синтаксических элементов:

• Чтобы определить тип указателя, вам нужно указать базовый тип, а также тот факт, что он находится внутри класса: int Class::*ptr; ,
• Если у вас есть класс или ссылка и хотите использовать его с указателем на члене, вы должны использовать .* Оператор (родственный . Оператор).
• Если у вас есть указатель на класс и вы хотите использовать его с указателем на член, вам нужно использовать оператор ->* (сродни оператору -> ).

Указатели на статические переменные-члены

static переменная-член как обычная переменная C / C ++, за исключением области:

• Он находится внутри class , поэтому ему нужно его имя, украшенное именем класса;
• Он имеет доступ к public , protected или private .

Итак, если у вас есть доступ к static переменной-члену и правильно ее украсить, вы можете указать на переменную как на любую нормальную переменную вне 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()