You’ve used a lot of C functions in the book so far, but the truth is that there are still some ways to make your C functions a lot more powerful. If you know how to use them correctly, C functions can make your code do more things but without writing a lot more code.

To see how this works, let’s look at an example. Imagine you have an array of strings that you want to filter down, displaying some strings and not displaying others:

int NUM_ADS = 7;
char *ADS[] = {
  "William: SBM GSOH likes sports, TV, dining",
  "Matt: SWM NS likes art, movies, theater",
  "Luis: SLM ND likes books, theater, art",
  "Mike: DWM DS likes trucks, sports and bieber",
  "Peter: SAM likes chess, working out and art",
  "Josh: SJM likes sports, movies and theater",
  "Jed: DBM likes theater, books and dining"
};

Let’s write some code that uses string functions to filter this array down.

Code Magnets

Complete the find() function so it can track down all the sports fans in the list who don’t also share a passion for Bieber.

Beware: you might not need all the fragments to complete the function.

Code Magnets Solution

You were to complete the find() function so it can track down all the sports fans in the list who don’t also share a passion for Bieber.

Test Drive

Now, if you take the function and the data, and wrap everything up in a program called find.c, you can compile and run it like this:

And sure enough, the find() function loops through the array and finds the matching strings. Now that you have the basic code, it would be easy to create clones of the function that could perform different kinds of searches.

Exactly right. If you clone the function, you’ll have a lot of duplicated code.

C programs often have to perform tasks that are almost identical except for some small detail. At the moment, the find() function runs through each element of the array and applies a simple test to each string to look for matches. But the test it makes is hardwired. It will always perform the same test.

Now, you could pass some strings into the function so that it could search for different substrings. The trouble is, that wouldn’t allow find() to check for three strings, like “arts,” “theater,” or “dining.” And what if you needed something wildly different?

You need something a little more sophisticated...

What you need is some way of passing the code for the test to the find() function. If you had some way of wrapping up a piece of code and handing that code to the function, it would be like passing the find() function a testing machine that it could apply to each piece of data.

This means the bulk of the find() function would stay exactly the same. It would still contain the code to check each element in an array and display the same kind of output. But the test it applies against each element in the array would be done by the code that you pass to it.

Imagine you take our original search condition and rewrite it as a function:

int sports_no_bieber(char *s)
{
  return strstr(s, "sports") && !strstr(s, "bieber");
}

Now, if you had some way of passing the name of the function to find() as a parameter, you’d have a way of injecting the test:

If you could find a way of passing a function name to find(), there would be no limit to the kinds of tests that you could make in the future. As long as you can write a function that will return true or false to a string, you can reuse the same find() function.

find(sports_no_bieber);
find(sports_or_workout);
find(ns_theater);
find(arts_theater_or_dining);

But how do you say that a parameter stores the name of a function? And if you have a function name, how do you use it to call the function?

You probably guessed that pointers would come into this somewhere, right? Think about what the name of a function really is. It’s a way of referring to the piece of code. And that’s just what a pointer is: a way of referring to something in memory.

That’s why, in C, function names are also pointer variables. When you create a function called go_to_warp_speed(int speed), you are also creating a pointer variable called go_to_warp_speed that contains the address of the function. So, if you give find() a parameter that has a function pointer type, you should be able to use the parameter to call the function it points to.

Let’s look at the C syntax you’ll need to work with function pointers.

Usually, it’s pretty easy to declare pointers in C. If you have a data type like int, you just need to add an asterisk to the end of the data type name, and you declare a pointer with int *. Unfortunately, C doesn’t have a function data type, so you can’t declare a function pointer with anything like function *.

Why doesn’t C have a function data type?

C doesn’t have a function data type because there’s not just one type of function. When you create a function, you can vary a lot of things, such as the return type or the list of parameters it takes. That combination of things is what defines the type of the function.

So, for function pointers, you’ll need to use slightly more complex notation...

Say you want to create a pointer variable that can store the address of each of the functions on the previous page. You’d have to do it like this:

That looks pretty complex, doesn’t it?

Unfortunately, it has to be, because you need to tell C the return type and the parameter types the function will take. But once you’ve declared a function pointer variable, you can use it like any other variable. You can assign values to it, you can add it to arrays, and you can also pass it to functions...

...which brings us back to your find() code...

Exercise

Take a look at those other types of searches that people have asked for. See if you can create a function for each type of search. Remember: the first is already written.

