Function Definitions

Syntax

function-definition ::=
[declaration-specifiers] declarator [declaration-list] compound-statement

Description

A function definition provides the following information about the function:

Do not confuse definition with declaration, especially in the case of functions. Function definition implies that the above four pieces of information are supplied. Function declaration implies that the function is defined elsewhere.

You can declare formal parameters as structures or unions. When the function is called, the calling function's argument is copied to temporary locations within the called function.

All functions in C may be recursive. They may be directly recursive so the function calls itself or they may be indirectly recursive so a function calls one or more functions which then call the original function. Indirect recursion can extend through any number of layers.

In function definitions that do not use prototypes, any parameters of type float are actually passed as double, even though they are seen by the body of the function as floats. When such a function is called with a float argument, the float is converted back to float on entry into the function.

	NOTE: In compatibility mode, the type of the parameter is silently changed to double, so the reverse conversion does not take place.

In a prototype-style definition, such conversions do not take place, and the float is both passed and accessed in the body as a float.

char and short parameters to nonprototype-style function definitions are always converted to type int. This conversion does not take place in prototype-style definitions.

In either case, arrays of type T are always adjusted to pointer to type T, and functions are adjusted to pointers to functions.

Single dimensioned arrays declared as formal parameters need not have their size specified. If the name of an integer array is x, the declaration is as follows:

int x[ ];

For multidimensional arrays, each dimension must be indicated by a pair of brackets. The size of the first dimension may be left unspecified.

The storage class of formal parameters is implicitly “function parameter.” A further storage class of register is accepted.

Examples

The following example shows a function that returns the sum of an array of integers.

int total(data, n) /* function type, name, formal list */
int data[ ]; /* parameter declarations */
int n;
{
auto int sum = 0; /* local, initialized */
auto int i; /* loop variable */

for(i=0; i<n; ++i) /* range over all elements */
sum += data[i]; /* total the data array */
return sum; /* return the value */
}

This is an example of a function definition without prototypes.

int func1 (p1, p2) /* old-style function definition */
int p1, p2; /* parameter declarations */
{ /* function body starts */
int l1; /* local variables */
11 = p1 + p2;
return l1;
}

Here is an example of a function definition using prototypes.

char *func2 (void) /* new-style definition */
/* takes no parameters */
{
/* body */
}

int func3 (int p1, char *p2, ...)/* two declared parameters:
p1 & p2 */
/* "..." specifies more,
undeclared parameters
of unspecified type */
{
/* body */ /* to access undeclared
parameters here, use the
functions declared in the
<stdarg.h> header file. */
}

inline

HP C supports inlining frequently used functions. These functions can be inlined by specifying them as inline either in the function declarator or in the function definition.

	NOTE: inline is available only wit h-AC99. For all other options, you must use __inline.

The optimizer uses its own heuristics to inline a function, if necessary.

Examples

The following examples detail the usage of inline.

Example 3-10 Using inline in Function Declaration

inline void foo(int);     //Function declaration with inline specifier    main()    {       foo(5);    }    void foo(int x)    {       . . .    }

Example 3-11 Using inline in Function Definition

main()    {       foo(5);    }    inline foo(int x0)      // Function definition with inline specifier    {       . . .    }