Short C Tutorial

Formatted input: scanf description

For example:

  scanf ("%d", &i);         /* reads an integer into `i' */
  scanf ("%i", &i);         /* reads an integer (or octal, or hex) into `i' */
  scanf ("%f %i", &f, &i);  /* reads a double followed by an integer */

scanf is actually an integer function, which returns the number of input items assigned (or EOF if the end-of-file is reached or an error occurred).

The ampersand character `&' is a unary operator that returns the address of the thing to its right. Recall that a C function can not alter the value of its arguments (but there is nothing stopping it altering that value that is pointed to by one of its arguments!).

User input, a real program example

/* interest.c, by Tom Boutell, 6/27/93.
   Updated 6/29/93 to support user input. */

/* This program calculates the balance of a savings or loan account after
   a number of years specified by the user, with an interest rate,
   monthly payment, initial balance and rate of compounding specified
   by the user. */

/* Get standard input and output functions */
#include <stdio.h>

/* Get standard math functions */
#include <math.h>

int main() {
  /* Initial balance (money in account). Since this value can
    have a fractional part, we declare a float (floating point)
    variable to store it. */
  float initial_balance;

  /* Rate of interest, per year (also a floating point value) */
  float interest;

  /* Number of times interest is compounded each year (interest periods)
    (thus 1.0 is annually, 365.0 is daily) */ 
  float frequency;

  /* Time in years */
  float years;

  /* Total interest periods. This cannot have a fractional part,
    so we declare an integer (no fractional part) variable to store it. */
  int interest_periods;

  /* Current balance. (We store this in a separate place form the
    initial balance, so we will still be able to tell how much money
    we started with when the calculation is finished.) */

  float balance;

  /* Counter of interest periods */
  int i;

  /* Monthly deposit (negative values are permitted) */
  float deposit;

  /* Flag: when this is set true (nonzero), the user is finished */

  int done;

  /* User input: analyze again? */

  int again; 

  /* Initially, of course, we are *not* finished. (C does NOT automatically
    set variables to zero. Making this assumption is a common mistake
    among new programmers.) */

  done = 0;

  /* Loop until done. */

  while (!done) {
    /* Fetch starting values from user */  
    printf("Initial balance: ");
    scanf("%f", &initial_balance);

    printf("Interest rate (example: .05 for 5 percent): ");
    scanf("%f", &interest);

    printf("Number of compoundings per year (12 = monthly, 365 = daily): ");
    scanf("%f", &frequency);

    printf("Monthly deposit (enter negative value for loan payment): ");
    scanf("%f", &deposit);

    printf("Number of years (examples: 1, 5, .5): ");
    scanf("%f", &years);

    /* Actual logic begins here. */

    /* Calculate number of interest periods. */
    interest_periods = frequency * years;

    /* Set working balance to begin at initial balance. */
    balance = initial_balance;

    /* Loop through interest periods, increasing balance */
    for (i=0; (i < interest_periods); i++) {
      /* Add deposit. User enters deposit in terms of a monthly
        deposit, so calculate how much this comes out to
        over a given interest period. 
        
        This isn't 100% accurate because the deposit begins 
        earning interest on the fraction of it "deposited" 
        in one interest period, when in fact the whole amount 
        should be added at the beginning of the month. Feel free 
        to try to improve on this. */  
     
      balance += deposit * ( (1.0/frequency) * 12.0);

      /* Each period, multiply balance by 1.0 plus the annual
        rate of interest divided by the number of times per year
        (frequency) with which interest is compounded. */

      balance = balance * (1.0 + (interest/frequency));
    }
    /* Print out result */
    printf("Initial balance: %f Final balance: %f\n", 
      initial_balance, balance);
  
    printf("Enter 1 for another analysis, or 0 to quit: ");
    scanf("%d", &again);

    if (again) {
      done = 0;
    } else {
      done = 1;
    }
  }
  /* Everything went fine */
  return 0;
}

The on-line manual pages

The simple debugger `dbx'

cc -g -O0 main.c

dbx a.out



