C Functions

Functions are central to C programming and to the philosophy of C program design. You've already been introduced to some of C's library functions, which are complete functions supplied as part of your compiler. This chapter covers user-defined functions, which, as the name implies, are functions that you, the programmer, create. Today you will learn

  • What a function is and what its parts are
  • About the advantages of structured programming with functions
  • How to create a function
  • How to declare local variables in a function
  • How to return a value from a function to the program
  • How to pass arguments to a function

What Is a Function?

This chapter approaches the question "What is a function?" in two ways. First, it tells you what functions are, and then it shows you how they're used.

A Function Defined

First the definition: A function is a named, independent section of C code that performs a specific task and optionally returns a value to the calling program. Now let's look at the parts of this definition:

  • A function is named. Each function has a unique name. By using that name in another part of the program, you can execute the statements contained in the function. This is known as calling the function. A function can be called from within another function.
  • A function is independent. A function can perform its task without interference from or interfering with other parts of the program.
  • A function performs a specific task. This is the easy part of the definition. A task is a discrete job that your program must perform as part of its overall operation, such as sending a line of text to a printer, sorting an array into numerical order, or calculating a cube root.
  • A function can return a value to the calling program. When your program calls a function, the statements it contains are executed. If you want them to, these statements can pass information back to the calling program.

That's all there is to the "telling" part. Keep the previous definition in mind as you look at the next section.

How a Function Works

A C program doesn't execute the statements in a function until the function is called by another part of the program. When a function is called, the program can send the function information in the form of one or more arguments. An argument is program data needed by the function to perform its task. The statements in the function then execute, performing whatever task each was designed to do. When the function's statements have finished, execution passes back to the same location in the program that called the function. Functions can send information back to the program in the form of a return value.

Function Prototype

return_type function_name(arg-type name-1,...,arg-type name-n);

Function Definition

return_type function_name(arg-type name-1,...,arg-type name-n)
{
/*statements; */
}

function prototype provides the compiler with a description of a function that will be defined at a later point in the program. The prototype includes a return type indicating the type of variable that the function will return. It also includes the function name, which should describe what the function does. The prototype also contains the variable types of the arguments (arg type) that will be passed to the function. Optionally, it can contain the names of the variables that will be passed. A prototype should always end with a semicolon.

function definition is the actual function. The definition contains the code that will be executed. The first line of a function definition, called the function header, should be identical to the function prototype, with the exception of the semicolon. A function header shouldn't end with a semicolon. In addition, although the argument variable names were optional in the prototype, they must be included in the function header. Following the header is the function body, containing the statements that the function will perform. The function body should start with an opening bracket and end with a closing bracket. If the function return type is anything other than void, a return statement should be included, returning a value matching the return type.

Function Prototype Examples

void Helloworld();
void print_report( int report_number );
Function Definition Examples

void Helloworld()/* function header */
{/* opening bracket */
printf(?This is my First Function?):/* function body*/
}/* closing bracket */

void print_report( int report_number )
{
if( report_number == 1 )
printf( "Printing Report 1" );
else
printf( "Not printing Report 1" );
}

Writing a Function

The first step in writing a function is knowing what you want the function to do. Once you know that, the actual mechanics of writing the function aren't particularly difficult.

The Function Header

The first line of every function is the function header, which has three components, each serving a specific function.

The Function Return Type

The function return type specifies the data type that the function returns to the calling program. The return type can be any of C's data types: char, int, long, float, or double. You can also define a function that doesn't return a value by using a return type of void. Here are some examples:

intfunc1(...)/* Returns a type int.*/

floatfunc2(...)/* Returns a type float. */

voidfunc3(...)/* Returns nothing.*/

The Function Name

You can name a function anything you like, as long as you follow the rules for C variable names (given in Day 3, "Storing Data: Variables and Constants"). A function name must be unique (not assigned to any other function or variable). It's a good idea to assign a name that reflects what the function does.

The Parameter List

Many functions use arguments, which are values passed to the function when it's called. A function needs to know what kinds of arguments to expect--the data type of each argument. You can pass a function any of C's data types. Argument type information is provided in the function header by the parameter list.

For each argument that is passed to the function, the parameter list must contain one entry. This entry specifies the data type and the name of the parameter. For example, here's the header from the function in Listing 5.1:

long cube(long x)

The parameter list consists of long x, specifying that this function takes one type long argument, represented by the parameter x. If there is more than one parameter, each must be separated by a comma. The function header

