Function pointer syntax tutorial
Function pointer syntax is one of those weird, weird things that just doesn’t seem right.
Can you read that?
In less than 2 paragraphs, you will!
First things first. What is a function pointer anyway? Why, its simply a variable that, instead of pointing to an object (like an
int* will point to an integer, and a
double* will point to a double), this weird, weird “function pointer” will actually point to __A FUNCTION__!!
WHAT?? You say. POINT TO A FUNCTION! Why, yes! It is no different than me pointing to a recipe. Its one thing to have a copy of the recipe for chocolate mousse in hand (an actual function body), and its another thing to have a hyperlink that merely __points__ to that chocolate mousse recipe (a pointer to the function). When you have a pointer to a function (hyperlink to a recipe) you can still execute it (make the recipe) but you need to remember to dereference the pointer first (follow the hyperlink to pull up the recipe).
Does that make a little bit of sense? Me hopes so.
Moving on to function pointer syntax then, it is actually not that bad to read. Say you had a function:
puts( "It. There. Happy now?" ) ;
And you wanted to declare a function pointer to the SayIt() function in your main function:
// DECLARE A FUNCTION POINTER TO THE
// SayIt() function by the name of ptrSayIt
void (*ptrSayIt)() ;
// The above is probably the weirdest, non-C++ish
// syntax you've come across. It looks weird because
// it is. No, really, function pointer declaration
// syntax is kind of mixed up.
// 1. First, the word VOID specifies the
// return type of the function that you
// will point to...
// 2. Second is (*ptrSayIt). The bracket
// and star combination (* there
// says THIS IS A FUNCTION POINTER, NOT
// A FUNCTION DECLARATION THAT RETURNS A POINTER
// TO VOID* (which is what "void *ptrSayIt();" would mean!)
// 3. Third, the trailing brackets at the end ()
// say that the function we are pointing to
// won't accept any arguments when it is called.
// If it helps, you can look at it as:
// void(*)(). That is the type of the
// ptrSayIt variable. The "mixed up" part
// is because this breaks the usual C declaration
// syntax of TYPE InstanceName,
// and so its really weird to look at at first.
// Then you kind of get used to it. Keep reading!
// Now the ptrSayIt variable points to the
// SayIt function..
ptrSayIt = &SayIt ; // you don't really need the & in front
// but I put it to be clear
// Now we can call the SayIt function __through__
// the ptrSayIt pointer we just declared and set up!
(*ptrSayIt)() ; // (*DEREFERENCE) the pointer first!
// OUTPUTS: "It. There. Happy now?"
// TRY IT YOURSELF!
So this all seems very weird. But the program above works, I guarantee!
Lets do some more examples.
Declare a function pointer named Foo that points to a function marked by prototype:
int add( int a, int b ) ;
int (*Foo)(int,int) ;
Reasoning: the return type of the function you are about to point to goes first.
int // function pointer will point
// to a function returning int..
Then, you do this mixed up thing where you write the name of the pointer variable NOW, in brackets, with a * in front:
int (*Foo) // function pointer VARIABLE
// identifier/handle is Foo. This is actually
// the WEIRDEST part of the syntax.
Then you follow up with the types of arguments that the function you are trying to point to will contain:
int (*Foo)( int, int ) // will point
// to a function accepting 2 ints
So what’s the use of function pointers? Why, many, many uses!
Now you can write functions that accept pointers to functions.. and so you can have a function have variable behavior based on what function you passed it…-
But you probably already think function pointers are cool. That’s why you stopped in to read about them!