Functions

Function Definitions

• A function definition follows this general form:
  datatype
  name(parameter-list)
  {
  body
  }
  
  • datatype is any valid datatype
  • datatype can also be void, which means the function does not return a value
  • parameter-list is a list of one or more declarations of variables used to hold the values passed to this function
  • If the parameter-list is set to void, the function takes no parameters
• As an example, a simple function definition could look like:

  int
  add(int a, int b)
  {
  	return a + b;
  }
  

  • Pre-ANSI C functions must list the parameters without datatypes inside the parentheses, then declare the same parameters with datatypes (though in a possibly different order) immediately after the parentheses like:

    int
    add(a, b);
    int a, b;
    {
    	return a + b;
    }
    

• datatype and parameter-list are optional, (though strongly recommended)
  • If datatype is not specified, it is assumed that the function returns int
  • If no parameter-list is specified, it is assumed that the function takes no parameters
  • The smallest possible function definition is therefore a(){}, which is the same as the somewhat more explicit:

    int
    a(void)
    {
    }
    

    though, since it doesn't return a value, it would be better defined as:

    void
    a(void)
    {
    }
    

• Functions may not be defined inside other functions (as can be done in Pascal)
• Functions may call themselves, as in:

  int
  factorial(int n)
  {
  	if (n <= 1)
  		return 1;
  	else
  		return n * factorial(n - 1);
  }
  

Returning a Value

• The return statement exits the current function
• return may also be given an expression whose value is used as the value returned to the caller
  • The returned expression will be converted to match the specified return type for the function

Function Declaration

• Functions are typically declared before being defined, using a function prototype
• A function prototype tells the compiler the datatype of the return value and the number and datatypes of any values passed to the function, allowing it to automatically convert to the appropriate value when necessary
• A function prototype is nearly identical to a function definition without the body
  • The general form of a function prototype is:
    datatype name(parameter-list);
• A prototype for the add() function would look like:
  int add(int a, int b);
• The parameter list for a function prototype only needs to contain the datatypes, not the identifiers
  • The add() function could have been written as
    int add(int, int);
  The identifiers are usually left in since (if well-named) they provide a concise summary of the function
• The prototype need not contain parameter-list
  • If this is true, nothing is assumed about the parameters
  • The compiler will not, however, be able to automatically convert to the datatype expected by a function:
    • For example, if you define a function like double dfunc(double d); and, in another file, you do i = dfunc(3); (where i is an int variable and 3 is an int constant), the compiler will not know that 3 should be passed as a double, so it will not do the conversion and dfunc will not operate as expected
• If no prototype (or definition) is found before the first use of a function, a prototype of
  int name(); is assumed
• Prototypes are usually placed in a header file and #included in every file where the function is called

Parameters Passed By Value

• Unless otherwise specified, parameters are passed by value
• Given this function definition:

  void
  subfunc(int a)
  {
  	a = 3;
  }
  
  void
  func(void)
  {
  	int a, b;
  
  	a = 0;
  	subfunc(a);
  	b = a;
  }
  

  the b variable in func() would be set to 0, not 3, since subfunc() operates on a copy of the value of a, not the actual variable
• There is a way of having functions operate on the actual variable; this will be discussed later