voidfunc1(int x, float y, char z)

specifies a function with three arguments: a type int named x, a type float named y, and a type char named z. Some functions take no arguments, in which case the parameter list should consist of void, like this:

voidfunc2(void)

NOTE: You do not place a semicolon at the end of a function header. If you mistakenly include one, the compiler will generate an error message.


Sometimes confusion arises about the distinction between a parameter and an argument. A parameter is an entry in a function header; it serves as a "placeholder" for an argument. A function's parameters are fixed; they do not change during program execution.

An argument is an actual value passed to the function by the calling program. Each time a function is called, it can be passed different arguments. In C, a function must be passed the same number and type of arguments each time it's called, but the argument values can be different. In the function, the argument is accessed by using the corresponding parameter name.

An example will make this clearer. These program presents a very simple program with one function that is called twice.

Example : The difference between arguments and parameters.

1:/* Illustrates the difference between arguments and parameters. */
2:
3:#include <stdio.h>
4:
5:float x = 3.5, y = 65.11, z;
6:
7:float half_of(float k);
8:
9:main()
10:{
11:/* In this call, x is the argument to half_of(). */
12:z = half_of(x);
13:printf("The value of z = %f\n", z);
14:
15:/* In this call, y is the argument to half_of(). */
16:z = half_of(y);
17:printf("The value of z = %f\n", z);
18:
19:return 0;
20:}
21:
22:float half_of(float k)
23:{
24:/* k is the parameter. Each time half_of() is called, */
25:/* k has the value that was passed as an argument. */
26:
27:return (k/2);
28:}

The value of z = 1.750000

The value of z = 32.555000

ANALYSIS:

Looking an Example, you can see that the half_of() function prototype is declared on line 7. Lines 12 and 16 call half_of(), and lines 22 through 28 contain the actual function. Lines 12 and 16 each send a different argument to half_of(). Line 12 sends x, which contains a value of 3.5, and line 16 sends y, which contains a value of 65.11. When the program runs, it prints the correct number for each. The values in x and y are passed into the argument k of half_of(). This is like copying the values from x to k, and then from y to k. half_of() then returns this value after dividing it by 2 (line 27).

The Function Body

The function body is enclosed in braces, and it immediately follows the function header. It's here that the real work is done. When a function is called, execution begins at the start of the function body and terminates (returns to the calling program) when a return statement is encountered or when execution reaches the closing brace.

Local Variables

You can declare variables within the body of a function. Variables declared in a function are called local variables. The term local means that the variables are private to that particular function and are distinct from other variables of the same name declared elsewhere in the program. This will be explained shortly; for now, you should learn how to declare local variables.

A local variable is declared like any other variable, using the same variable types and rules for names that you learned on Day 3. Local variables can also be initialized when they are declared. You can declare any of C's variable types in a function. Here is an example of four local variables being declared within a function:

int func1(int y)
{
int a, b = 10;
float rate;
double cost = 12.55;
/* function code goes here... */
}

The preceding declarations create the local variables a, b, rate, and cost, which can be used by the code in the function. Note that the function parameters are considered to be variable declarations, so the variables, if any, in the function's parameter list also are available.

When you declare and use a variable in a function, it is totally separate and distinct from any other variables that are declared elsewhere in the program. This is true even if the variables have the same name. These programs demonstrates this independence.

Example : A demonstration of local variables

1:/* Demonstrates local variables. */
2:
3:#include <stdio.h>
4:
5:int x = 1, y = 2;
6:
7:void demo(void);
8:
9:main()
10:{
11:printf("\nBefore calling demo(), x = %d and y = %d.", x, y);
12:demo();
13:printf("\nAfter calling demo(), x = %d and y = %d\n.", x, y);
14:
15:return 0;
16:}
17:
18:void demo(void)
19:{
20:/* Declare and initialize two local variables. */
21:
22:int x = 88, y = 99;
23:
24:/* Display their values. */
25:
26:printf("\nWithin demo(), x = %d and y = %d.", x, y);
27:}

Before calling demo(), x = 1 and y = 2.

Within demo(), x = 88 and y = 99.

After calling demo(), x = 1 and y = 2.

ANALYSIS:

