Programming in C

Lecture Outline

Aims and Objectives
Splitting programs across files
Scope Rules in C
Using Header Files
Recursion
The C Preprocessor
Macro Substitution

• Multi-file Programs

• Scope rules

• Recursion

• The C Preprocessor

• You may have a file containing a large program with several functions that is becoming too big to manage

• Or, you may want to write library functions, user-defined functions that are useful and are to be shared by many different programs

• gcc doesn't just compile C programs. It also `loads' them, and prepares them for execution

• You can compile more than 1 program at a time using gcc
  gcc p1.c p2.c p3.c

• C then creates an a.out file (by default) which contains executable code for all programs input as parameters to gcc

• We are going to see how to share the functions, and variables used in the different files, and also how to protect variables used by functions in one file from functions in other files

• We are also going to see what Header files do

• The Scope Rules describe how and when variables and functions can be referenced

  int a = 2; /* global */
  
  double foo(double x, int y)
  {
  	extern int a;
  	int w = 34; /* local */
  
  	return (double) ((x * w) + (y * w)) * a;
  }
  

• What is the scope of an extern if the program is written in multiple files?

• If you want an extern to be globally available to only the functions in the same file, then use static in the declaration of the variable.

  static int a = 2;

• You can use header files (*.h) to declare and define variables and function prototypes that are going to be used in more than one program, to reduce the risk of error, and also so that you don't have to worry about how vars/functions should be declared and defined.

  // Header file name = num.h
  #define THESTRING "hello, world\n"
  
  int binsearch(int x, int v[], int n);
  
  int getnum(int v[], int max);
  

• Save this in a file with a .h extension, and #include it in each program file that needs access to these definitions (e.g., as with <stdio.h>)

• However, do not use < and >, use double quotes

• The < and > around a file to be included tells C to look in a special directory

• The double quotes tells C that the file can be found in the same directory containing the source file, otherwise include the included file's full pathname

  #include "num.h"

• Let's split up the number searching program up into 3 files, using num.h as the header file - what changes must be made?

• p1.c will contain main()

• p2.c will contain getnum() and isnum() (isdigit() re-written)

• p3.c will contain binsearch()

  /* p1.c */
  
  #include <stdio.h> 
  #include "num.h"
  
  main()
  {
  	
  	int v[20];
  	int n, i;
  	int x = 5;
  	
  	printf(THESTRING);
  		
  	for (i = 0; i < 20; v[i++] = 0)
  	;
  	n = getnum(v, 20);
  
  	printf("%d is in array cell %d\n", x, binsearch(x, v, n));
  }
  

• The differences are
  • inclusion of num.h
    
  • removal of prototypes
    
  • printf(THESTRING)
    

  /* p2.c */
  
  #include <stdio.h>
  
  static const int NUM=1;
  static const int ALPHA=0;
  
  static int isnum(int c);
  
  int getnum(int v[], int max)
  {
  	int c, i;
  	
  	for (i = 0; i < max && (c = getchar()) != EOF;)
  		if (c == '\n') {
  		 	++i;
  		}
  		
  		else if (! (isnum(c))) {
  			printf("Input contains non-integer\n");
  			v[i] = 0;
  			while ((c = getchar()) != '\n' && c != EOF)
  			;
  		}
  		else {
  			v[i] = (v[i] * 10) + (c - '0');
  		}	
  	return i;
  }
  
  int isnum(int c)
  {
  	extern int NUM;
  	extern int ALPHA;
  
  	if (c >= '0' && c <= '9')
  		return NUM;
  	else
  		return ALPHA;
  }
  

• Differences are
  • <stdio.h> included
    
  • NUM & ALPHA as static constants
    
  • Static prototype declaration
    

  /* p3.c */
  
  int binsearch(int x, int v[], int n)
  {
  	int low, high, mid;
  
  	low = 0;
  	high = n - 1;
  	
  	while (low <= high) {
  		mid = (low + high) / 2;
  		if (x < v[mid]) {
  			high = mid - 1;
  		}
  		else if ( x > v[mid]) {
  			low = mid + 1;
  		}
  		else /* found match */
  			return mid;
  	}
  	return -1; /* no match */
  }
  

• No differences!

• To compile the three files together, use
  gcc p1.c p2.c p3.c

• The differences are relatively minor, but are essential if the program is to be split up into separate files

• A C function may call itself directly or indirectly

• Two different examples

  // member.c
  /* is x a member of the list s? */
  
  #include <stdio.h>
  #include <string.h>
  
  int member(int x, char s[]);
  
  main()
  {
  	char x = 'h'; /* character to find */
  	char s[] = "look in this string"; /* search in this array */
  
  	printf("%c is %s \"%s\"\n", x, member(x, s) ? "in" : "not in", s);
  }
  
  int member(int x, char s[])
  {
  	if (strlen(s) == 0)
  		return 0;
  	else if (x == s[0])
  		return 1;
  	else {
  		return member(x, ++s);
  	}
  }
  

• Second example

  // binsearchR.c
  /* recursive binsearch */
  
  int binsearch(int x, int v[], int from, int to)
  {
  	int mid;
  
  	mid = (from + to) / 2;
  	
  	if (from > to)
  		return -1; /* no match found */
  	else if (x < v[mid])
  		return binsearch(x, v, from, mid - 1);
  	else if (x > v[mid])
  		return binsearch(x, v, mid + 1, to);
  	else
  		return mid;
  } 
  
  /* iterative binsearch */
  
  int binsearch(int x, int v[], int n)
  {
  	int low, high, mid;
  
  	low = 0;
  	high = n - 1;
  	
  	while (low <= high) {
  		mid = (low + high) / 2;
  		if (x < v[mid]) {
  			high = mid - 1;
  		}
  		else if ( x > v[mid]) {
  			low = mid + 1;
  		}
  		else /* found match */
  			return mid;
  	}
  	return -1; /* no match */
  }
  

• Already come across

  #define symbolic_constant string

• C Preprocessor replaces symbolic_constant with string before compiling the program

• The Preprocessor also processes #include statements

• The entire file referenced by the #include is copied into the current file at the location of the #include

• #define allows you to create macros - string can be an expression

  #define max(a, b) ((a < b) ? (b) : (a))

  allows you to create a macro (which happens to look like a function) - but max(a, b) is replaced by the expression prior to compilation

  max(2, 3) /* in the program */

  is replaced with

  ((2 < 3) ? (3) : (2))

  and

  max(p+q, q+r)

  is replaced with

  ((p+q < q+r) ? (q+r) : (p+q))

• However, you cannot freely do everything that you can with normal expressions. What happens to

  max(p++, q++)

• putchar(x) and getchar() are not really functions. They are macros...

  #define getc(fp) ((fp)->cnt-- ? (int) *(fp)->ptr++ : __getc(fp))

  #define getchar() getc(stdin)

  #define putc(c, fp) ((fp)->cnt-- > 1 ? (int)(*(fp)->ptr++ = (c)) : __putc(c, fp))

  #define putchar(c) putc(c, stdout)

• You are also allowed to use prototypes which use symbolic constants

  int getchar(int);

  int putchar(void);

#if conditional integer expression
	statement
#elif conditional integer expression
	statement
#else
	statement
#endif

• Can be used to test whether or not some preprocessing is needed, e.g., if a symbolic constant is not already defined, then define it

Next Lecture...