Then, see if you can complete the find() function:

Exercise Solution

You were to take a look at those other types of searches that people have asked for and create a function for each type of search.

Then, you were to complete the find() function:

Test Drive

Let’s take those functions out on the road and see how they perform. You’ll need to create a program to call find() with each function in turn:

Each call to the find() function is performing a very different search. That’s why function pointers are one of the most powerful features in C: they allow you to mix functions together. Function pointers let you build programs with a lot more power and a lot less code.

The Hunter’s Guide to Function Pointers

When you’re out in the reeds, identifying those function pointers can be pretty tricky. But this simple, easy-to-carry guide will fit in the ammo pocket of any C user.

Lots of programs need to sort data. And if the data’s something simple like a set of numbers, then sorting is pretty easy. Numbers have their own natural order. But it’s not so easy with other types of data.

Imagine you have a set of people. How would you put them in order? By height? By intelligence? By hotness?

When the people who wrote the C Standard Library wanted to create a sort function, they had a problem:

How could a sort function sort any type of data at all?

You probably guessed the solution: the C Standard Library has a sort function that accepts a pointer to a comparator function, which will be used to decide if one piece of data is the same as, less than, or greater than another piece of data.

This is what the qsort() function looks like:

The qsort() function compares pairs of values over and over again, and if they are in the wrong order, the computer will switch them.

And that’s what the comparator function is for. It will tell qsort() which order a pair of elements should be in. It does this by returning three different values:

To see how this works in practice, let’s look at an example.

Sorting ints Up Close

Let’s say you have an array of integers and you want to sort them in increasing order. What does the comparator function look like?

int scores[] = {543,323,32,554,11,3,112};

If you look at the signature of the comparator function that qsort() needs, it takes two void pointers given by void*. Remember void* when we used malloc()? A void pointer can store the address of any kind of data, but you always need to cast it to something more specific before you can use it.

The qsort() function works by comparing pairs of elements in the array and then placing them in the correct order. It compares the values by calling the comparator function that you give it.

A void pointer void* can store a pointer to anything.

int compare_scores(const void* score_a, const void* score_b)

{
  
...

}

Values are always passed to the function as pointers, so the first thing you need to do is get the integer values from the pointers:

Then you need to return a positive, negative, or zero value, depending on whether a is greater than, less than, or equal to b. For integers, that’s pretty easy to do—you just subtract one number from the other:

And this is how you ask qsort() to sort the array:

qsort(scores, 7, sizeof(int), compare_scores);

Long Exercise

Now it’s your turn. Look at these different sort descriptions. See if you can write a comparator function for each one. To get you started, the first one is already completed.

And finally: if you already had the compare_areas() and compare_names() functions, how would you write these two comparator functions?

Long Exercise Solution

Now it’s your turn. You were to look at these different sort descriptions and write a comparator function for each one.

And finally: if you already had the compare_areas() and compare_names() functions, how did you write these two comparator functions?

Test Drive

Some of the comparator functions were really pretty gnarly, so it’s worth seeing how they run in action. This is the kind of code you need to call the functions.

If you compile and run this code, this is what you get:

Do this!

Great, it works.

Now try writing your own example code. The sorting functions can be incredibly useful, but the comparator functions they need can be tricky to write. But the more practice you get, the easier they become.

Imagine you’re writing a mail-merge program to send out different types of messages to different people. One way of creating the data for each response is with a struct like this:

The enum gives you the names for each of the three types of response you’ll be sending out, and that response type can be recorded against each response. Then you’ll be able to use your new response data type by calling one of these three functions for each type of response:

