C Language Tutorial And Complete Reference

C TUTORIAL

2012-12-18T09:25:00.000-08:00

C LANGUAGE TUTORIAL

This tutorial teaches the entire C programming language. It is composed of 13 chapters which should be studied in order since topics are introduced in a logical order

It is to the students benefit to download the source code for the example programs, then compile and execute each program as it is studied. The diligent student will modify the example program in some way, then recompile and execute it to see if he understands the material studied for that program.

This will provide the student with valuable experience using his compiler.

If you New to C Language


Don't worry about C language You Can easily Learn C within 13 hour with Help of Our Overview of C language which Contain 13 Chapter.with help of those 13 Chapter You Can Learn C

Click Here To learn C in 13 Hours



If you Want Prepare For International Certificate In C Language

Making a International Certificate for C language was so easy you have to prepare all topic in C language and also you have to workout more example program

Click Here To Learn Complete Reference



Good Luck for Your Preparation

Which of the following statements should be used to obtain a remainder after dividing 3.14 by 2.1 ?

2011-03-17T11:41:00.001-07:00

1. Which of the following statements should be used to obtain a remainder after dividing 3.14 by 2.1 ?

A. rem = 3.14 % 2.1;
B. rem = modf(3.14, 2.1);
C. rem = fmod(3.14, 2.1);
D. Remainder cannot be obtain in floating point division.

If you Want Prepare For International Certificate In C Language

2011-03-17T10:40:00.000-07:00

Making a International Certificate for C language was so easy you have to prepare all topic in C language and also you have to workout more example program

Click Here To Learn Complete Reference

This will Give you Complete Reference of C language More Topic in this other than that 13hrs Chapter

Study These Topic and Challenge Your Friends

This will Help You to Write Exam in C even For International Certification

Topic Under C For International Certificate

Programs In DYNAMIC ALLOCATION Of C

2010-12-18T08:42:00.000-08:00

C Tutorial

Programs In DYNAMIC ALLOCATION Of C

Example Program No : 1

Rewrite the example program STRUCT1.C from chapter 11 to dynamically allocate the two structures.

#include <stdio.h>
#include <malloc.h>

struct child
{
   char initial;    /* last name initial      */
   int age;         /* childs age             */
   int grade;       /* childs grade in school */
} *boy, *girl;

int main()
{
   boy = (struct child *)malloc(sizeof(struct child));

   boy->initial = 'R';
   boy->age = 15;
   boy->grade = 75;

   girl = (struct child *)malloc(sizeof(struct child));

   girl->age = boy->age - 1; /* she is one year younger */
   girl->grade = 82;
   girl->initial = 'H';

   printf("%c is %d years old and got a grade of %d\n",
           girl->initial, girl->age, girl->grade);

   printf("%c is %d years old and got a grade of %d\n",
           boy->initial, boy->age, boy->grade);

   return 0;
}

/* Result of execution

H is 14 years old and got a grade of 82
R is 15 years old and got a grade of 75

*/

Example Program No :2

Rewrite the example program STRUCT2.C from chapter 11 to dynamically allocate the 12 structures.

#include <stdio.h>
#include <malloc.h>

struct child
{
   char initial;
   int age;
   int grade;
} *kids[12];

int main()
{
int index;

   for (index = 0 ; index < 12 ; index++)
   {
      kids[index] = (struct child *)malloc(sizeof(struct child));
      kids[index]->initial = 'A' + index;
      kids[index]->age = 16;
      kids[index]->grade = 84;
   }

   kids[3]->age = kids[5]->age = 17;
   kids[2]->grade = kids[6]->grade = 92;
   kids[4]->grade = 57;

   *kids[10] = *kids[4];               /* Structure assignment */

   for (index = 0 ; index < 12 ; index++)
      printf("%c is %d years old and got a grade of %d\n",
             kids[index]->initial, kids[index]->age,
             kids[index]->grade);

   return 0;
}

/* Result of execution

A is 16 years old and got a grade of 84
B is 16 years old and got a grade of 84
C is 16 years old and got a grade of 92
D is 17 years old and got a grade of 84
E is 16 years old and got a grade of 57
F is 17 years old and got a grade of 84
G is 16 years old and got a grade of 92
H is 16 years old and got a grade of 84
I is 16 years old and got a grade of 84
J is 16 years old and got a grade of 84
E is 16 years old and got a grade of 57
L is 16 years old and got a grade of 84

*/

Programs In STRUCTURES AND UNIONS Of C

2010-12-18T08:40:00.000-08:00

C Tutorial

Programs In STRUCTURES AND UNIONS Of C

Example Program No : 1

Define a named structure containing a string for a name, an integer for feet, and another for arms. Use the new type to define an array of about 6 items. Fill the fields with data and print them out as follows.

A human being has 2 legs and 2 arms.
     A dog has 4 legs and 0 arms.
     A television set has 4 legs and 0 arms.
     A chair has 4 legs and 2 arms.

#include <stdio.h>
#include <string.h>

struct 
{
   char what[25];
   int legs, arms;
} object[6];

int main()
{
int index;

   strcpy(object[0].what, "human being");
   object[0].legs = 2;
   object[0].arms = 2;

   strcpy(object[1].what, "dog");
   object[1].legs = 4;
   object[1].arms = 0;

   strcpy(object[2].what, "television set");
   object[2].legs = 4;
   object[2].arms = 0;

   strcpy(object[3].what, "chair");
   object[3].legs = 4;
   object[3].arms = 2;

   strcpy(object[4].what, "centipede");
   object[4].legs = 100;
   object[4].arms = 0;

   strcpy(object[5].what, "spider");
   object[5].legs = 6;
   object[5].arms = 0;

   for(index = 0 ; index < 6 ; index++) 
   {
      printf("A %s has %d legs and %d arms.\n", object[index].what,
                  object[index].legs, object[index].arms);
   }

   return 0;
}



/* Result of execution

A human being has 2 legs and 2 arms.
A dog has 4 legs and 0 arms.
A television set has 4 legs and 0 arms.
A chair has 4 legs and 2 arms.
A centipede has 100 legs and 0 arms.
A spider has 6 legs and 0 arms.

*/

Example Program No : 2

Rewrite exercise 1 using a pointer to print the data out.

#include <stdio.h>
#include <string.h>

struct
{
   char what[25];
   int legs, arms;
} object[6], *point;

int main()
{
int index;

   strcpy(object[0].what, "human being");
   object[0].legs = 2;
   object[0].arms = 2;

   strcpy(object[1].what, "dog");
   object[1].legs = 4;
   object[1].arms = 0;

   strcpy(object[2].what, "television set");
   object[2].legs = 4;
   object[2].arms = 0;

   strcpy(object[3].what, "chair");
   object[3].legs = 4;
   object[3].arms = 2;

   strcpy(object[4].what, "centipede");
   object[4].legs = 100;
   object[4].arms = 0;

   strcpy(object[5].what, "spider");
   object[5].legs = 6;
   object[5].arms = 0;

   point = object;
   for(index = 0 ; index < 6 ; index++)
   {
      printf("A %s has %d legs and %d arms.\n", point->what,
                      point->legs, point->arms);
      point++;
   }

   return 0;
}

/* Result of execution

A human being has 2 legs and 2 arms.
A dog has 4 legs and 0 arms.
A television set has 4 legs and 0 arms.
A chair has 4 legs and 2 arms.
A centipede has 100 legs and 0 arms.
A spider has 6 legs and 0 arms.

*/

Programs In File I/O of C

2010-12-18T08:37:00.000-08:00

C Tutorial

Programs In File I/O of C

Example Program No : 1

Write a program that will prompt for a filename for an input file, prompt for a filename for a write file, and open both plus a file to the printer. Enter a loop that will read a character, and output it to the file, the printer, and the monitor. Stop at EOF.

#include <stdio.h>

int main()
{
FILE *infile, *outfile, *printer;
char infilename[25], outfilename[25];
int c;

   printf("Enter input file name ----> ");
   scanf("%s", infilename);
   infile = fopen(infilename, "r");

   printf("Enter output file name ---> ");
   scanf("%s", outfilename);
   outfile = fopen(outfilename, "w");

   printer = fopen("PRN", "w");

   do
   {
      c = getc(infile);
      if (c != EOF)
      {
         putchar(c);
         putc(c, outfile);
         putc(c, printer);
      }
   } while (c != EOF);

   fclose(printer);
   fclose(infile);
   fclose(outfile);

   return 0;
}

/* Result of execution

(This program writes to the printer, a file, and the monitor.)

*/

Example Program No :2

Prompt for a filename to read. Read the file a line at a time and display it on the monitor with line numbers.

#include <stdio.h>

int main()
{
FILE *infile;
char c, infilename[25], inputline[100];
int line = 1;

   printf("Enter input file name ----> ");
   scanf("%s", infilename);
   infile = fopen(infilename, "r");

   printf("%5d", line);
   do
   {
      c = fgets(inputline, 100, infile); /* read a line */
      if (c != NULL)
      {
         printf("%5d %s", line, inputline);
         line++;
      }
   } while (c != NULL);

   fclose(infile);

   return 0;
}

/* Result of execution

(You will get a listing of the file on the monitor with line numbers)

*/

Example Program No : 3

Modify ANYFILE.C to test if the file exists and print a message if it doesn't. Use a method similar to that used in READCHAR.C.

#include <stdio.h>

int main()
{
FILE *fp1;
char oneword[100], filename[25];
char *c;

   printf("Enter filename -> ");
   scanf("%s", filename);         /* read the desired filename */
   fp1 = fopen(filename, "r");
   if (fp1 == NULL)
   {
      printf("File doesn't exist\n");
      exit (1);
   }
   else
   {
      do
      {
         c = fgets(oneword, 100, fp1); /* get a line from the file */
         if (c != NULL)
            printf("%s", oneword);    /* display it on the monitor */
      } while (c != NULL);            /* repeat until NULL         */
   }
   fclose(fp1);

   return 0;
}

/* Result of execution

(The output depends on weather you type in a good filename.)

*/

Programs In I/O Of C

2010-12-18T08:34:00.000-08:00

C Tutorial

Programs In I/O Of C

Example Program No : 1

Write a program to read in a character using a loop, and display the character in its normal char form. Also display it as a decimal number. Check for a dollar sign to use as the stop character. Use the _getch() form of input so it will print immediately. Hit some of the special keys, such as function keys, when you run the program for some surprises. You will get two inputs from the special keys, the first being a zero which is the indication to the system that a special key was hit.

#include <stdio.h>
#include <conio.h>