quit[!]                        - quit dbx
run arg1 arg2 ... { f1 }& f2   - begin execution of the program
stop at {line}                 - suspend execution at the line
[n] cont {signal}              - continue with signal
return                         - continue until the current procedure returns
print {exp} ...                - print the value of the expressions
printf "string", exp, ...      - print expressions using format string(C)
where [n]                      - print currently active procedures (stack trace)
status                         - print trace/stop/record's in effect
func {proc}                    - move to activation level of {proc}
{exp}[/ | ?]{count}{format}    - display count number of formatted memory items
file {file}                    - change current file to file
list {exp1},{exp2}             - list source lines from {exp1} to {exp2}
list {exp}:{int}               - list source lines at {exp} for {int} lines
sh {shell command}             - perform shell command

Arrays

Arrays are declared in C as follows (for example):

int counts[100];
float temperature[1024];

In this example, `count' is an array that can hold 100 integers, and `temperature' is an array that can hold 1024 floats.

So far so good. The major departure from FORTRAN is that the first element in a C array is element number 0 (rather than 1 as in FORTRAN). While this may be confusing to die-hard FORTRAN programmers, it is really a more natural choice. A side-effect of this choice is that the last element in an array has an index that is one less that the declared size of the array. This is a source of some confusion, and something to watch out for.

Initialising arrays

To initialise an array, specify the initial values in a list within curly brackets. For example:

int primes[100] =
  {2,   3,   5,   7,  11,  13,  17,  19,  23,  29,  31,  37,  41,  43,  47,  53,  59,  61,
  67,  71,  73,  79,  83,  89,  97, 101, 103, 107, 109, 113, 127, 131, 137, 139,
 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223,
 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,
 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383,
 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
 467, 479, 487, 491, 499, 503, 509, 521, 523, 541};

float temp[1024] = {5.0F, 2.3F};

double trouble[] = {1.0, 2.0, 3.0};

In this example, `primes' is initialised with the values of the first 100 primes (check them!), and the first two elements (temp[0] and temp[1]) of `temp' are initialised to 5.0F and 2.3F respectively. The remaining elements of `temp' are set to 0.0F. Note that we use the trailing `F' on these numbers to indicate that they are floats, not doubles.

The array `trouble' in the above example contains three double numbers. Note that its length is not explicitly declared, C is smart enough to work the length out.

Static arrays that are not explicitly initialised are set to zero. Automatic arrays that are not explicitly initialised, have undefined values.

Multidimensional arrays

Multidimensional arrays are declared and referenced in C by using multiple sets of square brackets. For example,

int table[2][3][4];

`table' is a 2x3x4 array, with the rightmost array subscript changing most rapidly as you move through memory (the first element is `table[0][0][0]', the next element is `table[0][0][1]', and the last element is `table[1][2][3]'.

When writing programs that use huge arrays (say, more than a few megabytes), you should be very careful to ensure that array references are as close as possible to being consecutive (otherwise you may get severe swapping problems).

Initialisation of multidimensional arrays

This is best demonstrated with an example:

int mat[3][4] = {
                  { 0, 1, 2},
                  { 3, 4, 5},
                  { 6, 7, 8}
                }

Note that I have only initialised a 3x3 subset of the 3x4 array. The last column of each row will have the default initialisation of zero.

Character arrays

Arrays can be of any type. Character arrays hold a single character in each element. In C, you manipulate character strings as arrays of characters, and operations on the strings (such as concatenation, searching) are done by calling special libary functions (e.g., strcat, strcmp).

Note that when calling a string-manipulation function, the end of the string is taken as the position of the first NUL character (0) in the string.

Character arrays can be initialised in the following ways:

char str[] = {'a', 'b', 'c'};
char prompt[] = "please enter a number";

In the example, `str' has length 3 bytes, and `prompt' has length 22 bytes, which is one more than the number of characters in "please enter a number", the extra character is used to store a NUL character (zero) as an indication of the end of the string. `str' does not having a trailing NUL.

Pointers

If there is one thing that sets C apart from most other languages, it is the use of pointers. A `pointer' is a variable containing the address of a memory location.

Suppose `p' is a pointer, then `*p' is the thing which `p' points to.

Suppose `i' is being pointed at by `p', then `i' and `*p' are the same thing, and `p', being equal to the address of `i', is equal to `&i' (remember, `&' is the unary address operator).

Pointers are declared by specifying the type of thing they point at. For example,

int *p;

defines `p' as a pointer to an int (so, therefore, `*p' is an int, hence the form of the declaration).

Note carefully, then by declaring `p' as in the above example, the compiler simply allocates space for the pointer (4 bytes in most cases), not for the variable that the pointer points to! This is a very important point, and is often overlooked. Before using `*p' in an expression, you have to ensure that `p' is set to point to a valid int. This `int' must have had space allocated for it, either statically, automatically, or by dynamically allocating memory at run-time (using a `malloc' function).

