C for Computer Scientists

Lecture Outline

Aims and Objectives
Another Looping Construct
Symbolic Constants
Character Input and Output
Counting Characters
Another Program...
Arrays
Functions
Call by Value
Call by Reference
A function to fetch a line of input

• for loop

• Symbolic Constants

• Character Input and Output

• Logical AND and OR

• Arrays

• Functions

• Call by Value and Call by Reference

	for (initialisation ; condition ; expression)
	{
		statements;
	}

• The initialisation step occurs before the loop is entered for the first time

• The condition is checked before the body of the loop is executed

• the expression step is executed every time the body is executed

The temperature conversion program with a for loop instead of a while loop

	// program name: temp_conv1.c
	#include <stdio.h>

	main()
	{
		int fahr;

		for (fahr=0; fahr <= 300; fahr = fahr+20)
		{
			printf("%3d %6.1f\n",fahr,(5.0/9.0)*(fahr-32));
		}
	}

• Notice that the calculation is part of the printf statement - wherever you can use a variable of a certain type (i.e., the calculation returns a value of type float, and is displayed as a floating point number) you can use a function or an expression

• The numbers 0, 20, and 300 in the program mean very little to readers of the program unless they are very familiar with what the program is doing

  for (fahr=0; fahr <= 300; fahr = fahr+20)
  

• C allows the definition of symbolic constants - names that will be replaced with their values when the program is compiled

• Symbolic constants are defined before main(), and the syntax is

  #define	NAME value
  

Example

	// program name: temp_conv2.c
 
	#include <stdio.h>

	#define	LOWER   0   /* lower limit of table */
	#define	UPPER   300 /* upper limit */
	#define	STEP    20  /* step size */

	main()
	{
		int fahr;

		for (fahr=LOWER; fahr<=UPPER; fahr=fahr+STEP)
		{
			printf("%3d %6.1f\n",fahr,(5.0/9.0)*(fahr-32));
		}
	}

• There is no semi-colon after the definition of a symbolic constant

• You cannot change the value of a symbolic constant at run-time

• C is a low(ish)-Level Language

• As such, it can only manipulate data structures that are directly supported by the hardware (characters and numeric literals)

• C has a standard library of functions for applying more powerful, flexible and convenient data structures - but first we will see how C performs low-level character input and output, from the keyboard and to the computer screen

• The simplest I/O functions are

  getchar(); /* get an input character */
  putchar(c); /* send an output character */
  

• Although getchar() and putchar() appear to handle characters, they are actually manipulating the ASCII values for the characters. getchar() reads a char and converts it into ASCII, and putchar() converts an ASCII value into a char!

• A program to read input from the keyboard and send the input as output to the screen

	//program name: readchar.c

	#include <stdio.h>

	main()
	{

		int c;	/* store the next char input */

		while ((c = getchar()) != EOF) {
			putchar(c);
		}
	}

• Every character on the keyboard has an ASCII value

• Let's say that we want to count the number of characters, spaces, and newlines (returns) in the input

• Now a character is anything that is input. But how can we count spaces and newlines?

• Single quotes around a character tell C to use that character's ASCII value. The character
  ' ', therefore is the ASCII value for the space character (32), and is an integer.
  " " is a space, and is a character!

• How can we refer to newline?

  '
  '

  will generate an error!

• C supports the use of special characters to refer to some difficult-to-refer-to characters. These chars are a single letter representation and are escaped!

• newline = '\n', ASCII value 10.

	//program name: countAllChars.c

	#include <stdio.h>

	main() {

		int c; /* for input char */
		int nc, ns, nl; /* declare vars */

		nc = ns = nl = 0; /* init. vars to 0 */

		while ((c = getchar()) != EOF) {
			++nc;
			if (c == ' ')
				++ns;
			else if (c == '\n')
				++nl;
		}

		printf("nc=%d; ns=%d; nl=%d", nc,ns,nl);
	}

• In more complicated conditionals you might want to test for multiple conditions, e.g., if the char is a space or if it is a newline, then...

• Let's rewrite the previous program so that we will not keep a count of newlines and spaces...

	//program name: countChars.c

	#include <stdio.h>

	main() {

		int c;
		int nc = 0; /* declare vars */

		while ((c = getchar()) != EOF) {
			if (! (c == ' ' || c == '\n'))
				++nc;
		}

		printf("nc=%d", nc);
	}

• Building a complex data type, based on character input

• First, a vector - or uni-dimensional array

• Declare it as type int, float, char, etc, depending on what each cell can contain

• Write a program to count the occurrence of letters in the range a - z and A - Z. Ignore other chars.

	//program name: countAlpha.c

	#include <stdio.h>

	main() {

		int c;	/* store input char */
		int nletters[26]; /*array of 26 cells */
		int i;	/* handy variable */

		for (i = 0; i < 26; ++i)
			nletters[i] = 0;

		while ((c = getchar()) != EOF) {
			if (c >= 'a' && c <= 'z')
				++nletters[c - 'a'];
			else if (c >= 'A' && c <= 'Z')
				++nletters[c - 'A'];
		}

		for (i = 0; i < 26; ++i) {
			c = 'a' + i;
			putchar(c);
			printf(" = %d\n", nletters[i]);
		}

	}

	Output for input: aAbcBc

	a = 2
	b = 2
	c = 2 

• A function is a subroutine or a procedure - a self-contained program that can be referenced (called) by other programs and functions

• Example, power(x,y) = x^y

	//program name: power.c

	#include <stdio.h>

	int power(int base, int n); /* prototype */

	main() {

		int i; /* handy variable */

		for (i = 0; i <= 10; ++i)
			printf("2^%d %d\n",i,power(2,i));

	}

	int power(int base, int i) {

		int n; /*handy variable */

		for (n = 1; i > 0; --i)
			n = n * base;
		return n;
	}

• Variables in the function are local to the function. You can use the same variables as in the calling procedure, without overwriting the original values!

• To change the value of the original variable

• Reading a character at a time is no great shakes

• Usually want to manipulate data at a higher level than character

• Typically, want to read input as complete `lines' (e.g., records). Let's say that the record delimiter is the newline character

• C stores character strings as a character array.

• The special character '\0' is used to indicate the end of the string (even after '\n'!)

	//program name: readLine.c

	#include <stdio.h>

	#define MAX 80 /* max line length */

	int getline(char line[],int max); /*prototype*/

	main()
	{
		char s[MAX];

		getline(s, MAX);
		printf("%s", s);
	}

	int getline(char s[], int max)
	{
		int c, i; /*store an input char, index*/

		for(i=0; i < max && (c=getchar()) != '\n' &&
                                    c != EOF; s[i++] = c)
		;
		if (c == '\n')
			s[i++] = '\n';

		s[i] = '\0';
		return i;
	}

Next Lecture...