C Function
A function is a group of statements that together perform a task. Every C program has at least one function, which is main(), and even the simplest program can define additional functions.
You can divide your code into separate functions. How you divide your code among different functions is up to you, but logically, the division is usually such that each function performs a specific task.
A function declaration tells the compiler about a function's name, return type, and parameters. A function definition provides the actual body of the function.
The C standard library provides numerous built-in functions that your program can call. For example, strcat() to concatenate two strings, and memcpy() to copy one memory location to another.
Functions are also known as methods, subroutines, or procedures, among other terms.
Defining a Function
The general form of a function definition in C is as follows:
return_type function_name( parameter list )
{
body of the function
}
A function in C consists of a function header and a function body. Here are all the parts of a function:
Return Type: A function can return a value. The returntype is the data type of the value the function returns. Some functions perform the desired operations without returning a value, in which case the returntype is the keyword void.
Function Name: This is the actual name of the function. The function name and the parameter list together constitute the function signature.
Parameters: Parameters act as placeholders. When a function is invoked, you pass a value to the parameter, which is called an actual parameter. The parameter list refers to the type, order, and number of the function's parameters. Parameters are optional; that is, a function may contain no parameters.
Function Body: The function body contains a collection of statements that define what the function does.
Example
Here is the source code for the max() function. This function takes two parameters, num1 and num2, and returns the larger of the two:
/* Function to return the maximum of two numbers */
int max(int num1, int num2)
{
/* Local variable declaration */
int result;
if (num1 > num2) {
result = num1;
} else {
result = num2;
}
return result;
}
Function Declaration
A function declaration tells the compiler about a function's name and how to call the function. The actual body of the function can be defined separately.
The function declaration includes the following parts:
return_type function_name( parameter list );
For the max() function defined above, here is the function declaration:
int max(int num1, int num2);
In the function declaration, the names of the parameters are not important, only their types are required, so the following is also a valid declaration:
int max(int, int);
Function declarations are required when you define a function in one source file and you call that function in another file. In such cases, you should declare the function at the top of the file calling the function.
Calling a Function
When creating a C function, you define what the function does, and then call it to perform the defined task.
When the program calls a function, control is transferred to the called function. The called function performs the defined task, and when its return statement is executed or it reaches the end of the function, control is passed back to the main program.
To call a function, you simply need to pass the required parameters along with the function name, and if the function returns a value, you can store the returned value. For example:
Example
#include <stdio.h>
/* Function declaration */
int max(int num1, int num2);
int main ()
{
/* Local variable definition */
int a = 100;
int b = 200;
int ret;
/* Calling a function to get the maximum value */
ret = max(a, b);
printf( "Max value is : %d\n", ret );
return 0;
}
/* Function returning the max between two numbers */
int max(int num1, int num2)
{
/* Local variable declaration */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
Putting the max() function and the main() function together, compile the source code. When running the final executable, it produces the following result:
Max value is : 200
Function Parameters
If a function is to use parameters, it must declare variables that accept the values of the parameters. These variables are known as the formal parameters of the function.
Formal parameters are treated as local variables within the function and are created upon entry into the function and destroyed upon exit.
When calling a function, there are two ways that parameters can be passed to the function:
| Call Type | Description |
|---|---|
| Call by Value | This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument. |
| Call by Reference | This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means changes made to the parameter affect the argument. |
By default, C uses call by value to pass parameters. This generally means that code within a function cannot alter the arguments used to call the function.