Note: This is an exported html of the original ODT. The formatting have become mangled and the program coding has gone haywire. All the footnotes have gone to the end of the article so similar symbols clubbed together makes a mess which I won't correct because of lack of time. If possible please download the PDF version for print purposes.

Functions in C

Manik Chand Patnaik (M.Tech.)

Lecturer, (C.S.E), Roland Institute of Technology.

Friday, November 16 – 2006.

We are already well acquainted with the main() the main function of C programs. In this chapter we will build upon our experience with main() to understand the concept of functions as used in C. Though no special reference is required, 'C Programming Tutorial' (K&R version 4) by Mark Burgess a Dabs Press publication and 'C, the Complete Reference' by Herbert Schildt, a McGrawHill publication is recommended for cross-reference.

What is a function?

Function in C is a single task unit. It is a self contained block of code performing some task. A function has a given name which needs to be called to execute the task of the function. A function may take some values for its operation and it may return some value too. When a function does not take or return any value it is called a subroutine. In C however, both subroutines and functions are referred as functions. The scope of auto variables defined inside a function is limited to that function only.

Where to use a function?

Function is used to implement top-down^‡ modular programming technique^§. By creation of functions we do functional partitioning of a program. A big program (monolithic) is broken down to small and manageable modules. This makes a program easy to read, test and debug.

However functions need the CPU Stack for their operation and they put an additional overhead on the CPU. The overhead is called function call overhead. (Minimal understanding required: CPU and Stack operations at a function call^ß).

Function categories

Four Function categories exist depending on arguments and return values.

1. Functions with arguments and return value

   e.g. int main(int argc, char* argv[ ]) int addition(int x, int y)

2. Functions with arguments but no return value

   e.g. void main(int argc, char* argv[ ]) void output(int x, int y)

3. Functions with no arguments and no return values

   e.g. void main(void) can also be void main() void printText(void)

4. Functions with no arguments but with return values

   e.g. int main(void) can also be int main() int getData(void)

Creating a Function

There are two parts in creation of a function; function declaration and function definition.

• Function declaration:-

Generally a function is declared before it is used. The declaration is generally made at the program header. i.e. The top-most part of the program. It is generally written after the pre-processor directives. The declaration can also be written in the calling function. Generally the order in which the functions are called is used in ordering the function declaration. i.e. If function f2() is used after the use of function f1() then f2() will be declared after f1().

The function declaration is also called the function prototype^‡.

<returnType> <functionName>(<argumentList>);

<returnType> is the datatype of the value the function returns.

<functionName> is the name of the function and it follows the Identifier naming rules.

<argumentList> contains the type and sequence of values which the function requires.

e.g. int addition( int, int);

This example function taken above takes two integers as arguments and returns one integer. Keep in mind that a function can-not return more than one value. There may be zero or more than zero arguments but the return can never be greater than a single value.

The function declaration never contains any function code. The semicolon following the function prototype is mandatory.

• Function definition:-

It is the actual function with all the code for the tasks assigned for the functions. Functions can call other functions and how deep the function calls can go is dependent on the type of system you are working on. The function definition must match perfectly with the function declaration (a.k.a. The Function prototype).

<returnType> <functionName>(<argumentList>){

<bodyOfFunction>

}

<bodyOfFunction> It carrys the function code. Those statements which make up the body of the function. If the <returnType> is not void then a return statement is required inside the <bodyOfFunction>.

e.g. int addition(int x,int y){

return(x+y);

}

• Arguments:-

In the above example the addition function takes two integers as parameters/arguments. The syntax can be written in two different methods.

1. As a Function Header (This is the old method. But it is still followed)

Syntax:

<returnType> <functionName>(<datatype1>,<datatype2>, - - - -)

<datatype1><identifier1>;

<datatype2><identifier2>;

<data - - - - ><iden - - - - >;

{

<bodyOfFunction>

}

1. Written in-line Inside the parenthesis. (The new method)

Syntax:

<returnType><functionName>(<datatype1><identifier1>,<dat- - 2><iden - - 2>, - - - )

{

<bodyOfFunction>

}

Both methods are well-supported in all major compilers.

Formal and Actual Arguments

To understand the formal and actual arguments let's take a small and simple program. Arguments are also called as parameters so they can be used interchangeably.

In this tiny program, the arguments (a and b) which are passed on to the function compute by the calling function are called actual arguments. Those arguments used to receive the values in the called function are called formal arguments.

Note: Even if you take a and b in the formal parameters they will be treated differently from the a and b in the calling function. This is because functional partitioning creates functional black boxes^‡.

Note: The type, order and number of actual and formal arguments must match.

Recursion

When a function calls itself it is termed as recursion. Recursion is also called circular definition. A small snippet for getting the factorial of a number would make the concept very clear.

. . .

int main(){

int num;

printf(“Enter a number to get factorial : ”);

scanf(“%d”,&num);

printf(“Factorial of %d is %d ”,num,fact(num));

return 0;

}

int fact(int n){

if(n==1) return 1;

else return(n*fact(n-1)); /*The function is calling itself*/

}

In this example the fact function calls itself. Whenever you use recursion take good care to avoid a black hole (there should be a way to come out of the recursive call stack).

Parameter Passing (by Value and by Reference)

Generally when we pass an argument to a function it passes only the value to the function and a local copy of the variable takes the values and the function acts on those local variables only. According to the black box concept the function cannot see the actual variables of the calling function. However we can explicitly make that happen by passing a value by reference.

• Passing by Value:-

The previous examples of a plus b whole square, the values of a and b are passed on to the function variables x and y. It is very much straight forward for primary data types like int, char and float etc. However you cannot just pass a derived or aggregate data type like this.

• Passing by Reference:-

Passing an array:-

As we know already the array bounds are not checked by C. So we have to make sure that the array bounds are taken care of. When we pass an array as the parameter we should pass the name of the array as well as the size of the array as arguments. An example is here for illustrating the concept.

Line no 16 may be new for you. It shows the exit function returning a failure when the boundary checking of the if statement fails. This will immediately terminate the program and clean the stack. The program flow will not go back to the calling function main().

Let's do some crazy modification to this array value printing program and see the result.

10 valuePrint(arr1,5,num);

11 printf("value of the same now:%d",arr1[num]); <Printing the same element again

12 return 0;

13 }

14

15 void valuePrint(int *ar,int size,int n){ < Look at the star here

16 if(n<size) printf("The element %d is: %d\n",n,ar[n]++); <Value is Changed here ++

17 else exit(EXIT_FAILURE);

18 }

The function here would print a value which is the original value entered while initialization. Then it would increment the value. When the control passes back to the main the value is already changed so the incremented value will be printed.

You may have a question, why the compiler not complained when the prototype and definition of the function mismatched here? Because as we have already discussed, array name is actually a pointer and by passing an array we did not create a local copy of a variable. We actually handled the same array present in the calling function.

To do the same trick with the primary data types involves the use of indirection^‡. A short example would clarify.

Try: Instead of doing this can we change the value of num using increment on n? Try the function snippet here:

14 void changeNum(int *n){

15 int ctr;

16 for(ctr=1;ctr<=5;ctr++) n++;

17 }

This won't change the value of num. Why? A small refresh of the pointer concept is enough. See the foot note^§ if you need further clarification.