void dump(response r)
{
  printf("Dear %s,
", r.name);
  puts("Unfortunately your last date contacted us to");
  puts("say that they will not be seeing you again");
}


void second_chance(response r)
{
  printf("Dear %s,
", r.name);
  puts("Good news: your last date has asked us to");
  puts("arrange another meeting. Please call ASAP.");
}


void marriage(response r)
{
  printf("Dear %s,
", r.name);
  puts("Congratulations! Your last date has contacted");
  puts("us with a proposal of marriage.");
}

So, now that you know what the data looks like, and you have the functions to generate the responses, let’s see how complex the code is to generate a set of responses from an array of data.

Pool Puzzle

Take code fragments from the pool and place them into the blank lines below. Your goal is to piece together the main() function so that it can generate a set of letters for the array of response data. You may not use the same code fragment more than once.

int main()
{
  response r[] = {
    {"Mike", DUMP}, {"Luis", SECOND_CHANCE},
    {"Matt", SECOND_CHANCE}, {"William", MARRIAGE}
  };
  int i;
  for (i = 0; i < 4; i++) {
    switch(_____________) {
    case _____________:
      dump(_____________);
      break;
    case______________:
      second_chance(_____________);
      break;
    default:
      marriage(_____________);
    }
  }
  return 0;
}

Note: each thing from the pool can be used only once!

Pool Puzzle Solution

Take code fragments from the pool and place them into the blank lines below. Your goal was to piece together the main() function so that it can generate a set of letters for the array of response data.

Note: each thing from the pool can be used only once!

Test Drive

When you run the program, sure enough, it generates the correct response for each person:

Well, it’s good that it worked, but there is quite a lot of code in there just to call a function for each piece of response data. Every time you need call a function that matches a response type, it will look like this:

switch(r.type) {
case DUMP:
  dump(r);
  break;
case SECOND_CHANCE:
  second_chance(r);
  break;
default:
  marriage(r);
}

And what will happen if you add a fourth response type? You’ll have to change every section of your program that looks like this. Soon, you will have a lot of code to maintain, and it might go wrong.

Fortunately, there is a trick that you can use in C, and it involves arrays...

The trick is to create an array of function pointers that match the different response types. Before seeing how that works, let’s look at how to create an array of function pointers. If you had an array variable that could store a whole bunch of function names, you could use it like this:

replies[] = {dump, second_chance, marriage};

But that syntax doesn’t quite work in C. You have to tell the compiler exactly what the functions will look like that you’re going to store in the array: what their return types will be and what parameters they’ll accept. That means you have to use this much more complex syntax:

But how does an array help?

Look at that array. It contains a set of function names that are in exactly the same order as the types in the enum:

enum response_type {
DUMP, SECOND_CHANCE, MARRIAGE};

This is really important, because when C creates an enum, it gives each of the symbols a number starting at 0. So DUMP == 0, SECOND_CHANCE == 1, and MARRIAGE == 2. And that’s really neat, because it means you can get a pointer to one of your sets of functions using a response_type:

Let’s see if you can use the function array to replace your old main() function.

Sharpen your pencil

OK, this exercise is quite a tough one. But take your time with it, and you should be fine. You already have all the information you need to complete the code. In this new version of the main() function, the whole switch/case statement used before has been removed and needs to be replaced with a single line of code. This line of code will find the correct function name from the replies array and then use it to call the function.

void (*replies[])(response) = {dump, second_chance, marriage};

int main()
{
  response r[] = {
    {"Mike", DUMP}, {"Luis", SECOND_CHANCE},
    {"Matt", SECOND_CHANCE}, {"William", MARRIAGE}
  };
  int i;
  for (i = 0; i < 4; i++) {
    ______________________________
  }
  return 0;
}

Sharpen your pencil: Solution

OK, this exercise was quite a tough one. In this new version of the main() function, the whole switch/case statement used before was removed, and you needed to replace it. This line of code will find the correct function name from the replies array and then use it to call the function.

Let’s break that down.

Test Drive

Now, when you run the new version of the program, you get exactly the same output as before:

The difference? Now, instead of an entire switch statement, you just have this:

(replies[r[i].type])(r[i]);

If you have to call the response functions at several places in the program, you won’t have to copy a lot of code. And if you decide to add a new type and a new function, you can just add it to the array:

Arrays of function pointers can make your code much easier to manage. They are designed to make your code scalable by making it shorter and easier to extend. Even though they are quite difficult to understand at first, function pointer arrays can really crank up your C programming skills.

Bullet Points

• Function pointers store the addresses of functions.

• The name of each function is actually a function pointer.

• If you have a function shoot(), then shoot and &shoot are both pointers to that function.

• You declare a new function pointer with return-type(*var-name)(param-types).

• If fp is a function pointer, you can call it with fp(params, ...).

• Or, you can use (*fp)(params,...). C will work the same way.

• The C Standard Library has a sorting function called qsort().

• qsort() accepts a pointer to a comparator function that can test for (in)equality.

• The comparator function will be passed pointers to two items in the array being sorted.

• If you have an array of data, you can associate functions with each data item using function pointer arrays.

There are no Dumb Questions

Q:	Why is the function pointer array syntax so complex?
A:	Because when you declare a function pointer, you need to say what the return and parameter types are. That’s why there are so many parentheses.
Q:	This looks a little like the sort of object-oriented code in other languages. Is it?
A:	It’s similar. Object-oriented languages associate a set of functions (called methods) with pieces of data. In the same way, you can use function pointers to associate functions with pieces of data.
Q:	Hey, so does that mean that C is object oriented? Wow, that’s awesome.
A:	No. C is not object oriented, but other languages that are built on C, like Objective-C and C++, create a lot of their object-oriented features by using function pointers under the covers.

Sometimes, you want to write C functions that are really powerful, like your find() function that could search using function pointers. But other times, you just want to write functions that are easy to use. Take the printf() function. The printf() function has one really cool feature that you’ve used: it can take a variable number of arguments:

So how can YOU do that?

And you’ve got just the problem that needs it. Down in the Head First Lounge, they’re finding it a little difficult to keep track of the drink totals. One of the guys has tried to make life easier by creating an enum with the list of cocktails available and a function that returns the prices for each one:

enum drink {
  MUDSLIDE, FUZZY_NAVEL, MONKEY_GLAND, ZOMBIE
};

double price(enum drink d)
{
  switch(d) {
  case MUDSLIDE:
    return 6.79;
  case FUZZY_NAVEL:
    return 5.31;
  case MONKEY_GLAND:
    return 4.82;
  case ZOMBIE:
    return 5.89;
  }
  return 0;
}

And that’s pretty cool, if the Head First Lounge crew just wants the price of a drink. But what they want to do is get the price of a total drinks order:

They want a function called total() that will accept a count of the drinks and then a list of drink names.

Variadic Functions Up Close

A function that takes a variable number of parameters is called a variadic function. The C Standard Library contains a set of macros that can help you create your own variadic functions. To see how they work, you’ll create a function that can print out series of ints:

Note

You can think of macros as a special type of function that can modify your source code.

Here’s the code:

Let’s break it down and take a look at it, step by step.

Geek Bits

Functions vs. macros

A macro is used to rewrite your code before it’s compiled. The macros you’re using here ( va_start, va_arg, and va_end) might look like functions, but they actually hide secret instructions that tell the preprocessor how to generate lots of extra smart code inside your program, just before compiling it.

There are no Dumb Questions

Q:	Wait, why are va_end and va_start called macros? Aren’t they just normal functions?
A:	No, they are designed to look like ordinary functions, but they actually are replaced by the preprocessor with other code.
Q:	And the preprocessor is?
A:	The preprocessor runs just before the compilation step. Among other things, the preprocessor includes the headers into the code.
Q:	Can I have a function with just variable arguments, and no fixed arguments at all?
A:	No. You need to have at least one fixed argument in order to pass its name to va_start.
Q:	What happens if I try to read more arguments from va_arg than have been passed in?
A:	Random errors will occur.
Q:	That sounds bad.
A:	Yep, pretty bad.
Q:	What if I try to read an int argument as a double, or something?
A:	Random errors will occur.

Exercise

OK, now it’s over to you. The guys in the Head First Lounge want to create a function that can return the total cost of a round of drinks, like this:

Using the price() from a few pages back, complete the code for total():

double total(int args, ...)
{
  double total = 0;
  ______________________________
  ______________________________
  ______________________________
  ______________________________
  ______________________________
  ______________________________
  ______________________________
  ______________________________
  return total;
}

Exercise Solution

OK, now it’s over to you. The guys in the Head First Lounge want to create a function that can return the total cost of a round of drinks, like this:

Using the price() from a few pages back, you were to complete the code for total():

Test Drive

If you create a little test code to call the function, you can compile it and see what happens:

Your code works!

Now you know how to use variable arguments to make your code simpler and more intuitive to use.

Bullet Points

• Functions that accept a variable number of arguments are called variadic functions.

• To create variadic functions, you need to include the stdarg.h header file.

• The variable arguments will be stored in a va_list.

• You can control the va_list using va_start(), va_arg(), and va_end().

• You will need at least one fixed parameter.

• Be careful that you don’t try to read more parameters than you’ve been given.

• You will always need to know the data type of every parameter you read.

You’ve got Chapter 7 under your belt, and now you’ve added advanced functions to your toolbox. For a complete list of tooltips in the book, see Appendix B.