Function

• Functions are central to C (and other) programming.
  • A function is an independent section of code, which performs a specific task.

  • Increase the redability of code.

  • Easier to debug.

    By breaking large computing tasks into smaller ones, you can debug the each component (more manageable).

  • With a good design, functions are reusable.

    e.g., You have already used useful functions, such as printf(), drand48(). These functions are included in libraries, and reusable. You can also make your reusable functions by yourself.

• Example:

  #include <stdio.h>
  
  /* function prototype */
  int Power(int x, int y);
  
  int main (void) {
    int i, answer;
    
    for (i = 0; i < 32; i++) {
      answer = Power(2, i);
      printf("%d -th power of 2 = %d\n", i, answer);
    }
  
    return 0;
  }
  
  /* function definition */
  
  /*
   * raise base to the n-th power, n >= 0
   */
  int Power (int base, int n) {
    int i, result;
    
    result = 1;
    for (i = 0; i < n; i++) {
      result = result * base;
    }
  
    return result;
  }
  

  Copy /home/progClass/src/logistic/power.c to your home directory, compile and run it, and see the results.

• Function prototype

  return_type function_name( arg_type name1,...,arg_type nameN);

  • This provides the compiler with the description of a function, which will be defined later. Header files (e.g. stdio.h) contain function prototypes.

  • Note that function prototype is identical to the 1st line of function definition.

  • The variable names are optional in function prototype and will be ignored. You could use different names in the function prototype and definition.

    e.g., all of the followings can be substitued in the above code.

    int Power(int, int);
    int Power(int dummy1, int dummy2);
    

  • Function prototype is generally placed before the start of main().

• Function definition

  The function definition contains the code which will be executed.

  return_type function_name(arg_type name1, ..., arg_type nameN)
  {
      /* declaration of variables used in the function */
      /* statements; */
      /* return variable */ }

• How a function works.
  • The statements inside of a function is not executed until the function is called.
  • After the function call, the program can pass arguments.
  • The statements will be executed, and the value specified by return statment will be passed back to the place where it was called.
  • Arguments are not required. In this case use void for the function definition and protoype.

    #include <stdlib.h>
    
    double NegRand(void);
    
    int main (void) {
      double x;
      srand48(20303);
    
      x = NegRand();
    
      printf("%f\n", x);
      return 0;
    }
    
    double NegRand(void) {
      double retVal = -drand48();
    
      return retVal;
    }
    

  • To call a function with no argument (void), you still need the opening and closing parentheses. (e.g. x=NegRand();).

• Values returned
  • Make sure that the correct type is returned.
  • A function can have multiple return statements (i.e. multiple exit points).

    int CoinFlip (void) {
      if (drand48() < 0.5) {
        return 1;  /* head */
      } else {
        return 0;  /* tail */
      }
    }
    

  • A function does not need to return a value. In this case, you can use void as the return_type.

    void JustPrintNewline (void) {
      printf ("\n");
      return;
    }
    

  • Can a function return more than one value?
    Yes, but need different methods (which will be covered later).

• Statements inside of functions.
  • You can use ANY statements inside of functions. You can also call other functions from inside of a function.

    int SomeFunction (int x, int y) {
      int sum, result;
      sum = x + y;
    
      result = AnotherFunction(sum);
      return (result);
    }
    
    int AnotherFunction (int z) {
      return z * z;
    }
    

  • But you cannot include another function definition inside of a function.

    int SomeFunction (int x, int y) {
      int sum, result;
      sum = x + y;
    
      int AnotherFunction (int z) {
        return z * z;
      }
    
      result = AnotherFunction(sum);
      return (result);
    }
    

• Names of functions

  The naming rules for variables apply.

• Exercises:

  Make a function which takes 2 integers as the arguments, and return the larger integer.