Pointers to Functions Typedef Using Pointers to Functions
UNIX and C Programming (COMP1000)
Lecture 6: Pointers to Functions
Updated: 19th August, 2019
Department of Computing
Curtin University
Copyright © 2019, Curtin University
CRICOS Provide Code: 00301J
1/20
Pointers to Functions Typedef Using Pointers to Functions
Outline
Pointers to Functions
Typedef
Using Pointers to Functions
2/20
Pointers to Functions Typedef Using Pointers to Functions
Pointers to Functions
I Functions are stored in memory, just like variables.
I Pointers can point anywhere in memory, including to functions.
I There are special pointer types to represent this.
I These pointers can point to a function with specified
parameter/return types.
pointer
function() [machine code]
3/20
Pointers to Functions Typedef Using Pointers to Functions
Pointers to Functions — Why?
I Used to implement “callbacks”:
I You call one function, and give it a pointer to another function.
I The first function calls the second, in some fashion beyond
your control.
I The second function, which you write yourself, is the “callback”
function.
I Callbacks are used a lot in “Event-Driven Programming”. For
instance:
I Mouse clicks (and their consequences, such as button presses).
I Stopwatch timers.
I Network communication.
I With callbacks, you control what happens, but you let
something else decide when it should happen.
4/20
Pointers to Functions Typedef Using Pointers to Functions
Pointers to Functions – Declaration
I To declare a pointer to a function:
return-type (*variable-name)(parameters);
For example:
int (*ptr)(float x, int y);
The parameter names are optional (and just for show):
int (*ptr)(float, int); /* Same as above */
I Looks a bit like a function, but this is actually a variable.
I ptr holds the memory address of any function that:
I Takes a float and int parameters.
I Returns an int.
5/20
Pointers to Functions Typedef Using Pointers to Functions
Pointers to Functions – Assignment
I Consider this function:
int myFunction(float abc, int xyz) {
return ...;
}
I The address-of (&) operator works on functions (as well as
variables).
I So, &myFunction is the memory address of myFunction
(where its machine code is stored).
I We use this to initialise pointers to functions:
int (*ptr)(float, int);
ptr = &myFunction; /* ptr points to myFunction */
I Like all variables, we can combine declaration and initialisation:
int (*ptr)(float, int) = &myFunction;
6/20
Pointers to Functions Typedef Using Pointers to Functions
Pointers to Functions – Usage (1)
I Pointers to functions (like all pointers) are just values.
I They can be copied and assigned like other pointers.
I However, dereferencing a pointer to a function gives you a
function.
I Consider this:
ptr
int (*ptr)(float, int);
ptr = &func;
func() [machine code]
I The expression *ptr is now equivalent to func.
I And so (*ptr)(...) is now equivalent to func(...).
I i.e. we can take a pointer, and call the function it points to.
I And remember it could be any function (with the right
parameter and return types).
7/20
Pointers to Functions Typedef Using Pointers to Functions
Pointers to Functions – Usage (2)
To complete the example:
int myFunction(float abc, int xyz) {
return ...;
}
...
/* Declare ptr as a pointer to a function. */
int (*ptr)(float, int);
/* Make ptr point to myFunction. */
ptr = &myFunction;
/* Call the function it points to. */
int result = (*ptr)(7.0, 3);
8/20
Pointers to Functions Typedef Using Pointers to Functions
Pointers to Functions — Another Example
void printHello(void) {
printf("Hello world\n");
}
/* A function that takes a pointer to another
function, and calls it n times. */
void callNTimes(int n, void (*funcPointer)(void)) {
int i;
for(i = 0; i < n; i++) {
(*funcPointer)();
}
}
...
/* Prints "Hello world\n" 10 times. */
callNTimes(10, &printHello);
9/20
Pointers to Functions Typedef Using Pointers to Functions
Typedef
I The “typedef” keyword can be placed before any declaration.
I It converts the declaration into a “type declaration”.
I The name being declared instead becomes a new data type —
an alias.
I You can then use that name in place of the type it was
declared as.
I Normally used in header files.
Simplistic Example
typedef int INTEGER;
...
INTEGER num = 15;
10/20
Pointers to Functions Typedef Using Pointers to Functions
Typedef — Pointer Example
typedef void* MagicData;
MagicData getMagic(void);
void doMagic(MagicData magic);
I MagicData is equivalent to void*.
I The new name can serve as a form of documentation.
I void* could mean anything, but MagicData might indicate
something specific about the data.
I It can also be a primitive form of information hiding.
I Other code doesn’t need to know what MagicData really is.
11/20
Pointers to Functions Typedef Using Pointers to Functions
Typedef — Pointers to Functions
I typedef can simplify pointers to functions.
I You only need one convoluted declaration (in a header file):
typedef int (*MyType)(float, int);
I MyType is now shorthand for this convoluted pointer datatype:
int (*ptr)(float, int) = &myFunction;
MyType ptr = &myFunction; /* Equivalent */
I You can also return pointers to functions:
MyType function2(char a, double b) {
return &myFunction;
}
I Without typedef, the syntax for this would be very strange.
12/20
Pointers to Functions Typedef Using Pointers to Functions
Functions as Data Types
I With pointers to functions, you treat functions as data types!
I As a result, they can look bizarre.
I However, they follow the same rules as other declarations.
I (Those rules may be more subtle than you realised!)
Consider this ordinary function declaration:
int myFunction(float, int);
I Rule 1: all declarations consist of a name and a type 1 .
I Here, the type is “int. . . (float,int)” (not just “int”).
I “myFunction” has the type “int. . . (float,int)”.
I Part of the type goes on the left, and part goes on the right!
1
Except for parameters, where the name can be omitted in a forward
declaration.
13/20
Pointers to Functions Typedef Using Pointers to Functions
Pointers to Functions – Declarations (1)
I Say we want a pointer to “int. . . (float,int)”
(i.e. a pointer to a function with those parameters and return
type).
I Where does the * go?
I Rule 2: the * goes on the left of the name.
I Where does the name go?
I In the middle! (Since part of the type goes on the left, and
part on the right.)
14/20
Pointers to Functions Typedef Using Pointers to Functions
Pointers to Functions – Declarations (2)
Almost correct (but not quite)
int* myPointer(float,int);
I Everything is (basically) in the right place; the name is
surrounded by the type.
I However, this is a function returning a pointer, not a pointer
to a function.
I Why?
I “(. . . )” (the parameter list) has a higher precedence than “*”.
I Rule 3: If there’s “(. . . )” immediately to the right, you have
a function.
15/20
Pointers to Functions Typedef Using Pointers to Functions
Pointers to Functions – Declarations (3)
Correct
Rule 4: Brackets override operator precedence.
int (*myPointer)(float,int);
This declares a variable, pointing to a function that:
I imports a float and an int; and
I returns an int.
This declaration simply obeys the rules of C that you already know.
16/20
Pointers to Functions Typedef Using Pointers to Functions
Returning Pointers to Functions (1)
I Functions can return any data type, including pointers to other
functions.
I What would the declaration look like?
I Normally, a return type goes on the left. . .
I . . . but pointers to functions have separate parts on the left
and right.
I We also need two parameter lists!
I One for the function we’re declaring, and
I One for the pointer to a function it returns.
I Rule 5: Remember all the other rules.
17/20
Pointers to Functions Typedef Using Pointers to Functions
Returning Pointers to Functions (2)
1. First, write the function without a return type:
myFunction(char a, double b)
18/20
Pointers to Functions Typedef Using Pointers to Functions
Returning Pointers to Functions (2)
1. First, write the function without a return type:
myFunction(char a, double b)
2. It returns a pointer, so add a * on the left (Rule 2):
*myFunction(char a, double b)
18/20
Pointers to Functions Typedef Using Pointers to Functions
Returning Pointers to Functions (2)
1. First, write the function without a return type:
myFunction(char a, double b)
2. It returns a pointer, so add a * on the left (Rule 2):
*myFunction(char a, double b)
3. Add brackets to keep it that way (Rule 4):
(*myFunction(char a, double b))
18/20
Pointers to Functions Typedef Using Pointers to Functions
Returning Pointers to Functions (2)
1. First, write the function without a return type:
myFunction(char a, double b)
2. It returns a pointer, so add a * on the left (Rule 2):
*myFunction(char a, double b)
3. Add brackets to keep it that way (Rule 4):
(*myFunction(char a, double b))
4. Add the second parameter list, turning the returned pointer
into a pointer to a function (Rule 3):
(*myFunction(char a, double b))(float,int)
18/20
Pointers to Functions Typedef Using Pointers to Functions
Returning Pointers to Functions (2)
1. First, write the function without a return type:
myFunction(char a, double b)
2. It returns a pointer, so add a * on the left (Rule 2):
*myFunction(char a, double b)
3. Add brackets to keep it that way (Rule 4):
(*myFunction(char a, double b))
4. Add the second parameter list, turning the returned pointer
into a pointer to a function (Rule 3):
(*myFunction(char a, double b))(float,int)
5. Add the return type for the returned pointer to a function:
int (*myFunction(char a, double b))(float,int)
18/20
Pointers to Functions Typedef Using Pointers to Functions
Returning Pointers to Functions (3)
I Compare myFunction to myPointer (declared earlier):
int (*myPointer)(float,int)
int (*myFunction(char a, double b))(float,int);
(The type of myPointer and the return type of myFunction
are in red.)
I See the similarities and differences?
I myPointer is a pointer to a function.
I myFunction returns a pointer to a function.
I The brackets after the name make the difference between a
variable and a function (rule 3).
19/20
Pointers to Functions Typedef Using Pointers to Functions
Returning Pointers to Functions — Example
int simpleFunction(float x, int y) {
return 10;
}
int (*myFunction(char a, double b))(float,int) {
return &simpleFunction;
}
...
int (*myPointer)(float,int);
int result;
myPointer = myFunction(’A’, 2.5);
result = (*myPointer)(7.0, 3);
20/20