int main()
{
char input_char;

   printf("Hit any key - to stop hit a $\n");
   do
   {
      input_char = _getch();
      printf("Input character is %c, numerical value is %3d\n",
                 input_char, input_char);
   } while (input_char != '$');

   return 0;
}

/* Result of execution

Hit any key - to stop hit a $
Input character is A, numerical value is 65
Input character is B, numerical value is 66
...
(The display depends on the input keys hit)

*/

Example Program No :2

Add a character string to SINGLEIO.C and store the input characters in the string. When the X is detected, add a terminating null to the string and print out the string with a printf() function call.

#include <stdio.h>
#include <conio.h>

char storage[80];

int main()
{
char c;
int index = 0;

   printf("Enter any characters, terminate program with X\n");

   do
   {
      c = _getch();           /* get a character                 */
      if (index < 79)         /* limit it to 79 characters       */
      {
         storage[index] = c;
         index++;
      }
      putchar(c);             /* display the hit key             */
   } while (c != 'X');
   storage[index] = 0;
   printf("%s\n", storage);
   printf("\nEnd of program.\n");

   return 0;
}

/* Result of execution

Enter any characters, terminate program with X

(The output depends on the characters you type in.)

End of program.

*/

Programs In Pointer Of C

2010-12-18T08:32:00.000-08:00

C Tutorial

Programs In Pointer Of C

Example Program No : 1

A variable name with an ampersand in front of it defines the address of the variable and therefore points to the variable. You can therefore read line nine as "pt1 is assigned the value of the address of index".

#include <stdio.h>
#include <string.h>

int main()
{
int index;
char stuff[20], *pt;

   strcpy(stuff, "This is a neat test.");
   pt = stuff;
   for(index = 0 ; index < 20 ; index++)
   {
      printf("A character is ---> %c\n", *pt);
      pt++;
   }

   return 0;
}

/* Result of execution

A character is ---> T
A character is ---> h
A character is ---> i
A character is ---> s
A character is --->
A character is ---> i
A character is ---> s
A character is --->
A character is ---> a
A character is --->
A character is ---> n
A character is ---> e
A character is ---> a
A character is ---> t
A character is --->
A character is ---> t
A character is ---> e
A character is ---> s
A character is ---> t
A character is ---> .

*/

Example Program No : 2

A pointer with a star in front of it refers to the value of the variable pointed to by the pointer. Line twelve of the program can be read as "The stored (starred) value to which the pointer pt1 points is assigned the value 13". This is commonly referred to as dereferencing the pointer. Now you can see why it is convenient to think of the asterisk as a star, it sort of sounds like the word store.

#include <stdio.h>
#include <string.h>

int main()
{
int index;
char stuff[20], *pt;

   strcpy(stuff, "This is a neat test.");
   pt = stuff + 19;
   for(index = 0 ; index < 20 ; index++)
   {
      printf("A character is ---> %c\n", *pt);
      pt--;
   }

   return 0;
}

/* Result of execution

A character is ---> .
A character is ---> t
A character is ---> s
A character is ---> e
A character is ---> t
A character is --->
A character is ---> t
A character is ---> a
A character is ---> e
A character is ---> n
A character is --->
A character is ---> a
A character is --->
A character is ---> s
A character is ---> i
A character is --->
A character is ---> s
A character is ---> i
A character is ---> h
A character is ---> T

*/

Programs In STRINGS AND ARRAYS Of C

2010-12-18T08:29:00.000-08:00

C Tutorial

Programs In STRINGS AND ARRAYS Of C

Example Program No : 1

Write a program with three short strings, about 6 characters each, and use strcpy() to copy the string literals "one", "two", and "three" into them. Concatenate the three strings into one larger string defined with 30 characters and print the result out 10 times.

#include "stdio.h"
#include "string.h"

int main()
{
int index;
char string1[6], string2[6], string3[6], all_three[18];

   strcpy(string1, "one");
   strcpy(string2, "two");
   strcpy(string3, "three");

   strcpy(all_three, string1);
   strcat(all_three, " ");
   strcat(all_three, string2);
   strcat(all_three, " ");
   strcat(all_three, string3);

   for(index = 0 ; index < 10 ; index = index + 1)
      printf("The final string is ---> %s\n", all_three);

   return 0;
}

/* Result of execution

The final string is ---> one two three
The final string is ---> one two three
The final string is ---> one two three
The final string is ---> one two three
The final string is ---> one two three
The final string is ---> one two three
The final string is ---> one two three
The final string is ---> one two three
The final string is ---> one two three
The final string is ---> one two three

*/

Example Program No : 2

Define two integer arrays, each 10 elements long, called array1 and array2. Using a loop, put some kind of nonsense data in each and add them term for term into another 10 element array named arrays. Finally, print all results in a table with an index number.

#include <stdio.h>

int main()
{
int index, array1[10], array2[10], arrays[10];

   for(index = 0 ; index < 10 ; index = index + 1)
   {
      array1[index] = 2 + 2 * index;
      array2[index] = 10 * (index + 1);
   }

   for(index = 0 ; index < 10 ; index = index + 1)
      arrays[index] = array1[index] + array2[index];

   for(index = 0 ; index < 10 ; index = index + 1)
      printf("%4d %4d + %4d = %4d\n", (index + 1), array1[index],
               array2[index], arrays[index]);

   return 0;
}

/* Result of execution

   1    2 +   10 =   12
   2    4 +   20 =   24
   3    6 +   30 =   36
   4    8 +   40 =   48
   5   10 +   50 =   60
   6   12 +   60 =   72
   7   14 +   70 =   84
   8   16 +   80 =   96
   9   18 +   90 = 108
10   20 + 100 = 120

*/

Example Program No :3
Define a string of some selected length, assign a word or phrase to it, and print it out as a string, then print it out as individual characters. Finally, print it out backwards by using a for loop with a decrementing third term. A useful function for the first term of the for loop is strlen() which returns the length of the string by counting characters up to, but not including, the terminating null.

#include <stdio.h>
#include <string.h>

char my_string[20] = "C is neat!";

int main()
{
int index;

   printf("%s\n", my_string);

   for (index = 0 ; my_string[index] ; index = index + 1)
      printf("%c", my_string[index]);
   printf("\n");

   for(index = strlen(my_string) ; index > 0 ; index = index - 1)
      printf("%c", my_string[index - 1]);
   printf("\n");

   return 0;
}

/* Result of execution

C is neat!
C is neat!
!taen si C

*/

Programs In C Preprocessor

2010-12-18T08:26:00.000-08:00

C Tutorial

Programs In C Preprocessor

Example Program No : 1

Write a program to count from 7 to -5 by counting down. Use #define statements to define the limits. (Hint, you will need to use a decrementing variable in the third part of the for loop control.

#include <stdio.h>

#define START 7
#define END   -5

int main()
{
int index;

   for(index = START ; index >= END ; index = index - 1)
      printf("The value of the count is now %2d\n", index);

   return 0;
}

/* Result of execution

The value of the count is now 7
The value of the count is now 6
The value of the count is now 5
The value of the count is now 4
The value of the count is now 3
The value of the count is now 2
The value of the count is now 1
The value of the count is now 0
The value of the count is now -1
The value of the count is now -2
The value of the count is now -3
The value of the count is now -4
The value of the count is now -5

*/

Programs In FUNCTIONS, VARIABLES, AND PROTOTYPES of C

2010-12-18T08:24:00.001-08:00

C Tutorial

Programs In FUNCTIONS, VARIABLES, AND PROTOTYPES of C

Example Program No : 1

To Rewrite TEMPCONV.C from an earlier chapter, and move the temperature calculation to a function.

/****************************************************************/
/*                                                              */
/*     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"
int tempcalc(itn centtemp);

int 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 = tempcalc(centigrade);
      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 */

   return 0;
}

int tempcalc(int centtemp)
{
int faren;

   faren = 32 + (centtemp * 9)/5;
   return (faren);
}

/* Result of execution

Centigrade to Farenheit temperature table

C = -20   F = -4
C = -10   F = 14
C =   0   F = 32   Freezing point of water
C = 10   F = 50
C = 20   F = 68
C = 30   F = 86
C = 40   F = 104
C = 50   F = 122
C = 60   F = 140
C = 70   F = 158
C = 80   F = 176
C = 90   F = 194
C = 100   F = 212   Boiling point of water
C = 110   F = 230
C = 120   F = 248

*/

Example Program No :2

Write a program that writes your name on the monitor 10 times by calling a function to do the writing. Move the called function ahead of the main function to see if your C compiler will allow it.

#include "stdio.h"

void writename();

void writename()
{
   printf("John Q. Doe\n");
}

int main()
{
int index;

   for(index = 0 ; index < 10 ; index = index + 1)
      writename();

   return 0;
}

/* Result of execution

John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe

*/

Example Program No :3
Add prototyping to the programs named SUMSQRES.C and SQUARES.C, and change the function definitions to the modern method.

#include <stdio.h>

void header(void);
void square(int number);
void ending(void);

int sum; /* This is a global variable */

int main(void)
{
int index;

   header();          /* This calls the function named header */
   for (index = 1 ; index <= 7 ; index++)
      square(index); /* This calls the square function */
   ending();          /* This calls the ending function */

   return 0;
}

void header(void)     /* This is the function named header */
{
   sum = 0;     /* Initialize the variable "sum" */
   printf("This is the header for the square program\n\n");
}

void square(int number)   /* This is the square function */
{
int numsq;

   numsq = number * number; /* This produces the square */
   sum += numsq;
   printf("The square of %d is %d\n", number, numsq);
}

void ending(void)   /* This is the ending function */
{
   printf("\nThe sum of the squares is %d\n", sum);
}

/* Result of execution

This is the header for the square program

The square of 1 is 1
The square of 2 is 4
The square of 3 is 9
The square of 4 is 16
The square of 5 is 25
The square of 6 is 36
The square of 7 is 49

The sum of the squares is 140

*/

Programs In ASSIGNMENT & LOGICAL COMPARES of C

2010-12-18T08:17:00.001-08:00

C Tutorial

Programs In ASSIGNMENT & LOGICAL COMPARES of C

Example Program No : 1

Write a program that will count from 1 to 12 and print the count, and its square, for each count.

#include <stdio.h>

int main()
{
int index, square;

   for(index = 1 ; index < 13 ; index = index + 1)
   {
      square = index * index;
      printf("%5d%5d\n", index, square);
   }

   return 0;
}

/* Result of execution

    1    1
    2    4
    3    9
    4   16
    5   25
    6   36
    7   49
    8   64
    9   81
   10 100
   11 121
   12 144

*/

Example Program No :2

Write a program that counts from 1 to 12 and prints the count and its inversion to 5 decimal places for each count. This will require a floating point number.

