Function Calls
The latest version of this topic can be found at Function Calls.
A function call is an expression that passes control and arguments (if any) to a function and has the form:
expression (expression-listopt)
where expression is a function name or evaluates to a function address and expression-list is a list of expressions (separated by commas). The values of these latter expressions are the arguments passed to the function. If the function does not return a value, then you declare it to be a function that returns void.
If a declaration exists before the function call, but no information is given concerning the parameters, any undeclared arguments simply undergo the usual arithmetic conversions.
Note
The expressions in the function argument list can be evaluated in any order, so arguments whose values may be changed by side effects from another argument have undefined values. The sequence point defined by the function-call operator guarantees only that all side effects in the argument list are evaluated before control passes to the called function. (Note that the order in which arguments are pushed on the stack is a separate matter.) See Sequence Points for more information.
The only requirement in any function call is that the expression before the parentheses must evaluate to a function address. This means that a function can be called through any function-pointer expression.
Example
This example illustrates function calls called from a switch statement:
int main()
{
/* Function prototypes */
long lift( int ), step( int ), drop( int );
void work( int number, long (*function)(int i) );
int select, count;
.
.
.
select = 1;
switch( select )
{
case 1: work( count, lift );
break;
case 2: work( count, step );
break;
case 3: work( count, drop );
/* Fall through to next case */
default:
break;
}
}
/* Function definition */
void work( int number, long (*function)(int i) )
{
int i;
long j;
for ( i = j = 0; i < number; i++ )
j += ( *function )( i );
}
In this example, the function call in main,
work( count, lift );
passes an integer variable, count, and the address of the function lift to the function work. Note that the function address is passed simply by giving the function identifier, since a function identifier evaluates to a pointer expression. To use a function identifier in this way, the function must be declared or defined before the identifier is used; otherwise, the identifier is not recognized. In this case, a prototype for work is given at the beginning of the main function.
The parameter function in work is declared to be a pointer to a function taking one int argument and returning a long value. The parentheses around the parameter name are required; without them, the declaration would specify a function returning a pointer to a long value.
The function work calls the selected function from inside the for loop by using the following function call:
( *function )( i );
One argument, i, is passed to the called function.