Program is similar to the previous programs in this chapter. Line 5 declares variables x and y. These are declared outside of any functions and therefore are considered global. Line 7 contains the prototype for our demonstration function, named demo(). It doesn't take any parameters, so it has void in the prototype. It also doesn't return any values, giving it a type of void. Line 9 starts our main() function, which is very simple. First, printf() is called on line 11 to display the values of x and y, and then the demo() function is called. Notice that demo() declares its own local versions of x and y on line 22. Line 26 shows that the local variables take precedence over any others. After the demo function is called, line 13 again prints the values of x and y. Because you are no longer in demo(), the original global values are printed.

As you can see, local variables x and y in the function are totally independent from the global variables x and y declared outside the function. Three rules govern the use of variables in functions:

  • To use a variable in a function, you must declare it in the function header or the function body (except for global variables, which are covered on Day 12.
  • In order for a function to obtain a value from the calling program, the value must be passed as an argument.
  • In order for a calling program to obtain a value from a function, the value must be explicitly returned from the function.

To be honest, these "rules" are not strictly applied, because you'll learn how to get around them later in this book. However, follow these rules for now, and you should stay out of trouble.

Keeping the function's variables separate from other program variables is one way in which functions are independent. A function can perform any sort of data manipulation you want, using its own set of local variables. There's no worry that these manipulations will have an unintended effect on another part of the program.

Function Statements

There is essentially no limitation on the statements that can be included within a function. The only thing you can't do inside a function is define another function. You can, however, use all other C statements, including loops (these are covered on Day 6, "Basic Program Control"), if statements, and assignment statements. You can call library functions and other user-defined functions.

What about function length? C places no length restriction on functions, but as a matter of practicality, you should keep your functions relatively short. Remember that in structured programming, each function is supposed to perform a relatively simple task. If you find that a function is getting long, perhaps you're trying to perform a task too complex for one function alone. It probably can be broken into two or more smaller functions.

How long is too long? There's no definite answer to that question, but in practical experience it's rare to find a function longer than 25 or 30 lines of code. You have to use your own judgment. Some programming tasks require longer functions, whereas many functions are only a few lines long. As you gain programming experience, you will become more adept at determining what should and shouldn't be broken into smaller functions.

Returning a Value

To return a value from a function, you use the return keyword, followed by a C expression. When execution reaches a return statement, the expression is evaluated, and execution passes the value back to the calling program. The return value of the function is the value of the expression. Consider this function:

intfunc1(int var)
{
int x;
/* Function code goes here... */
return x;
}

When this function is called, the statements in the function body execute up to the return statement. The return terminates the function and returns the value of x to the calling program. The expression that follows the return keyword can be any valid C expression.

A function can contain multiple return statements. The first return executed is the only one that has any effect. Multiple return statements can be an efficient way to return different values from a function, as demonstrated in their example.

Example : Using multiple return statements in a function.

1:/* Demonstrates using multiple return statements in a function. */
2:
3:#include <stdio.h>
4:
5:int x, y, z;
6:
7:int larger_of( int , int );
8:
9:main()
10:{
11:puts("Enter two different integer values: ");
12:scanf("%d%d", &x, &y);
13:
14:z = larger_of(x,y);
15:
16:printf("\nThe larger value is %d.", z);
17:
18:return 0;
19:}
20:
21:int larger_of( int a, int b)
22:{
23:if (a > b)
24:return a;
25:else
26:return b;
27:}

Enter two different integer values:
200300
The larger value is 300.

Enter two different integer values:
300
200
The larger value is 300.

ANALLYSIS:

As in other examples, Program with a comment to describe what the program does (line 1). The STDIO.H header file is included for the standard input/output functions that allow the program to display information to the screen and get user input. Line 7 is the function prototype for larger_of(). Notice that it takes two int variables for parameters and returns an int. Line 14 calls larger_of() with x and y. The function larger_of() contains the multiple return statements. Using an if statement, the function checks to see whether a is bigger than b on line 23. If it is, line 24 executes a return statement, and the function immediately ends. Lines 25 and 26 are ignored in this case. If a isn't bigger than b, line 24 is skipped, the else clause is instigated, and the return on line 26 executes. You should be able to see that, depending on the arguments passed to the function larger_of(), either the first or the second return statement is executed, and the appropriate value is passed back to the calling function.

One final note on this program. Line 11 is a new function that you haven't seen before. puts()--meaning put string--is a simple function that displays a string to the standard output, usually the computer screen. (Strings are covered on Day 10, "Characters and Strings." For now, know that they are just quoted text.)

Remember that a function's return value has a type that is specified in the function header and function prototype. The value returned by the function must be of the same type, or the compiler generates an error message.

Top Pages