Advanced Programming II Class Notes

Lecture Notes for Advanced Programming II

5 November 2002 - 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 Pointers 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 declarations 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

Generalize procedures with respect to behavior.

Determining string kinds.

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

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)(const char * name, mode_t mode);
  int (* close)(void);
  int (* read)(char * data, unsigned size);
  int (* write)(const char * data, unsigned size);
  }

Operating system device-driver interfaces.

device_driver disk_device_driver =
  { disk_open, disk_close, disk_read, disk_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

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 GUI programming, the front-end interacts, the back-end reacts.
- The back-end gives the front-end functions to call when buttons are pushed.
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.
- 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 5 November 2002.