Program Structure

• In C it is important to differentiate between a definition and a declaration. A declaration gives information about something (data type, storage class, variable/function/etc), while a definition reserves space/generates code. A definition also serves as a declaration.

• Identifiers and Keywords
  • Identifiers are made up of alphanumeric and underscore.
  • Traditionally variables are lower case and constants upper case. Don't begin names with underscore, as this often used for libary routines and may clash.
  • Keywords cannot be used.

    auto       break      case       char       const      continue
    default    do         double     else       enum       extern     
    float      for        goto       if         int        long       
    register   return     short      signed     sizeof     static 
    struct     switch     typedef    union      unsigned   void
    volatile   while
              

• The basics.
  • Functions should be declared before use. The declaration provides information about the arguments and return type, thus allowing better compiler checking, argument type checking, etc.
    • ProgramStructure2.c - Fahrenheit to celcius, using definitions
    • ProgramStructure.c - Fahrenheit to celcius, using declarations
    • ProgramStructure3.c - Fahrenheit to celcius, includeing ProgramStructure3.h and compiling ProgramStructure3Functions.c
  • A prototype declaration

    <function type> <name>(<argument declarations>);
    

    • The function type is void if it does not return a value.
    • The argument declarations are
      • void if there are no arguments,
      • A list of comma separated <type> [<formal name>] declarations.
    • The argument names are optional in a declaration, and are not used except for the issue of warning messages.
    • Prototypes.c - Fahrenheit to celcius, using functions
    • Each argument is declared seperately, not as for local variable definitions.
  • A function definition

    <function type> <name>(<argument declarations>) {
         <local variable definitions>
         <statements>
         [return[(<return value>)]]
    }
              

    • The definition of a function that has been declared, must match exactly on type, name, number of arguments, argument names if given, and argument type.
    • The argument names are not optional here.
  • Returning
    • Functions can exit at any point via a return statement. Functions can have multiple return statements.
    • Functions whose type is void can exit via a return statement with no <return value>. Such functions can also fall of the end.
    • Functions whose type is not void, must return a value via a return(<expression>) statement. The return value need not be in ()s. The expression will be converted to the appropriate type, as per the type conversion rules (see later).
    • The call to a function may ignore the returned value.
  • Functions may not be nested.
  • Functions can be used recursively.
  • If a function is not declared before its use, it is given a default declaration of int <name>(void). It is much better to always be explicit.

• Arguments
  • Actual arguments are converted to their formal types, according to conversion rules.
  • A call to a function of 0 arguments must have ()s.
  • Array names represent the address of the first element thus an array is passed by reference. All other types are passed by value.
  • Passing non-arrays by reference
    • Swap.c - Program using pointers for pass by reference
    • Their address must be passed to the function and indirection used to access the variable in the function.
    • & indicates the address of the name.
    • * indicates the contents of the address in the name.
    • Notice the argument declaration that says This and WithThis point to ints.
  • A variable number of arguments may be passed to a function.
    • Use the ... argument as the last formal argument, e.g. int printf(char *format,...)
    • There must be at least one named argument.
    • Declared in <stdarg.h> are the type va_list and the functions va_start, va_arg, and va_end, which are used to access the variable number of arguments.
      • A variable of type va_list is a pointer to the next argument.
      • va_start is a procedure that initialises such a variable.
      • va_arg returns the value of each successive argument, and updates the variable.
      • va_end cleans up afterwards.
  • PrintNumbers.c - Program that prints any number of integers and doubles

Exercises

• Write int strindex(char s1[],char c1) which returns the index of the first occurrence of c1 in s1, or -1 if c1 does not occur in s1.

Exam Style Questions

• What is the difference between a declaration and a definition of a variable or function?
• Give the syntax for a function {declaration|definition}.
• How are arrays treated differently from other variables when passed as arguments to functions?
• What effect does the const qualifier have when applied to a function argument?