Chapter 31: Pointers to members

Section 31.1: Pointers to static member functions

A static member function is just like an ordinary C/C++ function, except with scope:

It is inside a class, so it needs its name decorated with the class name;

It has accessibility, with public, protected or private.

So, if you have access to the static member function and decorate it correctly, then you can point to the function like any normal function outside a 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

Section 31.2: Pointers to member functions

To access a member function of a class, you need to have a "handle" to the particular instance, as either the instance itself, or a pointer or reference to it. Given a class instance, you can point to various of its members with a pointer-to-member, IF you get the syntax correct! Of course, the pointer has to be declared to be of the same type as what you are pointing to...

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

Unlike pointers to member variables (in the previous example), the association between the class instance and the member pointer need to be bound tightly together with parentheses, which looks a little strange (as though the .* and ->* aren't strange enough!)

Section 31.3: Pointers to member variables

To access a member of a class, you need to have a "handle" to the particular instance, as either the instance itself, or a pointer or reference to it. Given a class instance, you can point to various of its members with a pointer-to- member, IF you get the syntax correct! Of course, the pointer has to be declared to be of the same type as what you are pointing to...

class Class { public:

int x, y, z; char m, n, o;

}; // Class

int x; // Global variable

p_C_i = &Class::m; // ERROR! m is a char, not an int!

char Class::*p_C_c = &Class::m; // That's better...

} // main()

The syntax of pointer-to-member requires some extra syntactic elements:

To define the type of the pointer, you need to mention the base type, as well as the fact that it is inside a class: int Class::*ptr;.

If you have a class or reference and want to use it with a pointer-to-member, you need to use the .* operator (akin to the . operator).

If you have a pointer to a class and want to use it with a pointer-to-member, you need to use the ->* operator (akin to the -> operator).

Section 31.4: Pointers to static member variables

A static member variable is just like an ordinary C/C++ variable, except with scope:

It is inside a class, so it needs its name decorated with the class name;

It has accessibility, with public, protected or private.

So, if you have access to the static member variable and decorate it correctly, then you can point to the variable like any normal variable outside a 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()