#include <stdio.h>

int main()
{
int index;
float inversion;

   for(index = 1 ; index < 13 ; index = index + 1)
   {
      inversion = 1.0/index;
      printf("%5d%9.5f\n", index, inversion);
   }

   return 0;
}

/* Result of execution

    1    1.00000
    2     .50000
    3     .33333
    4     .25000
    5     .20000
    6     .16667
    7     .14286
    8     .12500
    9     .11111
   10     .10000
   11     .09091
   12     .08333

*/

Example Program No :3

Write a program that will count from 1 to 100 and print only those values between 32 and 39, one to a line. Use the incrementing operator for this program.

#include <stdio.h>

int main()
{
int index;

   for(index = 1 ; index < 101 ; index = index + 1)
   {
      if ((index >= 32) && (index <= 39))
         printf("%5d\n", index);
   }

   return 0;
}

/* Result of execution

   32
   33
   34
   35
   36
   37
   38
   39

*/

Programs In Controls Of C

2010-12-18T08:13:00.001-08:00

C Tutorial

Programs In Program Controls Of C

Example Program No : 1

Write a program that writes your name on the monitor ten times.

#include <stdio.h>

int main()
{
int index;

   for(index = 0 ; index < 10 ; index = index + 1)
      printf("John Q. Doe\n");

   return 0;
}

/* Result of execution

John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe

*/

Example Program No :2

Write this program three times, once with each looping method.

#include <stdio.h>

int main()
{
int index;

   index = 0;
   do
   {
      printf("John Q. Doe\n");
      index = index + 1;
   } while (index < 10);

   return 0;
}

/* Result of execution

John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe
John Q. Doe

*/

Example Program No :3

Write a program that counts from one to ten, prints the values on a separate line for each, and includes a message of your choice when the count is 3 and a different message when the count is 7.

#include <stdio.h>

int main()
{
int index;

   index = 1;
   do
   {
      printf("The count is now %2d",index);
      if (index == 3)
         printf(" and is equal to three.");
      if (index == 7)
         printf(" and is equal to seven.");
      printf("\n");
      index = index + 1;
   } while (index < 11);

   return 0;
}

/* Result of execution

The count is now 1
The count is now 2
The count is now 3 and is equal to three.
The count is now 4
The count is now 5
The count is now 6
The count is now 7 and is equal to seven.
The count is now 8
The count is now 9
The count is now 10

*/

Basic Programs In C

2010-12-18T08:08:00.001-08:00

C Tutorial

Basic Programs In C

Example Program No : 1

Write a program to display your name on the monitor.

#include <stdio.h>

int main()
{
printf("John Q. Doe\n");

return 0;
}

/* Result of execution

John Q. Doe

*/

Example Program No : 2

Modify the program to display your address and phone number on separate lines by adding two additional printf() statements.

#include <stdio.h>

int main()
{
   printf("John Q. Doe\n");
   printf("1234 Main Street\n");
   printf("(505) 555-1212\n");

   return 0;
}

/* Result of execution

John Q. Doe
1234 Main Street
(505) 555-1212

*/

Example Program No :3

Remove line 7 from ONEINT.C by commenting it out, then compile and execute the resulting program to see the value of an uninitialized variable. This can be any value within the allowable range for that variable. If it happens to have the value of zero, that is only a coincidence, but then zero is the most probable value to be in an uninitialized variable because there are lots of zero values floating around in a computer's memory. It is actually legal for the program to abort if you refer to a variable that you failed to initialize, but few compilers, if any, will actually do so.

#include <stdio.h>

int main()
{
int index;

/* index = 13; */
   printf("The value of the index is %d\n", index);
   index = 27;
   printf("The value of the index is %d\n", index);
   index = 10;
   printf("The value of the index is %d\n", index);

   return 0;
}

Example Program No : 4

Add the following two lines just after the last printf() of ONEINT.C to see what it does. Study it long enough to completely understand the result.

printf("Index is %d\n it still is %d\n it is %d",

index, index, index);

...................

#include <stdio.h>

int main()
{
int index;

   index = 13;
   printf("The value of the index is %d\n", index);
   index = 27;
   printf("The value of the index is %d\n", index);
   index = 10;
   printf("The value of the index is %d\n", index);

   printf("Index is %d\n it still is %d\n it is %d",
                                  index, index, index);

   return 0;
}

STRINGS.C

2010-12-18T07:07:00.001-08:00

                              /* Chapter 7 - Program 2 - STRINGS.C */
#include <stdio.h>
#include <string.h>

int main()
{
char name1[12], name2[12], mixed[25];
char title[20];

   strcpy(name1, "Rosalinda");
   strcpy(name2, "Zeke");
   strcpy(title, "This is the title.");

   printf("     %s\n\n", title);
   printf("Name 1 is %s\n", name1);
   printf("Name 2 is %s\n", name2);

   if(strcmp(name1, name2) > 0) /* returns 1 if name1 > name2 */
      strcpy(mixed, name1);
   else
      strcpy(mixed, name2);

   printf("The biggest name alphabetically is %s\n", mixed);

   strcpy(mixed, name1);
   strcat(mixed, " ");
   strcat(mixed, name2);
   printf("Both names are %s\n", mixed);

   return 0;
}

/* Result of execution

     This is the title.

Name1 is Rosalinda
Name2 is Zeke
The biggest name alphabetically is Zeke
Both names are Rosalinda Zeke

*/

OPERATORS

2010-12-18T06:17:00.003-08:00

OPERATORS

Operators are tokens that cause a computation
to occur when applied to variables. C provides the following operators;

& Address

* Indirection

+ Unary plus

- Unary minus

~ Bitwise compliment

! Logical negation

++ As a prefix; preincrement

As a suffix; postincrement

-- As a prefix; predecrement

As a suffix; postdecrement

+ Addition

- Subtraction

* Multiply

/ Divide

% Remainder

<< Shift left

>> Shift right

& Bitwise AND

| Bitwise OR

^ Bitwise XOR

&& Logical AND

|| Logical OR

= Assignment

*= Assign product

/= Assign quotient

%= Assign remainder (modulus)

+= Assign sum

-= Assign difference

<<= Assign left shift

>>= Assign right shift

&= Assign bitwise AND

|= Assign bitwise OR

^= Assign bitwise XOR

< Less than

> Greater than

<= Less than or equal to

>= Greater than or equal to

== Equal to

!= Not equal to

. Direct component selector

-> Indirect component selector

a ? x:y "If a is true then x else
y"

[] Define arrays

() Parenthesis isolate conditions and
expressions

... Ellipsis are used in formal parameter
lists of

function prototypes to show a variable
number of

parameters or parameters of varying
types.

To illustrate some more commonly used
operators consider the following short program;

main()

