Advanced Programming II Class Notes

Lecture Notes for Advanced Programming II

4 November 2003 - Function Pointers

Function Pointers.

Three problems
What are Function Pointers?
- Function Pointer Declarations
- typedefs
- Function Pointer Gotchas
Operations on Function Pointer Values
- Assignment
- Follow and Address-Of
- The Call Operator
Function Pointer Idioms
- Function Arguments
- Interface Definitions
- Callback Functions

String-Type Functions

Extend the <cctype> predicates to strings.

bool isdigitstr(const std::string & str);
bool isspacestr(const std::string & str);

and so on.

This is relatively easy to do.

bool isdigitstr(const std::string & str)
  for (unsigned i = 0; i < str.size(); i++)
    if !std::isdigit(str[i])
      return false
  return true

bool isspacestr(const std::string & str)
  for (unsigned i = 0; i < str.size(); i++)
    if !std::isspace(str[i])
      return false
  return true

and so on.

But hark! Duplicated code. Is there a better way?

Uniform Device Interfaces

Operating systems provide access to many devices.
- Disks, terminals, networks, ...
All devices do more or less the same things.
- open(), close(), read(), write(), ...
Having an interface per device is not a good idea.
- Each device requires more work to support.
- Each programmer has to work harder to use devices.
Having one interface for all devices is a better idea.
- Adding a new device type requires no new interface designs.
- Programmers learn one interface for all devices.
How can one interface supporting many devices be implemented?

Widget-Action Coordination

Graphical user interfaces make use of buttons, menus and other widgets.
Each widget type is the same, but each behaves differently.
- "Quit", "Read", and "Send" are all buttons, but each does different things.
How can a uniform set of widgets be given different behaviors?
Creating a widget per behavior is a bad idea.
- A quit button widget, a send button widget, ...
- Expensive to do.
- Mixes up the user interface with the rest of the system.
Is there a better way to incorporate behavior in widgets?

Function Pointers

A C more than a C++ feature, but useful none the less.
Function pointers are the basis for many high-level features in C++.
- Parameter functions in STL generic algorithms.
- Basis for implementing virtual functions in objects.
- Used heavily in gui programming as callbacks.
Function pointers are also useful on their own.
- Simulating C++ high-level features in other languages (C, for example).

What are Function Pointers?

A function is a block of code.
A function pointer is the first address in a function.
Calling a function follows the function pointer to the code to execute.

Function Pointer Declarations

Function pointer declarations can be hairy, but are logical (sorta).

The general declaration form is

return-type-spec ( * fun-name ) ( argument-list-decls )

For example
```
bool (* comp)(int x, int y)
```
declares a
- function pointer variable named comp that
- accepts two int parameters and
- returns a bool value.
Argument parameter names are optional in function pointer declarations.
- For example, bool (* comp)(int, int)
- Use them anyway, for documentation.

`typedef`s

Typedefs make function pointer declarations manageable.
typedef bool (* comp_fun)(int x, int y)
- The function name is the typedef name.
Function pointer types are just like any other types.
- Declare function-pointer parameters.
```
void sort(int a[], comp_fun less) { ... }
```
- Declare arrays of function pointers.
```
comp_fun orders[] = { less, equal, greater }
```
Typedef names can't be used to declare functions themselves.

Function Pointer Gotchas

Be careful with parentheses when using function pointers.
- bool (* comp)(int, int) declares comp as a pointer to a function accepting two ints and returning a bool.
- bool * comp(int, int) declares comp as a function accepting two ints and return a pointer to a bool.
- Function pointers and parens are the source of some of the most idiotic parses in C++.
Initialize function-pointer variables before use.
- As with any other uninitialized variable, uninitialized function-pointer variables contain garbage.
- Unlike other initialized variables, using an uninitialized function-pointer variable leads to disaster.
```
int i;
void (* f)(int x);
std::cout << i;    // whatever
(* f)(3);          // disaster
```

Operations on Function Pointer Values

Function pointers are pointers; assignment, follow and address-of are defined.

Assignment.

Function definitions provide constant function-pointer values.

bool less(int x, int y) { . . . }

bool (* comp)(int x, int y) = &less;

Assignments should be type checked.

