Functions

We have already introduced three functions that come with C:

printf()             
fgets()
scanf()

First, if you have a complicated task that must be performed in several places in a program,-- like, say, printing or getting input, your choice is to write the complicted code in the several places, or write the code once in a named function, then name the function in several places in the program. When we use printf, it looks simple, we plug-in an argument and printf prints it on the screen. The details of printf involve making calls to the operating system. Ultimately once printf has made the right system calls, it is the operating system that does the printing. This is hidden away from us. We just call printf.

Second, functions let you think about programs a different way. You can say to yourself, "I've got this problem to solve, if only I could do XXX, then I could use XXX to solve the problem". So the big problem is broken into two parts. Writing a function to do XXX and then using the function to help solve the original problem.

Third, if you are working on a large program with a team of programmers, the large problem can be broken into several pieces. Each piece can be assigned to a small group of programmers. You would be responsible for solving your piece and could work independently of the other groups.

Function Calls

int x=5;
printf("The value of 3 times %d is: %d.\n", x,  3*x);
x = printf("%d\n",12345);
printf("%d\n", printf("%d\n",12345) );

The value of 3 times 5 is 15.

NOTE: printf returns the number of characters in its output.

The third statement above is an assignment statement. The value of the expression on the right will be put into the variable on the left. The expression on the right is a call to function printf. The way a function-expresssion is evaluated is to run the function and see what value it returns. When this call to printf is executed printf prints

12345

The fourth line above has two printf's in it. The outside printf has two arguments in it separated by a comma:

 
"%d\n"
printf("%d\n",12345)

12345

12345
6

Function Definitions

 1. #include<stdio.h>
 2. int triple(int x) {
 3.     return 3*x;
 4. }

 5. void prtTriple(char *s) {
 6.    int i=0;
 7.    while (i<3) {
 8.       printf("%s\n", s);
 9.       i++;
10.     }
11. }

12. int main() {
13.   int age;
14.   printf("Please enter your age\n");
15.   scanf("%d", &age);
16.   printf("%d is triple your age\n", triple(age) );
17.   printf("%d is triple 2+3\n", triple(2+3) );
18.   prtTriple("Goodbye");
19. }

The rest of the function, its body, is the compound statement that comes after the header. The body contains the steps (statements) that will be executed when the function is called. We have one new keyword, return. The keyword return stops the function and returns the value of the expression that comes after it.

Lines 5-11 are the definition of the function prtTriple. The type name void means that prtTriple does not return a value. Notice that its body does not contain a statement of the form:

      return someExpression

     char *s

 8.       printf("%s\n", s);

Function triple is called in the statements 16 and 17 of the body of main. We repeat them below:

  printf("%d is triple your age\n", triple(age) );
  printf("%d is triple 2+3\n", triple(2+3) );

Function prtTriple is called in line 18. The address of G in "Goodbye" is passed to parameter s. Then statements of prtTriple are executed. Three Goodbyes are printed on the screen.

Parameters are the way functions access (use) the values of their arguments. If we want to use the value of the third argument, we use the name of the third parameter which is assigned (passed) the value of the third argument when the function is called. An Example: Function triple returns three times the value of its argument. It accesses the value of its argument in the expression 3*x, because x is the parameter that has been passed the value of the argument. The types of a parameter and its argument must correspond.

Note: The rules for what is a legal function name are the same as the rules (already covered) for what constitutes a legal variable name.

Note: Parameters of a function, and variables declared in the function are local to the function. That is they are private to the function. Other functions and the main program may have variables with the same name as those defined in our function. But C treats them as distinct variables. This is really important with different members of a programming team working independently on different functions.

Function Composition

int triple(int n) {
    return 3*n;
}

int sum(int n) {
    int s = 0;
    int i=1;
    while (i<=n) {
        s = s+i;
        i = i+1;
    }
    return s;
}

int main() {
  printf("Please enter a number\n");
  int y;
  scanf("%d", &y);
  print("%d is the sum of the numbers from 1 to %d\n", sum(y), y);
  print("%d is triple the sum of the numbers from 1 to %d\n", triple(sum(y)), y);
}

Function sum has one parameter and two variables of its own. In the last line of the main program, sum is plugged in, inside function triple, which is plugged inside of function printf. So function sum will be run first. The value returned by sum is plugged into function triple. Then function triple is run, and the value it returns is plugged into function printf.

Functions calling Functions

int sum(int n);            //function headers required when compiler gets to
int triple(int n);         //tripleSum; needs 

int tripleSum(int y) {      //compiler chks is plug-in to sum right type?
    return triple(sum(y));  //chks is plug-in to triple right type?
}                           //chks is does return type of triple match
                            //match return type of tripleSum
int triple(int n) {
    return 3*n;
}

int sum(int n) {
    int s = 0;
    int i = 1;
    while (i<=n) {
        s = s + i;
        i = i + 1;
    }
    return s;
}

int main() {
  printf("%d\n", tripleSum(3) );
}

Functions sum and triple are used in the definition of tripleSum, so when the compiler gets to the body of tripleSum it needs to make sure that sum and triple are being used correctly. It will check that the type of the plug-in to sum matches the type of the parameter of sum. And that the type of the plug-in to triple (namely the return type of sum) matches the type of the parameter of triple. Finally that the value returned by triple matches the return type of tripleSum.

In this example we could have avoided use of the headers by putting the whole definitions of sum and triple before the definition of tripleSum.

Let's go back to the concept of working on a programming team. Say we are working on the complicated function tripleSum and others are working on triple and sum. All we need to know about what the others are doing are the plug-in and return types of the two functions. That is exactly the information contained in the headers:

int sum(int n); 
int triple(int n);

int sum(int n);          
int triple(int n);      

int tripleSum(int y) {    
    return triple(sum(y)); 
}                         

gcc -c  ts.c

gcc ts.o triple.o sum.o main.o

Next: Program Structure