Here is an example showing some of the uses of pointers:

#include <stdio.h>
void main (void) {
  int m = 0, n = 1, k = 2;
  int *p;
  char msg[] = "hello world";
  char *cp;
            
  p   = &m;       /* p now points to m                       */
  *p  = 1;        /* m now equals 1                          */
  k   = *p;       /* k now equals 1                          */
  cp  = msg;      /* cp points to the first character of msg */
  *cp = 'H';      /* change the case of the 'h' in msg       */
  cp  = &msg[6];  /* cp points to the 'w'                    */
  *cp = 'W';      /* change its case                         */

  printf ("m = %d, n = %d, k = %d\nmsg = \"%s\"\n", m, n, k, msg);
}

Note the very important point that the name of an array (`msg' in the above example), if used without an index, is considered to be a pointer to the first element of the array. In fact, an array name followed by an index is exactly equivalent to a pointer followed by an offset. For example,

#include <stdio.h>
void main (void) {
  char msg[] = "hello world";
  char *cp;
            
  cp = msg;

  cp[0]     = 'H';
  *(msg+6)  = 'W';

  printf ("%s\n", msg);
  printf ("%s\n", &msg[0]);
  printf ("%s\n", cp);
  printf ("%s\n", &cp[0]);
}

Note, however, that `cp' is a variable, and can be changed, whereas `msg' is a constant, and is not an lvalue.

Pointers used as arguments to functions

We have already seen that C functions can not alter their arguments. They can, however, alter the variables that their arguments point to. Hence, by passing a pointer to a variable, one can get the effect of `call by reference'.

Here is an example of a function that swaps the values of its two arguments:

void swap_args (int *pi, int *pj) {
  int temp;

  temp = *pi;
  *pi = *pj;
  *pj = temp;
}

If all the asterisks were left out of this routine, then it would still compile OK, but its only effect would be to swap local copies of `pi' and `pj' around.

String functions

The standard C libraries include a bunch of functions for manipulating strings (i.e., arrays of chars).

Note that before using any of these functions, you should include the line "#include <string.h>" in your program. This include-file defines prototypes for the following functions, as well as defining special types such as `size_t', which are operating-system dependent.

char *strcat (s1, s2)           Concatenates s2 onto s1. null-terminates s1.
                                Returns s1.

char *strchr (s, c)             Searches string s for character c. Returns a
                                pointer to the first occurence, or null pointer
                                if not.

int strcmp (s1, s2)             Compares strings s1 and s2. Returns an integer
                                that is less than 0 is s1 < s2; zero if s1 = s2;
                                and greater than zero is s1 > s2.

char *strcpy (s1, s2)           Copies s2 to s1, returning s1.

size_t strlen (s)               Returns the number of characters in s, excluding
                                the terminating null.

char *strncat (s1, s2, n)       Concatenates s2 onto s1, stopping after `n'
                                characters or the end of s2, whichever occurs
                                first. Returns s1.

int strncmp (s1, s2, n)         Like strcmp, except at most `n' characters are
                                compared.

char *strncpy (s1, s2)          Like strcpy, except at most `n' characters are
                                copied.

char *strrchr (s, c)            Like strchr, except searches from the end of
                                the string.

int strstr (s1, s2)             Searches for the string s2 in s1. Returns a
                                pointer if found, otherwise the null-pointer.

size_r strspn (s1, s2)          Returns the number of consecutive characters
                                in s1, starting at the beginning of the string,
                                that are contained within s2.

size_r strcspn (s1, s2)         Returns the number of consecutive characters
                                in s1, starting at the beginning of the string,
                                that are not contained within s2.

char *strpbrk (s1, s2)          Returns a pointer to the first character in s1
                                that is present in s2 (or NULL if none).

char *strerror (n)              Returns a pointer to a string describing the
                                error code `n'.

char *strtok (s1, s2)           Searches s1 for tokens delimited by characters
                                from s1. The first time it is called with a
                                non-null s1, it writes a NULL into s1 at the
                                first position of a character from s2, and
                                returns a pointer to the beginning of s1. When
                                strtok is then called with a null s1, it finds
                                the next token in s1, starting at one position
                                beyond the previous null.

The following program illustrates the use of `strtok', the most complex of the string functions.

#include <string.h>
#include <stdio.h>
int main (void) {
  char s1[80];
  char s2[80];
  char *cp;

  if (gets(s1) == (char *)NULL) { /* gets returns the next line of input from 
                                   stdio, a null if there isn't one */

    printf ("end of file\n");
    return 1;
  }
  if (gets(s2) == (char *)NULL) {
    printf ("end of file\n");
    return 1;
  }

  cp = strtok (s1, s2);
  do {
    printf ("<%s>\n", cp);
  } while ((cp = strtok ((char *)NULL, s2)) != (char *)NULL);
  return 0;
}

File operations

<stdio> defines a number of functions that are used for accessing files. Before using a file, you have to declare a pointer to it, so that it can be referred to with the functions. You do this with, for example,

FILE *in_file;
FILE *out_file;

where `FILE' is a type defined in <stdio> (it is usually a complicated structure of some sort). To open a file, you do, for example:

in_file  = fopen ("input_file.dat",  "r");
out_file = fopen ("output_file.dat", "w");

Note the use of "r" to indicate read access, and "w" to indicate write access. The following modes are available:

"r"   read
"w"   write (destroys any existing file with the same name)
"rb"  read a binary file 
"wb"  write a binary file (overwriting any existing file) 
"r+"  opens an existing file for random read access, and
      writing to its end
"w+"  opens a new file for random read access, and writing to
      its end (destroys any existing file with the same name)

Once the file is opened, you can use the following functions to read/write it:

int getc (FILE *fp)             Returns the next character from `fp', or
                                EOF on error or end-of-file.

int putc (int c, FILE *fp)      Write the character c to the file `fp', 
                                returning the character written, or EOF on
                                error.

int fscanf (FILE *fp, char *format, ...) Like scanf, except input is taken 
                                from the file fp.

int fprintf (FILE *fp, char *format, ...) Like printf, except output is written 
                                to the file fp.

char *fgets (char *line, int n, FILE *fp) Gets the next line of input from the
                                file fp, up to `n-1' characters in length.
                                The newline character is included at the end
                                of the string, and a null is appended. Returns
                                `line' if successful, else NULL if end-of-file
                                or other error.

int fputs (char *line, FILE *fp) Outputs the string `line' to the file fp.
                                Returns zero is successful, EOF if not.

When you have finished with a file, you should close it with 'fclose':

int fclose (FILE *fp)           Closes the file 'fp', after flushing any
                                buffers. This function is automatically called
                                for any open files by the operating
                                system at the end of a program.  

It can also be useful to flush any buffers associated with a file, to guarantee that the characters that you have written have actually been sent to the file:

int fflush (FILE *fp)           Flushes any buffers associated with the 
                                file 'fp'.

To check the status of a file, the following functions can be called:

int feof (FILE *fp)             Returns non-zero when an end-of-file is read.

int ferror (FILE *fp)           Returns non-zero when an error has occurred,
                                unless cleared by clearerr.

void clearerr (FILE *fp)        Resets the error and end-of-file statuses.

int fileno (FILE *fp)           Returns the integer file descriptor associated
                                with the file (useful for low-level I/O).

Note that the above `functions' are actually defined as pre-processor macros in C. This is quite a common thing to do.

Structures

Any programming language worth its salt has to allow you to manipulate more complex data types that simply ints, and arrays. You need to have structures of some sort. This is best illustrated by example:

To define a structure, use the following syntax:

struct time {
  int hour;
  int minute;
  float second;
};

This defines a new data type, called `time', which contains 3 elements (packed consecutively in memory). To declare a variable of type `time', do the following:

struct time t1[10], t2 = {12, 0, 0.0F};

To refer to an individual element of a structure, you use the following syntax:

t1[0].hour = 12;
t1[0].minutes = 0;
t1[0].second = t2.second;
t1[1] = t2;

Structures can contain any type, including arrays and other structures. A common use is to create a linked list by having a structure contain a pointer to a structure of the same type, for example,

struct person {
  char *name[80];
  char *address[256];
  struct person *next_person;
};

Multiple precision arithmetic

As an example of how to program in C, let's explore the topic of multiple precision arithmetic. All the hard work will be done by GNU's Multiple Precision Arithmetic Library (GNU MP), written by Torbjorn Granlund. The version I will be using here is 1.3.2, obtained from archie.au on 9 August 1994.

Multiple precision arithmetic allows you to perform calculations to a greater precision than the host computer will normally allow. The penalty you pay is that the operations are slower, and that you have to call subroutines to do all the calculations.

GNU MP can perform operations on integers and rational numbers. It uses preprocessor macros (defined in gmp.h) to define special data types for storing these numbers. MP_INT is an integer, and MP_RAT is a rational number. However, since a multiple precision number may occupy an arbitrarily large amount of memory, it is not sufficient to allocate memory for each number at compile time. GNU MP copes with this problem by dynamically allocating more memory when necessary.

To begin with you need to initialise each variable that you are going to use. When you are finished using a variable, you should free the space it uses by calling a special function.

  MP_INT x, y;
  mpz_init (&x);
  mpz_init (&y);
  
  /* operations on x and y */
  
  mpz_clear (&x);
  mpz_clear (&y);

Let's now try a full program. For example, calculating the square root of two to about 200 decimal places:

#include <gmp.h>
#include <stdio.h>
void main (void) {
  char two[450], guess[225];
  int i;
  MP_INT c, x, temp, diff;
  
  two[0] = '2';
  for (i = 1; i < sizeof(two)-1; i++) {
    two[i] = '0';
  }
  two[i] = 0;
  mpz_init_set_str (&c, two, 10);

  guess[0] = '1';
  for (i = 1; i < sizeof(guess)-1; i++) {
    guess[i] = '0';
  }
  guess[i] = 0;
  mpz_init_set_str (&x, guess, 10);

  mpz_init (&temp);
  mpz_init (&diff);

  do {
    mpz_div (&temp, &c, &x);
    mpz_sub (&diff, &x, &temp);
    mpz_abs (&diff, &diff);
    mpz_add (&x, &temp, &x);
    mpz_div_ui (&x, &x, 2U);
  } while (mpz_cmp_ui (&diff, 10U) > 0);
      
  printf ("the square root of two is approximately ");
  mpz_out_str (stdout, 10, &x);
}

To compile, link, and run the program, use

cc -o two two.c -I/usr/local/include -L/usr/local/lib -lgmp
./two

PREPROCESSOR

#define PI 3.1415926535
#define SQR(a) (sqrarg=(a),sqrarg*sqrarg)

#include "filename"             /* from the current directory */
#include              /* from the system directories (modified by -I) */

#define DEBUG
                                /* defines the symbol DEBUG */
#ifdef DEBUG
  /* code here is compiled if DEBUG is defined */
#elif defined UNIX
  /* code here is compiled if DEBUG is not defined, and UNIX is defined */
#else
  /* code here is compiled if neither DEBUG or UNIX are defined */
#endif

#if 0
  /* code here is never compiled */
#endif

COMMAND-LINE ARGS, and returning a status to the shell

#include <stdio.h>
void main (int argc, char *argv[]) {
  printf ("this program is called '%s'\n", argv[0]);
  if (argc == 1) {
    printf ("it was called without any arguments\n");
  } else {
    int i;
    printf ("it was called with %d arguments\n", argc - 1);
    for (i = 1; i < argc; i++) {
      printf ("argument number %d was <%s>\n", i, argv[i]);
    }
  }
  exit (argc);
}  

MALLOC:

#include <stdio.h>
#include <stdlib.h>

/* Generates a two dimensional matrix, and fills it randomly with
zeroes and ones. */

void main (void) {
  int xdim, ydim;
  int i, j;
  int *p, *q;
  
  printf ("x dimension of matrix? > ");
  scanf ("%d", &xdim);
  printf ("y dimension of matrix? > ");
  scanf ("%d", &ydim);

  p = (int *) malloc (xdim * ydim * sizeof(int));
  if (p == NULL) {
    printf ("malloc failed!\n");
    return;
  }
  
  for (i = 0; i < xdim * ydim; i++) {
    if (rand() > RAND_MAX/2) {
      *(p+i) = 1;
    } else {
      *(p+i) = 0;
    }
  }

  for (i = 0; i < xdim; i++) {
    q = p + i * ydim;
    for (j = 0; j < ydim; j++) {
      printf ("%d ", *(q++));
    }
    printf ("\n");
  } 
  free ((void *)p);
} 

ASSIGNMENTS:

Write a C program that will accept an arbitrarily long list of real numbers from stdin, one per line, and will output the list sorted into ascending order. You should use "malloc" to obtain space to store the numbers. You do not know in advance how many numbers to expect, so you will have to "malloc" on-the-fly as necessary.

In addition, you will each be assigned one of the following exercises:

  this is a test
  of the program

It should return

  tset a si siht
  margorp eht fo

You are not allowed to use the C library function for reversing strings!

  this   is  a test
  of the    program

It should return

  this is a test
  of the program

  this   is  a test
  of the    program

It should return

  1 2 1 2 0 0 1

The following examples are taken from CORONADO ENTERPRISES C TUTOR - Ver 2.00

/* This is an example of a "while" loop */
#include <stdio.h>

main() {
   int count;

   count = 0;
   while (count < 6) {
      printf ("The value of count is %d\n", count);
      count = count + 1;
   }
}

/* This is an example of a do-while loop */
#include <stdio.h>
 
main()
{
int i;
 
   i = 0;
   do {
      printf("The value of i is now %d\n",i);
      i = i + 1;
   } while (i < 5);
}

/* This is an example of a for loop */
#include <stdio.h>

main()
{
int index;

   for (index = 0; index < 6; index++)
     printf ("The value of the index is %d\n",index);
}

/* This is an example of the if and the if-else statements */
#include <stdio.h>

main()
{
int data;

   for (data = 0; data < 10; data++) {

      if (data == 2)
         printf("Data is now equal to %d\n",data);

      if (data < 5)
         printf("Data is now %d, which is less than 5\n",data);
      else
         printf("Data is now %d, which is greater than 4\n",data);

   }  /* end of for loop */
}

#include <stdio.h>
main()
{
int xx;
 
   for (xx = 5; xx < 15; xx++){
      if (xx == 8)
         break;
      printf("In the break loop, xx is now %d\n",xx);
   }
 
   for(xx = 5;xx < 15;xx = xx + 1){
      if (xx == 8)
         continue;
      printf("In the continue loop, xx is now %d\n",xx);
   }
}

#include <stdio.h>
main()
{
int truck;

   for (truck = 3;truck < 13;truck = truck + 1) {

      switch (truck) {
         case 3  : printf("The value is three\n");
                   break;
         case 4  : printf("The value is four\n");
                   break;
         case 5  :
         case 6  :
         case 7  :
         case 8  : printf("The value is between 5 and 8\n");
                   break;
         case 11 : printf("The value is eleven\n");
                   break;
         default : printf("It is one of the undefined values\n");
                   break;
      } /* end of switch */

   } /* end of for loop */
}

#include <stdio.h>
main()
{
int dog,cat,pig;

   goto real_start;

   some_where:
   printf("This is another line of the mess.\n");
   goto stop_it;

/* the following section is the only section with a useable goto */
   real_start:
   for(dog = 1;dog < 6;dog = dog + 1) {
      for(cat = 1;cat < 6;cat = cat + 1) {
         for(pig = 1;pig < 4;pig = pig + 1) {
            printf("Dog = %d  Cat = %d  Pig = %d\n",dog,cat,pig);
            if ((dog + cat + pig) > 8 ) goto enough;
         };
      };
   };
   enough: printf("Those are enough animals for now.\n");
/* this is the end of the section with a useable goto statement */

   printf("\nThis is the first line out of the spaghetti code.\n");
   goto there;

   where:
   printf("This is the third line of spaghetti.\n");
   goto some_where;

   there:
   printf("This is the second line of the spaghetti code.\n");
   goto where;

   stop_it:
   printf("This is the last line of this mess.\n");

}

/****************************************************************/
/*                                                              */
/*     This is a temperature conversion program written in      */
/*      the C programming language. This program generates      */
/*      and displays a table of farenheit and centigrade        */
/*      temperatures, and lists the freezing and boiling        */
/*      of water.                                               */
/*                                                              */
/****************************************************************/
#include <stdio.h>

main()
{
int count;        /* a loop control variable               */
int farenheit;    /* the temperature in farenheit degrees  */
int centigrade;   /* the temperature in centigrade degrees */

   printf("Centigrade to Farenheit temperature table\n\n");

   for(count = -2;count <= 12;count = count + 1){
      centigrade = 10 * count;
      farenheit = 32 + (centigrade * 9)/5;
      printf("  C =%4d   F =%4d  ",centigrade,farenheit);
      if (centigrade == 0)
         printf(" Freezing point of water");
      if (centigrade == 100)
         printf(" Boiling point of water");
      printf("\n");
   } /* end of for loop */
}