void less1(int x, int y) { . . . }
bool less2(int x) { . . . }
bool less3(int x, float y) { . . . }

bool (* comp1)(int x, int y) = &less1;
bool (* comp2)(int x, int y) = &less2;
bool (* comp3)(int x, int y) = &less3;

Some compilers are more lenient than others, however.

Follow and Address-Of

Pointer follow * goes to the function to execute.
- You can't execute a pointer.
```
bool b = (* cmpr)(3, 4);
```
- This is a standard, automatic conversion:
  from fp(...) to (* fp)(...).
```
bool b = cmpr(3, 4);
```
- However, * must appear in function pointer declarations.
The address-of operator & is not necessary.
- A function name is a function pointer.
  - This is similar to array names.
```
bool (* comp)(int x, int y) = less;
```

The Call Operator `()`

Calling is an operator like any other.
It has the second highest precedence (:: is highest).
- Watch the parenthesis.
```
(* comp)(1, 2)
```
  is not the same as
  * comp(1, 2), identical to * (comp(1, 2)).
The procedure call operator () can be overloaded.
- This is used heavily in the STL as function objects or functors.
More on this later.

Function Pointers Idioms

Function pointers have a number of important uses.
Generalize functions via function pointer arguments.
- Similar to templates, but with values, not types.
Easily implement function substitution.
- The basis for implementing inheritance.
Allow control to be spread around a program in simple ways.
- Functions encapsulate behavior; function pointers pass it around.

Function Arguments

How can we get lots of different string predicates without duplicating lots of code?

Generalize procedures with respect to behavior.

bool isstrkind(string str, int (* cp)(int))
  for (unsigned i = 0; i < str.size(); i++)
    if !cp(str[i])
      return false
  return true

isstrkind(str, isspace)
isstrkind(str, isdigit)

Many STL generic algorithms (the _if ones, in particular).

Custom error handling. Got an error? Call a function.

    
widget::
widget(args a, void (* err_fun)(args))

  if terrible error
    err_fun(a)

Interface Definitions

How can different devices present a uniform interface?
Function pointers can simulate over-ridden member functions.
- Function pointers implement over-ridden member functions.

A struct of function pointers looks like an object.

struct device_driver {
  int (* open)(char * name, mode_t mode);
  int (* close)(void);
  int (* read)(char * data, unsigned size);
  int (* write)(char * data, unsigned size);
  }

Operating system device-driver interfaces.

device_driver disk_device_driver =
  { dsk_open, dsk_close, dsk_read, dsk_write }

device_driver tty_device_driver =
  { tty_open, tty_close, tty_read, tty_write }

void t(void) {
  device_driver dd = disk_device_driver
  (dd.open)("/dev/null", R_ONLY)
  }

Callback Functions

How to get widgets of the same type to behave differently?

Customize each widget behavior with a pointer to a function.

When the widget is activated, it calls the funcion.
This function type is known as a callback function.

static void quit_action(...) {...}
static void read_action(...) {...}
static void send_action(...) {...}

static button 
  quit_button = new_button("quit", quit_action)
  read_button = new_button("read", read_action)
  send_button = new_button("send", send_action)

In GUI programming, the front-end interacts, the back-end reacts.
- The back-end gives the front-end functions to call when buttons are pushed.

Other Callback Uses

Simulated concurrency with callback functions.
- Coordinating two or more independent but related program parts.
  - How do the parts coordinate?
- Each part gives the other functions to call to coordinate.
In discrete event simulators an event occurs, a function happens.
- Each event includes a function pointer when the event occurs.
- The simulator calls the event's function.

Function Pointers in C++

Function pointers are less useful in C++.
- Objects are safer and easier to use, but are possibly more expensive.
What about member functions?
- A member function needs its context.
  - Where does this come from?
- The arcane .* and ->* syntax (neither overloadable).
Overloading operator () is much more fun, though.

Points to Remember

Function pointers are the basis for several important capabilities.
- General function arguments, member-function inheritance, callbacks.
Function pointers are the address of executable code.
- Make sure that's always true.
Function pointers are a pointer type.
- Assign them, follow them, address them.
Learn the idioms supported by function pointers.

This page last modified on 17 November 2003.