{

int a;

int b;

int c;

a = 5; /* Assign a value of 5 to
variable 'a' */

b = a / 2; /* Assign the value of
'a' divided by two to variable 'b' */

c = b * 2; /* Assign the value of
'b' multiplied by two to variable 'c' */

if (a == c) /* Test if 'a' holds the
same value as 'c' */

puts("Variable 'a' is an even
number");

else

puts("Variable 'a' is an odd
number");

}

Normally when incrementing the value
of a variable you would write something like;

x = x + 1

C provides the incremental operator
'++' as well so that you can write;

x++

Similarly you can decrement the value
of a variable using '--' as;

x--

All the other mathematical operators
may be used the same, so in a C program you can write in shorthand;

NORMAL C

x = x + 1 x++

x = x - 1 x--

x = x * 2 x *= 2

x = x / y x /= y

x = x % 5 x %= 5

and so on.

PC GRAPHICS

2010-12-18T06:17:00.001-08:00

PC GRAPHICS

When programming graphics you should
bear in mind that they are a machine dependant subject. Code to
produce graphics on an IBM PC will not port to an Amiga, or VAX
or any other type of computer.

Introduction To PC Graphics

The IBM PC and compatible range of computers
display information on a visual display unit (VDU). To enable
the computer to send information to the VDU a component is included
within the computer called a "display card". There are
various display cards and VDUs which have been produced for the
IBM PC range of computers; monochrome display adapter (MDA), colour
graphics adapter (CGA), Hercules graphics card (HGC), Enhanced
graphics adapter (EGA), video graphics array (VGA), super video
graphics array (SVGA), memory controller gate array (MCGA), 8514/A
and the Txas Instruments Graphics Architecture (TIGA). For simplicity,
this section will concern itself only with the three more common
types of display;

CGA, EGA and VGA

Information about the VGA display is
also relevant to the SVGA display which in simple terms can do
the same and more. This section will not concern itself with monochrome
displays since they are of limited use in graphics work.

Display Modes

When an IBM PC computer is first switched
on is set to display 80 columns by 25 rows of writing. This measurement,
80 x 25 is called the "resolution". A display mode which
is intended for displaying writing is called a "text"
mode. Where as a display mode which is intended for displaying
pictures is called a "graphics" mode.

If you look closely at the display you
will see that each displayed character is comprised of dots. In
reality the entire display is comprised of dots, called "pixels",
which may be set to different colours. In text display modes these
pixels are not very relevant, however, in graphics display modes
each pixel may be selected and set by a program. The size of the
pixels varies with the display resolution. In 80 x 25 text mode
the pixels are half the width they are in 40 x 25 text display
mode.

Depending upon the display card installed
in the computer, there are a number of display modes which may
be used;

MODE TYPE RESOLUTION COLOURS

0 Text 40 x 25 4 (CGA), 16 (EGA,
VGA) Shades of grey

1 Text 40 x 25 4 (CGA), 16 (EGA,
VGA)

2 Text 80 x 25 4 (CGA), 16 (EGA,
VGA) Shades of grey

3 Text 80 x 25 4 (CGA), 16 (EGA,
VGA)

4 Graphics 320 x 200 4

5 Graphics 320 x 200 4 (grey on CGA
and EGA)

6 Graphics 640 x 200 2

7 Text 80 x 25 Mono (EGA, VGA)

13 Graphics 320 x 200 16 (EGA, VGA)

14 Graphics 640 x 200 16 (EGA, VGA)

15 Graphics 640 x 350 Mono (EGA,
VGA)

16 Graphics 640 x 350 16 (EGA, VGA)

17 Graphics 640 x 480 2 (VGA)

18 Graphics 640 x 480 16 (VGA)

19 Graphics 320 x 200 256 (VGA)

The term resolution in graphics modes
refers to the number of pixels across and down the VDU. The larger
the number of pixels, the smaller each is and the sharper any
displayed image appears. As you can see from the table, the VGA
display can produce a higher resolution than the other display
cards, resulting in sharper images being produced.

The CGA display card can produce a maximum
resolution of 320 x 200 pixels, where as the VGA display card
can produce a resolution of 640 x 480 pixels. This is why writing
on a VGA VDU looks so much sharper than the writing displayed
on a CGA VDU.

Accessing The Display

Inside the IBM PC computer is a silicon
chip called the BIOS ROM, this chip contains functions which may
be called by an external computer program to access the display
card, which in turn passes the information on to the VDU. The
BIOS display functions are all accessed by generating interrupt
10 calls, with the number of the appropriate function stored in
the assembly language AH register.

A programmer interested in creating
graphics displays must first be able to switch the display card
to an appropriate graphics mode. This is achieved by calling the
BIOS display function 0, with th number of the desired display
mode from the table stored in the assembly language AL register
thus the following assembly language code segment will switch
the display card to CGA graphics mode 4, assuming that is that
the display card is capable of this mode;

mov ah , 00

mov al , 04

int 10h

A C function for selecting video display
modes can be written;

#include <dos.h>

void setmode(unsigned char mode)

{

/* Sets the video display mode */

union REGS inregs outreg;

inreg.h.ah = 0;

inreg.h.al = mode;

int86(0x10,&inreg,&outregs);

}

Any graphics are created by setting
different pixels to different colours, this is termed "plotting",
and is achieved by calling BIOS display function 12 with the pixel's
horizontal coordinate in the assembly language CX register and
it's vertical coordinate in the assembly language DX register
and the required colour in the assembly language AL register thus;

mov ah, 12

mov al, colour

mov bh, 0

mov cx, x_coord

mov dx, y_coord

int 10h

The corresponding C function is;

#include <dos.h>

void plot(int x_coord, int y_coord,
unsigned char colour)

{

/* Sets the colour of a pixel */

union REGS regs;

regs.h.ah = 12;

regs.h.al = colour;

regs.h.bh = 0;

regs.x.cx = x_coord;

regs.x.dx = y_coord;

int86(0x10,&regs,&regs);

}

The inverse function of plot is to read
the existing colour setting of a pixel. This is done by calling
BIOS ROM display function 13, again with the pixel's horizontal
coordinate in the assembly language CX register and it's vertical
coordinate in the assembly language DX register. This function
then returns the pixel's colour in the assembly language AL register;

#include <dos.h>

unsigned char get_pixel(int x_coord,
int y_coord)

{

/* Reads the colour of a pixel */

union REGS inreg, outreg;

inreg.h.ah = 13;

inreg.h.bh = 0;

inreg.x.cx = x_coord;

inreg.x.dx = y_coord;

int86(0x10,&inreg,&outreg);

return(outreg.h.al);

}

Colour And The CGA

The CGA display card can display a maximum
of 4 colours simultaneously at any time. However, the display
card can generate a total of 8 colours. There are two sets of
colours, called "palettes". The first palette contains
the colours;

background, cyan, magenta and white.

the second palette contains the colours;

background, green, red and yellow.

Colour 0 is always the same as the background
colour.

The pixels displayed on the VDU take
their colours from the currently active palette, and are continuously
being refreshed. So, if the active palette changes, so to do the
colours of the displayed pixels on the VDU.

Selection of the active CGA palette
is achieved by calling the BIOS display function 11 with the number
of the desired palette (either 0 or 1) in the assembly language
BH register;

mov ah, 11

mov bh, palette

int 10h

The C function for selecting the CGA
palette is;

void palette(unsigned char palette)

{

union REGS inreg, outreg;

inreg.h.ah = 11;

inreg.h.bh = palette;

int86(0x10,&inreg,&outreg);

}

The background colour may be selected
independantly from any of the eight available colours by calling
the same BIOS display function with a value of 0 stored in the
assembly language BH register and the desired background colour
in the assembly language BL register;

mov ah, 11

mov bh, 0

mov bl, colour

int 10h

In C this function can be written;

void background(unsigned char colour)

{

union REGS inreg, outreg;

inreg.h.ah = 11;

inreg.h.bh = 0;

inreg.h.bl = colour;

int86(0x10,&inreg,&outreg);

}

The background colours available are;

0 Black

1 Blue

2 Green

3 Cyan

4 Red

5 Magenta

6 Yellow

7 White

Colour And The EGA

The EGA display card can display a maximum
of 16 colours simultaneously at any time. The colour of all pixels
is continuously refreshed by the display card by reading the colour
from the EGA palette. Unlike the CGA display card, the EGA display
card allows you to redefine any or all of the colours in the palette.
Unfortunately only the first 8 colours may be loaded into other
palette colours.

The colours are;

0 Black

1 Blue

2 Green

3 Cyan

4 Red

5 Magenta

6 Brown

7 Light grey

8 Dark grey

9 Light blue

10 Light green

11 Light cyan

12 Light red

13 Light magenta

14 Yellow

15 White

Changing a palette colour is achieved
by calling the BIOS display function 16 with a value of 0 in the
assembly language AL register, the colour value (0 to 7) in the
assembly language BH register and the number of the palette colour
(0 to 15) in the assembly language BL register thus;

mov ah,16

mov al,0

mov bl,palette

mov bh,colour

int 10h

In C this function may be written;

void ega_palette(unsigned char colour,
unsigned char palette)

{

union REGS inreg,outreg;

inreg.h.ah = 16;

inreg.h.al = 0;

inreg.h.bl = palette;

inreg.h.bh = colour;

int86(0x10,&inreg,&outreg);

}

Colour And The VGA

The VGA display card can display a maximum
of 256 colours on the VDU at any one time, these colours are defined
by information held in 256 special registers called "DAC"
registers. As with the CGA and EGA displays, the colour of displayed
pixels is continuously being refreshed, and as such any change
to a DAC register is immediately visible. Each DAC register has
three component data parts which record the amount of green, blue
and red colours which make up the displayed colour. Each of these
seperate data components can hold a value between 0 and 63 giving
the VGA display card the ability to display 262,144 colours! Although
only a small subset of them can be displayed at any one time.

Setting the value of a DAC register
is achieved by calling the BIOS display function 16 with a value
of 16 stored in the assembly language AL register, the green value
stored in the assembly language CH register, the blue value stored
in the assembly language CL register and the red value stored
in the assembly language DH register and the number of the DAC
register to be set stored in the assembly language BX register;

mov ah,16

mov al,16

mov ch,green

mov cl,blue

mov dh,red

mov bx,dac

int 10h

The C function to set a DAC register
looks lik this;

void set_dac(int dac, unsigned char
green, unsigned char blue, unsigned char red)

{

union REGS regs;

regs.h.ah = 16;

regs.h.al = 16;

regs.x.bx = dac;

regs.h.ch = green;

regs.h.cl = blue;

regs.h.dh = red;

int86(0x10,&regs,&regs);

}

Displaying Text

The BIOS ROM provides three functions
for displaying a single character. The first function to consider
is the one used extensively by DOS for displaying messages, this
is function 14 called "write text in teletype mode".
This function interprets some control characters; bell (ascii
7), backspace (ascii 8), carriage return (ascii 10) and line feed
(ascii 13) but all other ascii codes are displayed, and the current
cursor position updated accordingly, moving down a row when a
character is displayed in the far right column. To call this function
the assembly language register AL holds the ascii code of the
character to be displayed and assembly language register BL holds
the foreground colour for the character to be displayed in if
a graphics mode is active;

mov ah,14

mov al,character

mov bh,0

mov bl,foreground

int 10h

A C function for accessing the write
text in teletype mode may be written like this;

#include <dos.h>

void teletype(unsigned char character,
unsigned char foreground)

{

union REGS inreg, outreg;

inreg.h.ah = 14;

inreg.h.al = character;

inreg.h.bh = 0;

inreg.h.bl = foreground;

int86(0x10,&inrg,&outreg);

}

The second BIOS ROM display function
for displaying a character allows the foreground and background
colours of the displayed character to be defined. It also allows
multiple copies of the character to be displayed one after another
automatically displaying subsequent characters at the next display
position, although the current cursor position is not changed
by this function.

This function is called "write
character and attribute", and is BIOS ROM display function
number 9. It is called with the ascii code of the character to
be displayed in the assembly language AL register, the display
page in assembly language register BH, the foreground colour in
the first four bits of the assembly language register BL and the
background colour in the last four bits of the assembly language
register BL, the number of times the character is to be displayed
is stored in the assembly language CX register thus;

mov ah,9

mov al,character

mov bh,0

mov bl,foreground + 16 * background

mov cx,number

int 10h

And in C;

#include <dos.h>

void char_attrib(unsigned char character,
unsigned char foreground, unsigned char background, int number)

{

union REGS inreg,outreg;

inreg.h.ah = 9;

inreg.h.al = character;

inreg.h.bh = 0;

inreg.h.bl = (background << 4)
+ foreground;

inreg.x.cx = number;

int86(0x10,&inreg,&outreg);

}

The last BIOS ROM display function for
displaying a character retains the foreground and background colours
of the display position.

This function is called "write
character", and is BIOS ROM display function number 10. It
is identical to BIOS ROM display function 9 except that the colours
of the displayed character are those which are prevalent at the
display position, except in graphics modes when the foreground
colour of the character is determined by the value in the assembly
language BL register. Its use is as follows;

mov ah,10

mov al,character

mov bh,0

mov bl,foreground ; For graphics
modes ONLY

mov cx,number

int 10h

And in C;

#include <dos.h>

void char_attrib(unsigned char character,
unsigned char foreground, int number)

{

union REGS inreg,outreg;

inreg.h.ah = 10;

inreg.h.al = character;

inreg.h.bh = 0;

inreg.h.bl = foreground; /* For graphics
modes ONLY */

inreg.x.cx = number;

int86(0x10,&inreg,&outreg);

}

Positioning of the text cursor is provided
for by the ROM BIOS display function number 2. It is called with
the row number in the assembly language register DH and the column
number in the assembly language register DL;

mov ah,2

mov bh,0

mov dh,row

mov dl,column

int 10h

The corresponding function in C looks
like this;

#include <dos.h>

void at(unsigned char row, unsigned
char column)

{

union REGS regs;

regs.h.ah = 2;

regs.h.bh = 0;

regs.h.dh = row;

regs.h.dl = column;

int86(0x10,&regs,&regs);

}

From these basic functions a more useful
replacement for the C language's "printf()" function
can be written which allows data to be displayed at the current
cursor position, previously set by a call to "at()",
with prescribed attributes;

#include <dos.h>

#include <stdarg.h>

void at(unsigned char row, unsigned
char column)

{

union REGS regs;

regs.h.ah = 2;

regs.h.bh = 0;

regs.h.dh = row;

regs.h.dl = column;

int86(0x10,&regs,&regs);

}

void xprintf(unsigned char foreground,
unsigned char background, char *format,...)

{

union REGS inreg,outreg;

va_list arg_ptr;

static char output[1000];

unsigned char col;

unsigned char row;

unsigned char n;

unsigned char p;

unsigned char text;

unsigned char attr;

/* Convert foreground and background
colours into a single attribute */

attr = (background << 4) + foreground;

/* Copy data into a single string */

va_start(arg_ptr, format);

vsprintf(output, format, arg_ptr);

/* Determine number of display columns
*/

inreg.h.ah = 15;

int86(0x10,&inreg,&outreg);

n = outreg.h.ah;

/* Determine current cursor position
*/

inreg.h.ah = 3;

inreg.h.bh = 0;

int86(0x10,&inreg,&outreg);

row = outreg.h.dh;

col = outreg.h.dl;

/* Now display data */

p = 0;

while (output[p])

{

/* Display this character */

inreg.h.bh = 0;

inreg.h.bl = attr;

inreg.x.cx = 01;

inreg.h.ah = 9;

inreg.h.al = output[p++];

int86(0x10,&inreg,&outreg);

/* Update cursor position */

/* moving down a row if required */

col++;

if (col < (n - 1))

at(row, col);

else

{

col = 0;

at(++row, col);

}

This function, "xprintf()"
illustrates two more functions of the BIOS ROM. The first is the
call to function 15 which returns the number of text display columns
for the currently active display mode.

The other function illustrated, but
not yet discussed, is BIOS ROM function 3 which returns information
about the cursor. The cursor's row is returned in the assembly
language register DH, and it's column in the assembly language
register DL.

POINTERS

2010-12-18T06:16:00.001-08:00

POINTERS

A pointer is a variable that holds the
memory address of an item of data. Therefore it points to another
item. A pointer is declared like an ordinary variable, but its
name is prefixed by '*', thus;

char *p;

Read more »

POINTERS TO FUNCTIONS

2010-12-18T06:15:00.001-08:00

POINTERS TO FUNCTIONS

C allows a pointer to point to the address
of a function, and this pointer to be called rather than specifying
the function. This is used by interrupt changing functions and
may be used for indexing functions rather than using switch statements.
For example;

#include <stdio.h>

#include <math.h>

double (*fp[7])(double x);

void main()

{

double x;

int p;

fp[0] = sin;

fp[1] = cos;

fp[2] = acos;

fp[3] = asin;

fp[4] = tan;

fp[5] = atan;

fp[6] = ceil;

p = 4;

x = fp[p](1.5);

printf("\nResult %lf",x);

}

This example program defines an array
of pointers to functions, (*fp[])() that are then called dependant
upon the value in the indexing variable p. This program could
also be written;

#include <stdio.h>

#include <math.h>

void main()

{

double x;

int p;

p = 4;

switch(p)

{

case 0 : x = sin(1.5);

break;

case 1 : x = cos(1.5);

break;

case 2 : x = acos(1.5);

break;

case 3 : x = asin(1.5);

break;

case 4 : x = tan(1.5);

break;

case 5 : x = atan(1.5);

break;

case 6 : x = ceil(1.5);

break;

}

puts("\nResult %lf",x);

}

The first example, using pointers to
the functions, compiles into much smaller code and executes faster
than the second example.

The table of pointers to functions is
a useful facility when writing language interpreters, the program
compares an entered instruction against a table of key words that
results in an index variable being set and then the program simply
needs to call the function pointer indexed by the variable, rather
than wading through a lengthy switch() statement.

PROGRAM CONTROL STATEMENTS

2010-12-18T06:14:00.003-08:00

PROGRAM CONTROL STATEMENTS

As with any computer language, C includes
statements that test the outcome of an expression. The outcome
of the test is either TRUE or FALSE. The C language defines a
value of TRUE as non-zero, and FALSE as zero.

Selection statements

The general purpose selection statement
is "if" that follows the general form;

if (expression)

statement

else

statement

Where "statement" may be a
Read more »

SIGNAL

2010-12-18T06:14:00.001-08:00

SIGNAL

Interrupts raised by the host computer
can be trapped and diverted in several ways. A simple method is
to use signal().

Signal() takes two parameters in the
form;

void (*signal (int sig, void (*func)
(int))) (int);

The first parameter, 'sig' is the signal
to be caught. These are often predefined by the header file 'signal.h'.

The second parameter is a pointer to
a function to be called when the signal is raised. This can either
be a user function, or a macro defined in the header file 'signal.h'
to do some arbitrary task, such as ignore the signal for example.

On a PC platform, it is often useful
to disable the 'ctrl-break' key combination that is used to terminate
a running program by the user. The following PC signal() call
replaces the predefined signal 'SIGINT', which equates to the
ctrl-break interrupt request, with the predefined macro 'SIG-IGN',
ignore the request;

signal(SIGINT,SIG_IGN);

This example catches floating point
errors on a PC, and zero divisions!

#include <stdio.h>

#include <signal.h>

void (*old_sig)();

void catch(int sig)

{

printf("Catch was called with:
%d\n",sig);

}

void main()

{

int a;

int b;

old_sig = signal(SIGFPE,catch);

a = 0;

b = 10 / a;

/* Restore original handler before
exiting! */

signal(SIGFPE,old_sig);

}

SIZEOF

2010-12-18T06:13:00.001-08:00

SIZEOF

A preprocessor instruction, 'sizeof',
returns the size of an item, be it a structure, pointer, string
or whatever. However! take care when using 'sizeof'. Consider
the following program;

#include <stdio.h>

#include <mem.h>

char string1[80]; char *text = "This
is a string of data" ;

void main()

{

/* Initialise string1 correctly */

memset(string1,0,sizeof(string1));

/* Copy some text into string1 ? */

memcpy(string1,text,sizeof(text));

/* Display string1 */

printf("\nString 1 = %s\n",string1);

}

What it is meant to do is initialise
all 80 elements of string1 to zeroes, which it does alright, and
then copy the constant string 'text' into the variable 'string1'.
However, variable text is a pointer, and so the sizeof(text) instruction
returns the size of the character pointer (perhaps two bytes)
rather than the length of the string pointed to by the pointer!
If the length of the string pointed to by 'text' happened to
be the same as the size of a character pointer then no error would
be noticed.

SORTING AND SEARCHING

2010-12-18T06:12:00.003-08:00

SORTING AND SEARCHING

The ANSI C standard defines qsort(),
a function for sorting a table of data. The function follows the
format;

qsort(void *base,size_t elements,size_t
width,int (*cmp)(void *, void *));

The following short program illustrates
the use of qsort() with a character array.

#include <string.h>

main()

{

int n;

char data[10][20];

/* Initialise some arbirary data */

strcpy(data[0],"RED");

strcpy(data[1],"BLUE");

strcpy(data[2],"GREEN");

strcpy(data[3],"YELLOW");

strcpy(data[4],"INDIGO");

strcpy(data[5],"BROWN");

strcpy(data[6],"BLACK");

strcpy(data[7],"ORANGE");

strcpy(data[8],"PINK");

strcpy(data[9],"CYAN");

/* Sort the data table */

qsort(data[0],10,20,strcmp);

/* Print the data table */

for(n = 0; n < 10; n++)

puts(data[n]);

}

Here is a program that implements the
shell sort algorithm (this one is based on the routine in K &
R), which sorts arrays of pointers based upon the data pointed
to by the pointers;

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define LINELEN 80

#define MAXLINES 2000

char *lines[MAXLINES];

int lastone;

void SHELL(void);

void SHELL()

{

/* SHELL Sort Courtesy of K & R
*/

int gap;

int i;

int j;

char temp[LINELEN];

for(gap = lastone / 2; gap > 0;
gap /= 2)

for(i = gap; i < lastone; i++)

for(j = i - gap; j >= 0 &&
strcmp(lines[j] , lines[j + gap]) >

0; j -= gap)

{

strcpy(temp,lines[j]);

strcpy(lines[j] , lines[j + gap]);

strcpy(lines[j + gap] , temp);

}

void main(int argc, char *argv[])

{

FILE *fp;

char buff[100];

int n;

/* Check command line parameter has
been given */

if (argc != 2)

{

printf("\nError: Usage is SERVSORT
file");

exit(0);

}

/* Attempt to open file for updating
*/

fp = fopen(argv[1],"r+");

if (fp == NULL)

{

printf("\nError: Unable to open
%s",argv[1]);

exit(0);

}

/* Initialise element counter to zero
*/

lastone = 0;

/* Read file to be sorted */

while((fgets(buff,100,fp)) != NULL)

{

/* Allocate memory block*/

lines[lastone] = malloc(LINELEN);

if (lines[lastone] == NULL)

{

printf("\nError: Unable to allocate
memory");

fclose(fp);

exit(0);

}

strcpy(lines[lastone],buff);

lastone++;

if (lastone > MAXLINES)

{

printf("\nError: Too many lines
in source file");

exit(0);

}

/* Call sort function */

SHELL();

/* Close file */

fclose(fp);

/* Reopen file in create mode */

fp = fopen(argv[1],"w+");

/* Copy sorted data from memory to
disk */

for(n = 0; n < lastone; n++)

fputs(lines[n],fp);

/* Close file finally */

fclose(fp);

/* Return to calling program */

return(1);

}

If we want to use qsort() with a table
of pointers we have to be a bit more clever than usual.

This example uses the colours again,
but this time they are stored in main memory and indexed by a
table of pointers. Because we have a table of pointers to sort
there are two differences between this program's qsort() and the
previous one;

First we can't use strcmp() as the qsort()
comparison function, secondly the width of the table being sorted
is sizeof(char *), that is the size of a character pointer.

Notice the comparison function cmp()
that receives two parameters, both are pointers to a pointer.
qsort() sends to this function the values held in data[], which
are in turn pointers to the data. So we need to use this indirection
to locate the data, otherwise we would be comparing the addresses
at which the data is held rather than the data itself!

#include <alloc.h>

#include <string.h>

/* Function prototype for comparison
function */

int (cmp)(char **,char **);

int cmp(char **s1, char **s2)

{

/* comparison function using pointers
to pointers */

return(strcmp(*s1,*s2));

}

main()

{

int n;

char *data[10];

for(n = 0; n < 10; n++)

data[n] = malloc(20);

strcpy(data[0],"RED");

strcpy(data[1],"BLUE");

strcpy(data[2],"GREEN");

strcpy(data[3],"YELLOW");

strcpy(data[4],"INDIGO");

strcpy(data[5],"BROWN");

strcpy(data[6],"BLACK");

strcpy(data[7],"ORANGE");

strcpy(data[8],"PINK");

strcpy(data[9],"CYAN");

/* The data table is comprised of pointers
*/

/* so the call to qsort() must reflect
this */

qsort(data,10,sizeof(char *),cmp);

for(n = 0; n < 10; n++)

puts(data[n]);

}

The quick sort is a fast sorting algorithm
that works by subdividing the data table into two sub-tables and
then subdividing the sub-tables. As it subdivides the table, so
it compares the elements in the table and swaps them as required.

The following program implements the
quick sort algorithm, which is usually already used by qsort();

#include <string.h>

#define MAXELE 2000

char data[10][20];

int lastone;

void QKSORT()

{

/* Implementation of QUICKSORT algorithm
*/

int i;

int j;

int l;

int p;

int r;

int s;

char temp[100];

static int sl[MAXELE][2];

/* sl[] is an index to the sub-table
*/

l = 0;

r = lastone;

p = 0;

{

while(l < r)

{

i = l;

j = r;

s = -1;

while(i < j)

{

if (strcmp(data[i],data[j]) >
0)

{

strcpy(temp,data[i]);

strcpy(data[i],data[j]);

strcpy(data[j],temp);

s = 0 - s;

}

if (s == 1)

i++;

else

j--;

}

if (i + 1 < r)

{

p++;

sl[p][0] = i + 1;

sl[p][1] = r;

}

r = i - 1;

}

if (p != 0)

{

l = sl[p][0];

r = sl[p][1];

p--;

}

while(p > 0);

}

main()

{

int n;

/* Initialise arbitrary data */

strcpy(data[0],"RED");

strcpy(data[1],"BLUE");

strcpy(data[2],"GREEN");

strcpy(data[3],"YELLOW");

strcpy(data[4],"INDIGO");

strcpy(data[5],"BROWN");

strcpy(data[6],"BLACK");

strcpy(data[7],"ORANGE");

strcpy(data[8],"PINK");

strcpy(data[9],"CYAN");

/* Set last element indicator */

lastone = 9;

/* Call quick sort function */

QKSORT();

/* Display sorted list */

for(n = 0; n < 10; n++)

puts(data[n]);

}

A table sorted into ascending order
can be searched with bsearch(), this takes the format;

bsearch(key,base,num_elements,width,int
(*cmp)(void *, void *));

bsearch() returns a pointer to the first
element in the table that matches the key, or zero if no match
is found.

Or you can write your own binary search
function thus;

int BSRCH(char *key, void *data, int
numele, int width)

{

/* A binary search function returning
one if found */

/* Zero if not found */

int bp;

int tp;

int mp;

int result;

char *p;

bp = 0;

tp = numele;

mp = (tp + bp) / 2;

/* Locate element mp in table by assigning
pointer to start */

/* and incrementing it by width * mp
*/

p = data;

p += width * mp;

while((result = strcmp(p,key)) != 0)

{

if (mp >= tp)

/* Not found! */

return(0);

if (result < 0)

bp = mp + 1;

else

tp = mp - 1;

mp = (bp + tp) / 2;

p = data;

p += width * mp;

}

return(1);

}

void main()

{

int result;

char data[10][20];

/* Initialise some arbirary data */

strcpy(data[0],"RED");

strcpy(data[1],"BLUE");

strcpy(data[2],"GREEN");

strcpy(data[3],"YELLOW");

strcpy(data[4],"INDIGO");

strcpy(data[5],"BROWN");

strcpy(data[6],"BLACK");

strcpy(data[7],"ORANGE");

strcpy(data[8],"PINK");

strcpy(data[9],"CYAN");

/* Sort the data table */

qsort(data[0],10,20,strcmp);

result = BSRCH("CYAN",data[0],10,20);

printf("\n%s\n",(result ==
0) ? "Not found" : "Located okay");

}

There are other sorting algorithms as
well. This program incorporates the QUICK SORT, BUBBLE SORT, FAST
BUBBLE SORT, INSERTION SORT and SHELL SORT for comparing how each
performs on a random 1000 item string list;

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

char data[1000][4];

char save[1000][4];

int lastone;

void INITDATA(void);

void QKSORT(void);

void SHELL(void);

void BUBBLE(void);

void FBUBBLE(void);

void INSERTION(void);

void MKDATA(void);

void QKSORT()

{

/* Implementation of QUICKSORT algorithm
*/

int i;

int j;

int l;

int p;

int r;

int s;

char temp[20];

static int sl[1000][2];

l = 0;

r = lastone;

p = 0;

{

while(l < r)

{

i = l;

j = r;

s = -1;

while(i < j)

{

if (strcmp(data[i],data[j]) >
0)

{

strcpy(temp,data[i]);

strcpy(data[i],data[j]);

strcpy(data[j],temp);

s = 0 - s;

}

if (s == 1)

i++;

else

j--;

}

if (i + 1 < r)

{

p++;

sl[p][0] = i + 1;

sl[p][1] = r;

}

r = i - 1;

}

if (p != 0)

{

l = sl[p][0];

r = sl[p][1];

p--;

}

while(p > 0);

}

void SHELL()

{

/* SHELL Sort Courtesy of K & R
*/

int gap;

int i;

int j;

char temp[20];

for(gap = lastone / 2; gap > 0;
gap /= 2)

for(i = gap; i < lastone; i++)

for(j = i - gap; j >= 0 &&
strcmp(data[j] , data[j + gap]) > 0;

j -= gap)

{

strcpy(temp,data[j]);

strcpy(data[j] , data[j + gap]);

strcpy(data[j + gap] , temp);

}

void BUBBLE()

{

int a;

int b;

char temp[20];

for(a = lastone; a >= 0; a--)

{

for(b = 0; b < a; b++)

{

if(strcmp(data[b],data[b + 1]) >
0)

{

strcpy(temp,data[b]);

strcpy(data[b] , data[b + 1]);

strcpy(data[b + 1] , temp);

}

void FBUBBLE()

{

/* bubble sort with swap flag*/

int a;

int b;

int s;

char temp[20];

s = 1;

for(a = lastone; a >= 0 &&
s == 1; a--)

{

s = 0;

for(b = 0; b < a; b++)

{

if(strcmp(data[b],data[b + 1]) >
0)

{

strcpy(temp,data[b]);

strcpy(data[b] , data[b + 1]);

strcpy(data[b + 1] , temp);

s = 1;

}

void INSERTION()

{

int a;

int b;

char temp[20];

for(a = 0; a < lastone; a++)

{

b = a;

strcpy(temp,data[a + 1]);

while(b >= 0)

{

if (strcmp(temp,data[b]) < 0)

{

strcpy(data[b+1],data[b]);

b--;

}

else

break;

}

strcpy(data[b+1],temp);

}

void MKDATA()

{

/* Initialise arbitrary data */

/* Uses random(), which is not ANSI
C */

/* Returns a random number between
0 and n - 1 */

int n;

for(n = 0; n < 1000; n++)

sprintf(save[n],"%d",random(1000));

}

void INITDATA()

{

int n;

for(n = 0 ; n < 1000; n++)

strcpy(data[n],save[n]);

}

void main()

{

MKDATA();

/* Initialise arbitrary data */

INITDATA();

/* Set last element indicator */

lastone = 999;

/* Call quick sort function */

QKSORT();

/* Initialise arbitrary data */

INITDATA();

/* Set last element indicator */

lastone = 1000;

/* Call shell sort function */

SHELL();

/* Initialise arbitrary data */

INITDATA();

/* Set last element indicator */

lastone = 999;

/* Call bubble sort function */

BUBBLE();

/* Initialise arbitrary data */

INITDATA();

/* Set last element indicator */

lastone = 999;

/* Call bubble sort with swap flag
function */

FBUBBLE();

/* Initialise arbitrary data */

INITDATA();

/* Set last element indicator */

lastone = 999;

/* Call insertion sort function */

INSERTION();

}

Here are the profiler results of the
above test program run on 1000 and 5000 random items;

STRING SORT - 1000 RANDOM ITEMS

FBUBBLE 26.436 sec 41% |********************************************

BUBBLE 26.315 sec 41% |*******************************************

INSERTION 10.210 sec 15% |***************

SHELL 0.8050 sec 1% |*

QKSORT 0.3252 sec <1% |

STRING SORT - 5000 RANDOM ITEMS

FBUBBLE 563.70 sec 41% |********************************************

BUBBLE 558.01 sec 41% |********************************************

INSERTION 220.61 sec 16% |***************

SHELL 5.2531 sec <1% |

QKSORT 0.8379 sec <1% |

Here is the same test program amended
for sorting tables of integers;

/* Integer sort test program */

#include <stdio.h>

#include <stdlib.h>

void INITDATA(void);

void QKSORT(void);

void SHELL(void);

void BUBBLE(void);

void FBUBBLE(void);

void INSERTION(void);

void MKDATA(void);

int data[1000];

int save[1000];

int lastone;

void QKSORT()

{

/* Implementation of QUICKSORT algorithm
*/

int i;

int j;

int l;

int p;

int r;

int s;

int temp;

static int sl[1000][2];

l = 0;

r = lastone;

p = 0;

{

while(l < r)

{

i = l;

j = r;

s = -1;

while(i < j)

{

if (data[i] > data[j])

{

temp = data[i];

data[i] = data[j];

data[j] = temp;

s = 0 - s;

}

if (s == 1)

i++;

else

j--;

}

if (i + 1 < r)

{

p++;

sl[p][0] = i + 1;

sl[p][1] = r;

}

r = i - 1;

}

if (p != 0)

{

l = sl[p][0];

r = sl[p][1];

p--;

}

while(p > 0);

}

void SHELL()

{

/* SHELL Sort Courtesy of K & R
*/

int gap;

int i;

int j;

int temp;

for(gap = lastone / 2; gap > 0;
gap /= 2)

for(i = gap; i < lastone; i++)

for(j = i - gap; j >= 0 &&
data[j] > data[j + gap];

j -= gap)

{

temp = data[j];

data[j] = data[j + gap];

data[j + gap] = temp;

}

void BUBBLE()

{

int a;

int b;

int temp;

for(a = lastone; a >= 0; a--)

{

for(b = 0; b < a; b++)

{

if(data[b] > data[b + 1])

{

temp = data[b];

data[b] = data[b + 1];

data[b + 1] = temp;

}

void FBUBBLE()

{

/* bubble sort with swap flag */

int a;

int b;

int s;

int temp;

s = 1;

for(a = lastone; a >= 0 &&
s == 1; a--)

{

s = 0;

for(b = 0; b < lastone - a; b++)

{

if(data[b] > data[b + 1])

{

temp = data[b];

data[b] = data[b + 1];

data[b + 1] = temp;

s = 1;

}

void INSERTION()

{

int a;

int b;

int temp;

for(a = 0; a < lastone; a++)

{

b = a;

temp = data[a + 1];

while(b >= 0)

{

if (temp < data[b])

{

data[b+1] = data[b];

b--;

}

else

break;

}

data[b+1] = temp;

}

void MKDATA()

{

int n;

for(n = 0; n < 1000; n++)

save[n] = random(1000);

}

void INITDATA()

{

int n;

for(n = 0; n < 1000; n++)

data[n] = save[n];

}

void main()

{

int n;

/* Create 1000 random elements */

MKDATA();

/* Initialise arbitrary data */

INITDATA();

/* Set last element indicator */

lastone = 999;

/* Call quick sort function */

QKSORT();

/* Initialise arbitrary data */

INITDATA();

/* Set last element indicator */

lastone = 1000;

/* Call shell sort function */

SHELL();

/* Initialise arbitrary data */

INITDATA();

/* Set last element indicator */

lastone = 999;

/* Call bubble sort function */

BUBBLE();

/* Initialise arbitrary data */

INITDATA();

/* Set last element indicator */

lastone = 999;

/* Call bubble sort with swap flag
function */

FBUBBLE();

/* Initialise arbitrary data */

INITDATA();

/* Set last element indicator */

lastone = 999;

/* Call insertion sort function */

INSERTION();

}

And here are the profiler results for
this program;

INTEGER SORTS - 1000 RANDOM NUMBERS
(0 - 999)

FBUBBLE 3.7197 sec 41% |********************************************

BUBBLE 3.5981 sec 39% |******************************************

INSERTION 1.4258 sec 15% |***************

SHELL 0.1207 sec 1% |*

QKSORT 0.0081 sec <1% |

INTEGER SORTS - 5000 RANDOM NUMBERS
(0 - 999)

FBUBBLE 92.749 sec 42% |********************************************

BUBBLE 89.731 sec 41% |********************************************

INSERTION 35.201 sec 16% |***************

SHELL 0.9838 sec <1% |

QKSORT 0.0420 sec <1% |

INTEGER SORTS - 5000 RANDOM NUMBERS
(0 - 99)

FBUBBLE 92.594 sec 42% |*****************************************

BUBBLE 89.595 sec 40% |****************************************

INSERTION 35.026 sec 16% |***************

SHELL 0.7563 sec <1% |

QKSORT 0.6018 sec <1% |

INTEGER SORTS - 5000 RANDOM NUMBERS
(0 - 9)

FBUBBLE 89.003 sec 41% |*******************************************

BUBBLE 86.921 sec 40% |*******************************************

INSERTION 31.544 sec 14% |***************

QKSORT 6.0358 sec 2% |**

SHELL 0.5424 sec <1% |

INTEGER SORTS - 5000 DESCENDING ORDERED
NUMBERS

FBUBBLE 122.99 sec 39% |******************************************

BUBBLE 117.22 sec 37% |****************************************

INSERTION 70.595 sec 22% |**********************

SHELL 0.6438 sec <1% |

QKSORT 0.0741 sec <1% |

INTEGER SORTS - 5000 ORDERED NUMBERS

BUBBLE 62.908 sec 99% |******************************************

SHELL 0.3971 sec <1% |

INSERTION 0.0510 sec <1% |

QKSORT 0.0382 sec <1% |

FBUBBLE 0.0251 sec <1% |

INTEGER SORTS - 10000 RANDOM NUMBERS
(0 - 999)

FBUBBLE 371.18 sec 42% |****************************************

BUBBLE 359.06 sec 41% |***************************************

INSERTION 140.88 sec 16% |**************

SHELL 2.0423 sec <1% |

QKSORT 0.6183 sec <1% |

Theory has it that the performance of
a sorting algorithm is dependant upon;

a) the number of items to be sorted
and

b) how unsorted the list is to start
with.

With this in mind it is worth testing
the various sorting routines described here to determine which
one will best suit your particular application. If you examine
the above profiler results you will see that:

1) With an already sorted list FBUBBLE()
executes fastest

2) With a random list of small variations
between the values SHELL()

executes fastest

3) With a random list of large variations
between the values QKSORT()

executes the fastest

What the profiler does not highlight
is that when the comparison aspect of a sort function takes a
disproportionately long time to execute in relation to the rest
of the sort function, then the bubble sort with a swap flag will
execute faster than the bubble sort with out a swap flag.

When considering a sort routine take
into consideration memory constraints and the type of data to
be sorted as well as the relative performances of the sort functions.
Generally, the faster a sort operates, the more memory it requires.
Compare the simple bubble sort with the quick sort, and you will
see that the quick sort requires far more memory than the bubble
sort.

STRINGS

2010-12-18T06:12:00.001-08:00

STRINGS

The C language has one of the most powerful
string handling capabilities of any general purpose computer language.

A string is a single dimension array
of characters terminated by a zero byte.

Strings may be initialised in two ways.
Either in the source code where they may be assigned a constant
value, as in;

int main()

{

char *p = "System 5";

char name[] = "Test Program"
;

}

or at run time by the function strcpy()
that has the function prototype;

char *strcpy(char *destination, char
*source);

strcpy() copies the string pointed to
by source into the location pointed to by destination as in the
following example;

#include<stdio.h>

int main()

{

char name[50];

strcpy(name,"Servile Software");

printf("\nName equals %s",name);

}

C also allows direct access to each
individual byte of the string, so the following is quite permissible;

#include<stdio.h>

int main()

{

char name[50];

strcpy(name,"Servile Software");

printf("\nName equals %s",name);

/* Replace first byte with lower case
's' */

name[0] = 's';

printf("\nName equals %s",name);

}

The ANSI standard on the C programming
language defines the following functions for use with strings;

char *strcat(char *dest, char *source)
Appends string source to the end of string destination.

char *strchr(char *s, int c) Returns
a pointer to the first occurence of character 'c' within s.

int strcmp(char *s1, char *s2) Compares
strings s1 and s2 returning < 0 if s1 is less than s2

== 0 if s1 and s2 are the
same

> 0 if s1 is greater than
s2

int strcoll(char *s1, char *s2) Compares
strings s1 and s2 according to the collating sequence set by

setlocale() returning < 0
if s1 is less than s2

== 0 if s1 and s2 are the same

> 0 if s1 is greater than
s2

char *strcpy(char *dest, char *src)
Copies string src into string dest.

unsigned strcspn(char *s1, char *s2)
Returns the length of string s1 that consists entirely of characters
not in string s2.

unsigned strlen(char *s) Returns
the length of string s.

char *strncat(char *dest, char *src,
unsigned len) Copies at most 'len' characters from string src
into string dest.

int strncmp(char *s1, char *s2, unsigned
len) Compares at most 'len' characters from

string s1 with string s2 returning
< 0 if s1 is less than s2

== 0 if s1 and s2 are the
same

> 0 if s1 is greater than
s2

char *strncpy(char *dest, char *src,
unsigned len) Copies 'len' characters from string src into string
dest, truncating or

padding with zero bytes as required.

char *strpbrk(char *s1, char *s2)
Returns a pointer to the first character in string s1 that
occurs in

string s2.

char *strrchr(char *s, int c) Returns
a pointer to the last occurence of 'c' within string s.

unsigned strspn(char *s1, char *s2)
Returns the length of the initial segment of string s1 that
consists

entirely of characters in string
s2.

char *strstr(char *s1, char *s2) Returns
a pointer to the first occurence of string s2 within string

s1, or NULL if string s2 is not
found in string s1.

char *strtok(char *s1, char *s2) Returns
a pointer to the token found in string s1 that is defined by

delimiters in string s2. Returns
NULLif no tokens are found.

The ANSI standard also defines various
functions for converting strings into numbers and numbers into
strings.

Some C compilers include functions to
convert strings to upper and lower case, but these functions are
not defined in the ANSI standard. However, the ANSI standard does
define the functions; toupper() and tolower() that return an

integer parameter converted to upper
and lowercase respectively. By using these functions we can create
our own ANSI compatible versions;

#include<stdio.h>

void strupr(char *source)

{

char *p;

p = source;

while(*p)

{

*p = toupper(*p);

p++;

}

void strlwr(char *source)

{

char *p;

p = source;

while(*p)

{

*p = tolower(*p);

p++;

}

int main()

{

char name[50];

strcpy(name,"Servile Software");

printf("\nName equals %s",name);

strupr(name);

printf("\nName equals %s",name);

strlwr(name);

printf("\nName equals %s",name);

}

C does not impose a maximum length that
a string may be, unlike other computer languages. However, some
CPUs impose restrictions on the maximum size a block of memory
can be. For example, the 8088 family of CPUs, as used by the IBM
PC, impose a limit of 64K bytes on a segment of memory.

An example program to reverse all the
characters in a string.

#include <stdio.h>

#include <string.h>

char *strrev(char *s)

{

/* Reverses the order of all characters
in a string except the null */

/* terminating byte */

char *start;

char *end;

char tmp;

/* Set pointer 'end' to last character
in string */

end = s + strlen(s) - 1;

/* Preserve pointer to start of string
*/

start = s;

/* Swop characters */

while(end >= s)

{

tmp = *end;

*end = *s;

*s = tmp;

end--;

s++;

}

return(start);

}

main()

{

char text[100];

char *p;

strcpy(text,"This is a string
of data");

p = strrev(text);

printf("\n%s",p);

}

Strtok()

The function strtok() is a very powerful
standard C feature for extracting substrings from within a single
string. It is used where the substrings are separated by known
delimiters, such as commas in the following example;

#include <stdio.h>

#include <string.h>

main()

{

char data[50];

char *p;

strcpy(data,"RED,ORANGE,YELLOW,GREEN,BLUE,INDIGO,VIOLET");

p = strtok(data,",");

while(p)

{

puts(p);

p = strtok(NULL,",");

};

}

Or this program can be written with
a for() loop thus;

#include <stdio.h>

#include <string.h>

main()

{

char data[50];

char *p;

strcpy(data,"RED,ORANGE,YELLOW,GREEN,BLUE,INDIGO,VIOLET");

for(strtok(data,","); p;
p = strtok(NULL,","))

{

puts(p);

};

}

They both compile to the same code but
follow different programming styles.

Initially, you call strtok() with the
name of the string variable to be parsed, and a second string
that contains the known delimiters. Strtok() then returns a pointer
to the start of the first substring and replaces the first token
with a zero delimiter. Subsequent calls to strtok() can be made
in a loop passing NULL as the string to be parsed, and strtok()
will return the subsequent substrings.

Since strtok() can accept many delimiter
characters in the second parameter string we can use it as the
basis of a simple word counting program;

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

void main(int argc, char *argv[])

{

FILE *fp;

char buffer[256];

char *p;

long count;

if (argc != 2)

{

fputs("\nERROR: Usage is wordcnt
<file>\n",stderr);

exit(0);

}

/* Open file for reading */

fp = fopen(argv[1],"r");

/* Check the open was okay */

if (!fp)

{

fputs("\nERROR: Cannot open source
file\n",stderr);

exit(0);

}

/* Initialise word count */

count = 0;

{

/* Read a line of data from the file
*/

fgets(buffer,255,fp);

/* check for an error in the read
or EOF */

if (ferror(fp) || feof(fp))

continue;

/* count words in received line */

/* Words are defined as separated
by the characters */

/* \t(tab) \n(newline) , ; : . ! ?
( ) - and [space] */

p = strtok(buffer,"\t\n,;:.!?()-
");

while(p)

{

count++;

p = strtok(NULL,"\t\n,;:.!?()-
");

}

while(!ferror(fp) && !feof(fp));

/* Finished reading. Was it due to
an error? */

if (ferror(fp))

{

fputs("\nERROR: Reading source
file\n",stderr);

fclose(fp);

exit(0);

}

/* Reading finished due to EOF, quite
valid so print count */

printf("\nFile %s contains %ld
words\n",argv[1],count);

fclose(fp);

}

Converting Numbers To And From Strings

All C compilers provide a facility for
converting numbers to strings. This being sprintf(). However,
as happens sprintf() is a multi-purpose function that is therefore
large and slow. The following function ITOS() accepts two parameters,
the first being a signed integer and the second being a pointer
to a character string. It then copies the integer into the memory
pointed to by the character pointer. As with sprintf() ITOS()
does not check that the target string is long enough to accept
the result of the conversion. You should then ensure that the
target string is long enough.

Example function for copying a signed
integer into a string;

void ITOS(long x, char *ptr)

{

/* Convert a signed decimal integer
to a string */

long pt[9] = { 100000000, 10000000,
1000000, 100000, 10000, 1000, 100, 10, 1 };

int n;

/* Check sign */

if (x < 0)

{

*ptr++ = '-';

/* Convert x to absolute */

x = 0 - x;

}

for(n = 0; n < 9; n++)

{

if (x > pt[n])

{

*ptr++ = '0' + x / pt[n];

x %= pt[n];

}

return;

}

To convert a string to a floating point
number, C provides two functions; atof() and strtod(). atof()
has the prototype;

double atof(const char *s);

strtod has the prototype;

double strtod(const char *s,char **endptr);

Both functions scan the string and convert
it as far as they can, until they come across a character they
don't understand. The difference between the two functions is
that if strtod() is passed a character pointer for parameter 'endptr',
it sets that pointer to the first character in the string that
terminated the conversion. Because of its better error reporting,
by way of endptr, strtod() is often preferred to atof().

To convert a string to an integer use
atoi() that has the prototype;

int atoi(const char *s);

atoi() does not check for an overflow,
and the results are undefined!

atol() is a similar function but returns
a long. Alternatively, you can use strtol() and stroul() instead
that have better error checking.

STRUCTURES

2010-12-18T06:11:00.001-08:00

STRUCTURES

C provides the means to group together
variables under one name providing a convenient means of keeping
related information together and providing a structured approach
to data.

The general form for a structure definition
is;

typedef struct

{

variable_type variable_name;

}

structure_name;

When accessing data files, with a fixed
record structure, the use of a structure variable becomes essential.
The following example shows a record structure for a very simple
name and address file. It declares a data structure called 'data',
and comprised of six fields; 'name', 'address', 'town', 'county'
, 'post' and 'telephone'.

typedef struct

{

char name[30];

char address[30];

char town[30];

char county[30];

char post[12];

char telephone[15];

}

data;

The structure 'data' may then be used
in the program as a variable data type for declaring variables;

data record;

Thus declares a variable called 'record'
to be of type 'data'.

The individual fields of the structure
variable are accessed by the general form;

structure_variable.field_name;

Thus, the name field of the structure
variable record is accessed with;

record.name

There is no limit to the number of fields
that may comprise a structure, nor do the fields have to be of
the same types, for example;

typedef struct

{

char name[30];

int age;

char *notes;

}

dp;

Declares a structure 'dp' that is comprised
of a character array field, an integer field and a character pointer
field.

A structure variable may be passed as
a parameter by passing the address of the variable as the parameter
with the & operator thus;

func(&my_struct)

The following is an example program
that makes use of a structure to provide the basic access to the
data in a simple name and address file;

/* A VERY simple address book written
in ANSI C */

#include <stdio.h>

#include <stdlib.h>

#include <io.h>

#include <string.h>

#include <fcntl.h>

#include <sys\stat.h>

/* num_lines is the number of screen
display lines */

#define num_lines 25

typedef struct

{

char name[30];

char address[30];

char town[30];

char county[30];

char post[12];

char telephone[15];

}

data;

data record;

int handle;

/* Function prototypes */

void ADD_REC(void);

void CLS(void);

void DISPDATA(void);

void FATAL(char *);

void GETDATA(void);

void MENU(void);

void OPENDATA(void);

int SEARCH(void);

void CLS()

{

int n;

for(n = 0; n < num_lines; n++)

puts("");

}

void FATAL(char *error)

{

printf("\nFATAL ERROR: %s",error);

exit(0);

}

void OPENDATA()

{

/* Check for existence of data file
and if not create it */

/* otherwise open it for reading/writing
at end of file */

handle = open("address.dat",O_RDWR|O_APPEND,S_IWRITE);

if (handle == -1)

{

handle = open("address.dat",O_RDWR|O_CREAT,S_IWRITE);

if (handle == -1)

FATAL("Unable to create data
file");

}

void GETDATA()

{

/* Get address data from operator */

CLS();

printf("Name ");

gets(record.name);

printf("\nAddress ");

gets(record.address);

printf("\nTown ");

gets(record.town);

printf("\nCounty ");

gets(record.county);

printf("\nPost Code ");

gets(record.post);

printf("\nTelephone ");

gets(record.telephone);

}

void DISPDATA()

{

/* Display address data */

char text[5];

CLS();

printf("Name %s",record.name);

printf("\nAddress %s",record.address);

printf("\nTown %s",record.town);

printf("\nCounty %s",record.county);

printf("\nPost Code %s",record.post);

printf("\nTelephone %s\n\n",record.telephone);

puts("Press RETURN to continue");

gets(text);

}

void ADD_REC()

{

/* Insert or append a new record to
the data file */

int result;

result = write(handle,&record,sizeof(data));

if (result == -1)

FATAL("Unable to write to data
file");

}

int SEARCH()

{

char text[100];

int result;

printf("Enter data to search for
");

gets(text);

if (*text == 0)

return(-1);

/* Locate start of file */

lseek(handle,0,SEEK_SET);

{

/* Read record into memory */

result = read(handle,&record,sizeof(data));

if (result > 0)

{

/* Scan record for matching data
*/

if (strstr(record.name,text) != NULL)

return(1);

if (strstr(record.address,text) !=
NULL)

return(1);

if (strstr(record.town,text) != NULL)

return(1);

if (strstr(record.county,text) !=
NULL)

return(1);

if (strstr(record.post,text) != NULL)

return(1);

if (strstr(record.telephone,text)
!= NULL)

return(1);

}

while(result > 0);

return(0);

}

void MENU()

{

int option;

char text[10];

{

CLS();

puts("\n\t\t\tSelect Option");

puts("\n\n\t\t\t1 Add new record");

puts("\n\n\t\t\t2 Search for
data");

puts("\n\n\t\t\t3 Exit");

puts("\n\n\n\n\n");

gets(text);

option = atoi(text);

switch(option)

{

case 1 : GETDATA();

/* Go to end of file to append
new record */

lseek(handle,0,SEEK_END);

ADD_REC();

break;

case 2 : if (SEARCH())

DISPDATA();

else

{

puts("NOT FOUND!");

puts("Press RETURN to continue");

gets(text);

}

break;

case 3 : break;

}

while(option != 3);

}

void main()

{

CLS();

OPENDATA();

MENU();

}

Bit Fields

C allows the inclusion of variables
with a size of less than eight bits to be included in structures.
These variables are known as bit fields, and may be any declared
size from one bit upwards.

The general form for declaring a bit
field is;

type name : number_of_bits;

For example, to declare a set of status
flags, each occupying one bit;

typedef struct

{

unsigned carry : 1;

unsigned zero : 1;

unsigned over : 1;

unsigned parity : 1;

}

df;

df flags;

The variable 'flags' then occupies only
four bits in memory, and yet is comprised of four variables that
may be accessed like any other structure field.

Uunions

Another facility provided by C for efficient
use of available memory is the union structure. A union structure
is a collection of variables that all share the same memory storage
address. As such only one of the variables is ever accessible
at a time.

The general form of a union definition
is;

union name

{

type variable_name;

};

Thus, to declare a union structure for
two integer variables;

union data

{

int vara;

int varb;

};

and to declare a variable of type 'data';

data my_var;

The variable 'my_var' is then comprised
of the two variables 'vara' and 'varb' that are accessed like
with any form of structure, eg;

my_var.vara = 5;

Assigns a value of 5 to the variable
'vara' of union 'my_var'.

Enumerations

An enumeration assigns ascending integer
values to a list of symbols. An enumeration declaration takes
the general form;

enum name { enumeration list } variable_list;

Thus to define a symbol list of colours,
you can say;

enum COLOURS

{

BLACK,

BLUE,

GREEN,

CYAN,

RED,

MAGENTA,

BROWN,

LIGHTGRAY,

DARKGRAY,

LIGHTBLUE,

LIGHTGREEN,

LIGHTCYAN,

LIGHTRED,

LIGHTMAGENTA,

YELLOW,

WHITE

};

Then, the number zero may be referred
to by the symbol BLACK, the number one by the symbol BLUE, the
number two by the symbol GREEN and so on.

The following program illustrates the
use of an enumeration list to symbolise integers;

#include <stdio.h>

enum COLOURS

{

BLACK,

BLUE,

GREEN,

CYAN,

RED,

MAGENTA,

BROWN,

LIGHTGRAY,

DARKGRAY,

LIGHTBLUE,

LIGHTGREEN,

LIGHTCYAN,

LIGHTRED,

LIGHTMAGENTA,

YELLOW,

WHITE

};

void main()

{

int x;

x = RED;

printf("\nVariable 'x' holds %d",x);

}