C is a relativ= ely minimalist programming language that operates close to the hardware, and is more similar to assembly language than most high-level languages are. Indee= d, C is sometimes referred to as "portable assembly," reflecting its important difference from low-level languages such as assembly languages: C code can be compiled to run on almost any computer, more than any other language in existence, while any given assembly language runs on at most a = few very specific models of computer. For these reasons C has been called a medium-level language.

We briefly list some of C's characteristics that define the language and also have lead to its populari= ty as a programming language. Naturally we will be studying many of these aspe= cts throughout the course.

· &n= bsp; Small size

· &n= bsp; Extensive use of function calls

· &n= bsp; Loose typing -- unlike PASCAL

· &n= bsp; Structured language

· &n= bsp; Low level (Bitwise) programming readily available

· &n= bsp; Pointer implementation - extensive use of pointers for memory, arr= ay, Structures and functions

C has now become a widely used professional languag= e for various reasons.

· &n= bsp; It has high-level constructs.

· &n= bsp; It can handle low-level activities.

· &n= bsp; It produces efficient programs.

· &n= bsp; It can be compiled on a variety of computers.

Its main drawback is that it has poor = error detection which can make it off putting to the beginner. However diligence = in this matter can pay off handsomely since having learned the rules of C we c= an break them. Not many languages allow this. This if done properly and carefu= lly leads to the power of C programming.

A Brief History of C

C is a general-purpose language which = has been closely associated with the UNIX operating system for which it was develope= d - since the system and most of the programs that run it are written in C.

In 1972 Dennis Ritchie at = Bell Labs writes C and in 1978 the publication of The C Programming Language by Kernighan & Ritchie caused a revolution in the computing world

In 1983, the American National Standards Institute (ANSI) established a committee to provide a modern, comprehensive definition of C. The resulting definition, the ANSI standard, or "ANSI C", was completed late 1988<= /p>

· &n= bsp; UNIX developed c. 1969 -- DEC PDP-7 Assembly Language <= /span>

· &n= bsp; BCPL -- a user friendly OS providing powerful development tools de= veloped

from BCPL. Ass= embler tedious long and error prone.

· &n= bsp; A new language ``B'' a second attempt. c. 1970. =

· &n= bsp; A totally new language ``C'' a successor to ``B''. c. 1971

· &n= bsp; By 1973 UNIX OS almost totally written in ``C'' =

Basic Structure of C Programs

C program can be viewed as a block of = building blocks called functions. A function is a subroutine that may include one or more statement designed to perform a specific task. To write a C program we first create a function and then put them together. A C program may contain= one or more section as below.

Documentation Section

Link Section

Definition Section

Global Declaration Section=

main() Function Section
{

= Declaration Part

= Executable Part
}

= Subprogram section
Function 1

Documentation section consist of set of comment, purpose of the program, Program logic etc. The link section provide instruction to the compiler to link function from the system library. The d= efinition section define all symbolic constants.

There are some variable that are= used in more than one function such variable are called global variable and are declared in the global declaration section that is outside of the functions.

Every C progra= m must have one main() function section. This section contains two parts declarati= on part and executable part. The declaration part declare all the variable use= d in the executable part. There is at lest one statement in the executable part. These two part must appear between the opening and the closing brace. The program execution begin at the opening braces and end in the closing brace.= The closing brace of the main function section is the logical end of the progra= m. All statement in the declaration section and executable parts end with semicolon.

The subprogram section contain all the user-defined function that are called in the main function.User defined functions are generally placed immediately after the main function. Although they may apper any order.

`C's Character Set`

C does not use, nor requires the use o= f, every character found on a modern computer keyboard. The only characters required= by the C Programming Language are as follows:

· &n= bsp; A - Z

· &n= bsp; a -z

· &n= bsp; 0 - 9

· &n= bsp; space . , : ; ' $ "

· &n= bsp; # % & ! _ {} [] () < > |

· &n= bsp; + - / * =3D

The use of most of this set of charact= ers will be discussed throughout the course

C Language Keywords

The following names are reserved by th= e C language. Their meaning is already defined, and they cannot be re-defined to mean anything else.

auto        = ;break     case         char     = continue    default<= br> do           double    else       &nbs= p; enum     extern       float
for           goto       if            <= span style=3D'mso-spacerun:yes'> int     &n= bsp;   long           register
return     short      sizeof       static    struct        switch
typedef   union     unsigned  = void     volatile      while

Other than these names, yo= u can choose any names of reasonable length for variables, functions etc. The nam= es must begin with a letter or underscore (letters are better), and then can contain letters, numbers and underscores.

Developing a program in a compiled lan= guage such as C requires at least four steps:

edit= ing (or writing) the program
comp= iling it <= /o:p>
exec= uting it

We will now cover each step separately

Editing
You write a computer program with words and symbols that are understandable= to human beings. This is the editing part of the development cycle. You type t= he program directly into a window on the screen and save the resulting text as= a separate File. This is often referred to as the source File (you can read it with the TYPE command in DOS or the cat command in unix). The custom is that the text of a C program is stored in a File with the extension .c for C programming language

Compiling
You cannot directly execute the source File. To run on any computer system,= the source File must be translated into binary numbers understandable to the computer's Central Processing Unit (for example, the 80*87 microprocessor). This process produces an intermediate object File - with the extension .obj, the .obj stands for Object.

Executable files

Thus the text editor produces .c sourc= e files, which go to the compiler, which produces .obj object files, which go to the linker, which produces .exe executable file. You can then run .exe files as= you can other applications, simply by typing their names at the DOS prompt or r= un using windows menu.

`Using Unix`

Please note that Unix is a case sensit= ive operating system and files named firstprog.c and FIRSTPROG.c are tre= ated as two separate files on these system. By default the Unix system compiles = and links a program in one step, as follows:

cc firstprog.c

This command creates an executable fil= e called a.out that overwrites any existing file called a.out. Executable files on U= nix are run by typing their name. In this case the program is run as follows

a.out

To change the name of the executable f= ile type:

cc -o firstprog firstprog.= c

This produces an executable file called firstprog which is run as follows:

Firstprog

On all Unix systems further help on th= e C compiler can be obtained from the on-line manual. Type man cc

Syntax of Conditional operators is&nbs= p; logical-or-expression= ? expression : conditional-expression

The conditional operator (? :) = is a ternary operator (it takes three operands). The conditional operator works = as follows

· &n= bsp; The first operand is implicitly converted to bool. It is evaluated and all side effects are completed before continuing.<= /span>

· &n= bsp; If the first operand evaluates to true (1), the second oper= and is evaluated.

· &n= bsp; If the first operand evaluates to false (0), the third oper= and is evaluated.

The result of the conditional operator= is the result of whichever operand is evaluated the second or the third. Only one = of the last two operands is evaluated in a conditional expression.<= /span>

VARIABLES AND = DATA TYPES<= /o:p>

The first thing you need to know is th= at you can create variables to store values in. A variable is just a named area of storage that can hold a single value (numeric or character). Every variable= has a name and a value

The name identifies the variable, the = value stores data. There is a limitation on what these names can be. Every variab= le name in C must start with a letter, the rest of the name can consist of letters, numbers and underscore characters. No Space allowed in variable na= me. C recognizes upper and lower case characters as being different. Finally, y= ou cannot use any of C's keywords like main, while, switch etc as variable names.

It demands that you declare the name o= f each variable that you are going to use and its type, or class, before you actua= lly try to do anything with it.

There are five basic data types associ= ated with variables

int -      = integer: a whole number.
float -    floating point va= lue: ie a number with a fractional part.
double = - a double-precision floating point value.
char -     a single character.
void -     valueless s= pecial purpose type which we will examine closely in later sections.

Integer Number Variables

The first type of variable we need to = know about is of class type int - short for integer. An int variable can store a value in the range -32768 to +32767. You can think of it as a largish posit= ive or negative whole number: no fractional part is allowed. To declare an int = you use the instruction: int variable name;
For example:

int a;

declares that you want to create an int variable called a.To assign a value to our integer variable we would use the following C statement.

a=3D10;

The C programming language uses the "=3D" character for assignment. A statement of the form a=3D10; s= hould be interpreted as take the numerical value 10 and store it in a memory location associated with the integer variable a. The "=3D" character shoul= d not be seen as an equality otherwise writing statements of the form:

a=3Da+10;

This statement should be interpreted a= s take the current value stored in a memory location associated with the integer variable a; add the numerical value 10 to it and then replace this value in= the memory location associated with a.

<= /o:p>

Decimal Number Variables

As described above, an integer variabl= e has no fractional part. Integer variables tend to be used for counting, whereas re= al numbers are used in arithmetic. C uses one of two keywords to declare a variable that is to be associated with a decimal number: float and <= b>double. They are each offer a different level of precision as outlined below

float

A float, or floating point, number has= about seven digits of precision and a range of about 1.E-36 to 1.E+36. A float ta= kes four bytes to store.

double

A double, or double precision, number = has about 13 digits of precision and a range of about 1.E-303 to 1.E+303. A dou= ble takes eight bytes to store.

For example:

float total;
double sum;

To assign a numerical value to our flo= ating point and double precision variables we would use the following C statement= .

total=3D0.0;
sum=3D12.50;

Before you can use a variable you have= to declare it. As we have seen above, to do this you state its type and then g= ive its name. For example, int i; declares an integer variable. You can declare= any number of variables of the same type with a single statement.

For example:

int a, b, c;

x Here is an example program that includes some of the concepts outlined ab= ove. It includes a slightly more advanced use of the printf function which will covered in detail in the next part of this course:

Character Vari= ables

C only has a concept of numbers and characters. It very often comes as a surprise to some programmers who learn= t a beginner's language such as BASIC that C has no understanding of strings bu= t a string is only an array of characters and C does have a concept of arrays w= hich we shall be meeting later in this course.
To declare a variable of type character we use the keyword char. - A single character

store= d in one byte.
For example

char c;

To assign, or store, a character value= in a char data type is easy - a character variable is just a symbol enclosed by single quotes. For example, if c is a char variable you can store the lette= r A in it using the following C statement.

c= =3D'A'

Notice that you can only store a single character in a char variable. Later we will be discussing using character strings, which has a very real potential for confusion because a string constant is written between double quotes. But for the moment remember that= a char variable is 'A' and not "A".

Assignment Sta= tement
The easiest example of an expression is in the assi= gnment statement. An expression is evaluated, and the result is saved in a variabl= e. A simple example might look like

`y =3D (m * x)= + c`
This assignment will save the value of the expression in variable y. <= /o:p>

Arithmetic operators
Here are the most common arithmetic operators

            +    Addition
            -     Subtraction
            *    Multiplication
            /    Division
           %   Modulo Reduction

, / and % will be performed before + or - in any expression. Brackets can be used to force a different order of evaluation to this. Where division is performed between two integers, the result will be = an integer, with remainder discarded. Modulo reduction is only meaningful betw= een integers. If a program is ever required to divide a number by zero, this wi= ll cause an error, usually causing the program to crash.

C has some operators which allow abbreviation of certain types of arithmetic assignment statements

Shorthand

Equivalent

    i++; or ++i;

i=3Di+1;

i--; or --i;

i=3Di-1;

These operations are usually very efficient. They c= an be combined with another expression.

These can cause confusion if you try t= o do too many things on one command line. You are recommended to restrict your use o= f `++` and `-` to ensure that your programs stay readable.

Shorthand

Equivalent

i +=3D10
i -=3D10
i =3D10
i /=3D10=

i =3D i+10
i =3D i-10
i =3D i*10
i =3D i/10

Comparison Operator

C has no special type to represent log= ical or Boolean values. It improvises by using any of the integral types char, int, short, long, unsigned, with a value of 0 representing false a= nd any other value representing true. It is rare for logical values to be stor= ed in variables. They are usually generated as required by comparing two numer= ic values. This is where the comparison operators are used, they compare two numeric values and produce a logical result.

C notation  <= /b>

Meaning

=3D=3D

Equal&nbs= p; to

>

&nb= sp; Grater Than

<

Less Than=

>=3D

&nb= sp;            =              Grater than or equal to

<=3D

      =             &nb= sp;         Less than or equal to

!=3D

      =             &nb= sp;         not equal to =

Note that =3D=3D is used in comparison= s and =3D is used in assignments. Comparison operators are used in expressions like the = ones below.

`x =3D=3D y<= /span>`
`i > 10`
    `a= + b !=3D c`<= o:p>

In the last example, all arithmetic is done before any comparison is made.<= o:p>

Logical Operators

These are the usual And, Or and Not operators<= /o:p>

Symbol	Meaning
&& \|\| !=	AND OR Not

They are frequently used to combine relational oper= ators, for example
x < 20 && x >=3D 10

In C these logical connectives employ a technique known as lazy evaluation. Th= ey evaluate their left hand operand, and then only evaluate the right hand one= if this is required. Clearly false && anything is always false, true || anything is always true. In such cases the second test is not evaluated.

Type conversion

You can mix the types of values in your arithmetic expressions. char types will be treated as int. Otherwise where types of different size are involved, the result will usually be of the lar= ger size, so a float and a double would produce a double result. Where integer = and real types meet, the result will be a double.
There is usually no trouble in assigning a value to a variable of different type. The value will be preserved as expected except where.

·        &n= bsp;        The variable is too small to hold the value. In this case it will = be corrupted (this is bad).

·        &n= bsp;        The variable is an integer type and is being assigned a real value. The value is rounded down. This is often done deliberately by the programme= r.

Values passed as function arguments mu= st be of the correct type. The function has no way of determining the type passed to= it, so automatic conversion cannot take place. This can lead to corrupt results= . The solution is to use a method called casting which temporarily disguises a va= lue as a different type.

int i =3D 256;
int root;
root =3D sqrt( (double) i);

(Xxx ) (double) in this example. The r= esult of sqrt( (double) i); is also a double, but this is automatically converted to= an int on assignment to root.

Bitwise Operators=

C has a distinction of supporting spec= ial operators known as bitwise operators for manipulation of data at bit level. These operators are used for testing the bits, or shifting them right or le= ft. Bitwise operators may not be applied to float or double. Bitwise operators = are

Operators

Meaning

&

|

^

<<

>>

~

bitwise AND

bitwise OR

bitwise exclusive OR

Shift left

Shift right

One's complement

&n= bsp;More about bitwise operators

User Defined Type Declaration

C support the feature known as type definition that allows use= r to define an identifier that would represent an exiting data type. The user defined datatype isentifier can later be used to declare variables. It takes the general form.

user= -defined data type is enumerated data type provided by ANSI standard. It is defined = as follows.

enum identifier<= span style=3D'mso-spacerun:yes'> { value1,value2,....valuen };=

The identifier is user -defined enumerated data type which can= be used to declare variable that can have one of the value enclosed with in the braces ( known as enumeration constant). After this we can declare variables to be of = this new type as below.

&n= bsp;         enum identifier v1,v2,...vn.

The enumerated v= ariable v1,v2,..vn can only have one of the following types are valid;

v1=3D value3;

&n= bsp;         v3=3D value1;

An examp= le

enum day { Monday, Tuesday,...,Sunda= y};
enum day week_st, Week_end;

Weel_st=3D Monday;
week_end=3D Friday;
if(week_st=3D=3DTuesday)
week_end=3DSaturday;

The compiler automatically assign inte= ger digit beginning with 0 to all the enumeration constants that is , the enumeration constant value1 is assign 0, value 1 , and so on. However the automatic assignment can be overridden by assigning values explicitly to the enumeration constant For example

enum day { Monday=3D1, Tuesday,...Sunday= };

Here, the constant Monday is assigned = the value of 1. The remaining constants are assigned values that increase successively by 1.

The definition and deceleration = of enumerated variable can be combined in one statement

enum day { Monday,....Sunday} Week_st, Week_end;

printf() :

The printf (and scanf) functions do differ from th= e sort of functions that you will created for yourself in that they can take a variable number of parameters. In the case of printf the first parameter is always a string (c.f. "Hello World") but after that you can inclu= de as many parameters of any type that you want to. That is, the printf functi= on is usually of the form:

&nb= sp;

printf(s= tring,variable,variable,variable...)

where the ... means you can carry on writing a lis= t of variables separated by commas as long as you want to. The string is all-important because it specifies the type of each variable in the list and how you want it printed. The string is usually called the control string or= the format string. The way that this works is that printf scans the string from left to right and prints on the screen, or any suitable output device, any characters it encounters - except when it reaches a % character. The % character is a signal that what follows it is a specification for how the n= ext variable in the list of variables should be printed. printf uses this information to convert and format the value that was passed to the function= by the variable and then moves on to process the rest of the control string and anymore variables it might specify. For example:

printf("He= llo World");

only has a control string and, as this contains no % character= s it results in Hello World being displayed and doesn't need to display any vari= able values. The specifier %d means convert the next value to a signed decimal integer and so:

   printf("Total =3D %d",total);

will print Total= =3D and then the value passed by >total as a decimal integer.<= /p>
The C view of output is at a lower level than you might expect= . The %d isn't just a format specifier, it is a conversion specifier. It indicates the data type of the variable to be printed and how that data type should be converted to the characters that appear on the screen. That is %d says that= the next value to be printed is a signed integer value (i.e. a value that would= be stored in a standard int variable) and this should be converted into a sequ= ence of characters (i.e. digits) representing the value in decimal. If by some accident the variable that you are trying to display happens to be a float = or a double then you will still see a value displayed - but it will not correspo= nd to the actual value of the float or double.

The reason for this is twofold. The first differen= ce is that an int uses two bytes to store its value, while a float uses four and a double uses eight. If you try to display a float or a double using %d then = only the first two bytes of the value are actually used. The second problem is t= hat even if there wasn't a size difference ints, floats and doubles use a different binary representation and %d expects the bit pattern to be a simple signed binary integer.

This is all a bit technical, but that's in the nat= ure of C. You can ignore these details as long as you remember two important facts=

The specifier following % indicates the type of variable to be displayed as well as the format in which that the value should be displayed= ; If you use a specifier with the wrong type of variable then you will see some strange things on the screen and the error often propagates to other items = in the printf list.

(XXX). You can also add an 'l' in front of a speci= fier to mean a long form of the variable type and h to indicate a short form (lo= ng and short will be covered later in this course). For example, %ld means a l= ong integer variable (usually four bytes) and %hd means short int. Notice that there is no distinction between a four-byte float and an eight-byte double.= The reason is that a float is automatically converted to a double precision val= ue when passed to printf - so the two can be treated in the same way. (In pre-= ANSI all floats w= ere converted to double when passed to a function but this is no longer true.) = The only real problem that this poses is how to print the value of a pointer? T= he answer is that you can use %x to see the address in hex or %o to see the address in octal. Notice that the value printed is the segment offset and n= ot the absolute address - to understand what we am going on about you need to = know something about the Structure of your processor.

&nb= sp;

FORMAT SPECIFIERS

%c &nb= sp;           &= nbsp;   à      = ; character

%d      &nb= sp;          à     =    Integer

%f         &= nbsp;         à      = ; Float

%s        &= nbsp;         à     =    String

Strings will be discussed later but for now remember: if you p= rint a string using the %s specifier then all of the characters stored in the arra= y up to the first null will be printed. If you use a width specifier then the st= ring will be right justified within the space. If you include a precision specif= ier then only that number of characters will be printed.

printf("%s,= Hello")

will print Hello=

&nb= sp;          printf(&qu= ot;%25s ,Hello")

will print 25 characters with Hello right justified and

&n= bsp;         printf("%2= 5.3s,Hello")

will print Hello= right justified in a group of 25 spaces.

Also notice that= it is fine to pass a constant value to printf as in printf("%s,Hello").=

Finally there are the control codes

\bà Backspace   &n= bsp;       \nà New line   &nb= sp;

\tàNorizontal tab  &nbs= p;     \'à Single quote

\0à Null    &= nbsp;           &nbs= p;   \”àDouble quote

If you include a= ny of these in the control string then the corresponding ASCII control code is se= nt to the screen, or output device, which should produce the effect listed. In most cases you only need to remember \n for new line.

Scanf()

Now that we have mastered the intricacies of printf you should find scanf very easy. The sca= nf function works in much the same way as the printf. That is it has the gener= al form:

scanf(control string,variable,variable,...)

In this case the control string specifies how strings of chara= cters, usually typed on the keyboard, should be converted into values and stored in the listed variables. However there are a number of important differences as well as similarities between scanf and printf.

The most obvious is that scanf has to change the values stored= in the parts of computers memory that is associated with parameters (variables= ).

To understand this fully you will have to wait unt= il we have covered functions in more detail. But, just for now, bare with us when= we say to do this the scanf function has to have the addresses of the variables rather than just their values. This means that simple variables have to be passed with a preceding >&. (Note for future reference: There is no = need to do this for strings stored in arrays because the array name is already a pointer.)

The second difference is that the control string h= as some extra items to cope with the problems of reading data in. However, all= of the conversion specifiers listed in connection with printf can be used with scanf.

The rule is that scanf processes the control strin= g from left to right and each time it reaches a specifier it tries to interpret wh= at has been typed as a value. If you input multiple values then these are assu= med to be separated by white space - i.e. spaces, newline or tabs

scanf("%d %d",&i,&j);

will read in two= integer values into i and j. The integer values can be typed on the same line or on different lines as long as there is at least one white space character betw= een them.

The only exception to this rule is the %c specifier which always reads in the next character typed no matter what it is. You can also use a width modifier in scanf. In this case its effect is to limit the number of characters accepted to the width.

There is one main problem with scanf function whic= h can make it unreliable in certain cases. The reason being is that scanf tends to ignore white spaces, i.e. the space character. If you require your input to contain spaces this can cause a problem. Therefore for string data input the function getstr() may well be more reliable as it records spaces in the inp= ut text and treats them as an ordinary characters.

Where we are not too interested in the format of o= ur data, or perhaps we cannot predict its format in advance, we can read and w= rite whole lines as character strings. This approach allows us to read in a line= of input, and then use various string handling functions to analyse it at our leisure.

gets reads a whole line of input into a string unt= il a newline or EOF is encountered. It is critical to ensure that the string is large enough to hold any expected input lines. When all input is finished, = NULL as defined in stdio.h is returned.

&nb= sp;

CONTROL STATEMENTS

A program consists of a number of statements which are usually executed in sequence. Programs can be much more powerful if we can control the ord= er in which statements are run.

Statements fall into three general types

Assignment, where values, usually the results of calculations, are stored in variables.

Input / Output, data is read in or printed out.

Control, the program makes a decision about what t= o do next.

This section will discuss the use of control statements in C. = We will show how they can be used to write powerful programs by;

Repeating important sections of the program. =

Selecting between optional sections of a program. <= /span>

If else Statement

            This= is used to decide whether to do something at a special point, or to decide bet= ween two courses of action. The following test decides whether a student has pas= sed an exam with a pass mark of 45

if (result >=3D 45)

   printf("Pass\n");<= o:p>

else

   printf("Fail\n");<= o:p>

It is possible to use the if part w= ithout the else.

if (temperature= < 0)

            print= ("Frozen\n");

Each version consists of a test, (this is the bracketed statem= ent following the if). If the test is true then the next statement is obeyed. I= f it is false then the statement following the else is obeyed if present. After this, the rest of the program continues as normal.

If we wish to have more than one statement followi= ng the if or the else, they should be grouped together between curly brackets. Suc= h a grouping is called a compound statement or a block.

if (condition)

    {

   }

else

   {

&n= bsp; }

Sometimes we wish to make a multi-way decision based on several conditions. The most general way of doing this is by using the else if vari= ant on the if statement. This works by cascading several comparisons. As soon as one of these gives a true result, the following statement or block is execu= ted, and no further comparisons are performed. In the following example we are awarding grades depending on the exam result.

if ()

{

     else if (result = >=3D 60)

{

   }

else if (result >=3D 45)

   {

    }

else

   {

    }

&nb= sp;

In this example, all comparisons test a single variable called result. In other cases, each test may involve a different variable or some combination of tests. The same pattern can be used with more or fewer else if's, and the final lone else may be left out. It is up to the programmer to devise the correct Structure for each programming problem.

&nb= sp;

The switch Statement

This is another form of the multi way decision. It is well Structured, but can only be used in certain cases where; =

Only one variable is tested, all branches must dep= end on the value of that variable. The variable must be an integral type. (int, lo= ng, short or char).

Hopefully an example will clarify things. This is a function which converts an integer into a value description. It is useful w= here we are only concerned in measuring a quantity when it is quite small. =

&nb= sp;

estimate(number)=

int number;

{ switch(number) {

     case 0 :

             =    printf("None\n");

        =         break;

     case 1 :

        =         printf("One\n");

        =         break;

     case 2 :

        =         printf("Two\n");

        =         break;

     default :

        =          printf("Many\n");

        =          break;

    }

   }

&nb= sp;

Each interesting case is listed with a corresponding action. T= he break statement prevents any further statements from being executed by leav= ing the switch. Since case 3 and case 4 have no following break, they continue = on allowing the same action for several values of number.
Both if and switch constructs allow the programmer= to make a selection from a number of possible actions.

The other main type of control statement is the lo= op. Loops allow a statement, or block of statements, to be repeated. Computers = are very good at repeating simple tasks many times, the loop is C's way of achieving this.

Loop Control Statements

C gives you a choice of three types of loop, while, do while a= nd for.

The while loop keeps repeating an action until an associated test returns false. This is useful where the programmer does not know in advance how many times the loop will be traversed.

The do while loops is similar, but the test occurs= after the loop body is executed. This ensures that the loop body is run at least once.

The for loop is frequently used, usually where the= loop will be traversed a fixed number of times. It is very flexible, and novice programmers should take care not to abuse the power it offers.

The while Loop

The while loop r= epeats a statement until the test at the top proves false.

The string is passed to the function as an argumen= t. The size of the array is not specified, the function will work for a string of = any size.

&nb= sp;

The while loop is used to look at the characters in the string= one at a time until the null character is found. Then the loop is exited and the index of the null is returned. While the character isn't null, the index is incremented and the test is repeated.

The while loop repeats a statement until the test at the top p= roves false.

The string is passed to the function as an argumen= t. The size of the array is not specified, the function will work for a string of = any size.

The while loop repeats a statement until the test at the top p= roves false.

The Do While Loop=

This is very similar to the while loop except that the test oc= curs at the end of the loop body. This guarantees that the loop is executed at l= east once before continuing. Such a setup is frequently used where data is to be read. The test then verifies the data, and loops back to read again if it w= as unacceptable.

&nb= sp;

   do

    {
     } while (conditi= on);

The for Loop

The for = loop works well where the number of iterations of the loop is known before the loop is entered. The head of the loop consists of three parts separated by semicolons.

The first is run before the loop is entered. This = is usually the initialisation of the loop variable

The second is a test, the loop is exited when this returns false.

The third is a statement to be run every time the = loop body is completed. This is usually an increment of the loop counter. <= /o:p>

The example is a function which calculates the ave= rage of the numbers stored in an array. The function takes the array and the num= ber of elements as arguments.

The for loop ensures that the correct number of ar= ray elements are added up before calculating the average.

The three statements at the head of a for loop usu= ally do just one thing each, however any of them can be left blank. A blank firs= t or last statement will mean no initialisation or running increment. A blank comparison statement will always be treated as true. This will cause the lo= op to run indefinitely unless interrupted by some other means. This might be a return or a break statement.

It is also possible to squeeze several statements into the fir= st or third position, separating them with commas. This allows a loop with more t= han one controlling variable. The example below illustrates the definition of s= uch a loop, with variables hi and lo starting at 100 and 0 respectively and converging.

for (initilzation;condition,incemen= tation)

The for loop is extremely flexible and allows many types of program behaviour to be specifi= ed simply and quickly.

Th= e break Statement

We have already met break in the di= scussion of the switch statement. It is used to exit from a loop or a switch, control passing to the first statement beyond the loop or a switch.

With loops, break can be used to force an early exit from the = loop, or to implement a loop with a test to exit in the middle of the loop body. A break within a loop should always be protected within an if statement which provides the test to control the exit condition.

&nb= sp;

ARRAYS

Scientific programs very often deal with multiple data items possessing common characteristics. In such cases, it is often convenient to place the data items in question into an array, so that they all share a co= mmon name (e.g., x). The individual data items can be either integers or floating-point numbers. However, they all must be of the same data type.

In C, an element of an array (i.e., an individual = data item) is referred to by specifying the array name followed by one or more subscripts, with each subscript enclosed in square brackets. All subscripts must be nonnegative integers. Thus, in an n-element array called x, the arr= ay elements are

    x[0],x[1], ..., x[n-1]=

Note that the first element of the array is x[0] and not x[1],= as in other programming languages.

The number of subscripts determines the dimensiona= lity of an array. For example, x[i] refers to an element of a one-dimensional ar= ray, x. Similarly, y[i][j] refers to an element of a two-dimensional array, y, e= tc.

Arrays are declared in much the same manner as ord= inary variables, except that each array name must be accompanied by a size specification (which specifies the number of elements). For a one-dimension= al array, the size is specified by a positive integer constant, enclosed in sq= uare brackets. The generalization for multi-dimensional arrays is fairly obvious. Several valid array declarations are shown below

int j[100];=

double x[20];

double y[10][20]= ;

Thus, j is a 100-element integer array, x is a 20-element floa= ting point array, and y is a 10x20 floating-point array. Note that variable size array declarations, e.g.,

double a[n];

where n is an i= nteger variable, are illegal in C.

It is sometimes convenient to define an array size= in terms of a symbolic constant, rather than a fixed integer quantity. This ma= kes it easier to modify a program that utilizes an array, since all references = to the maximum array size can be altered by simply changing the value of the symbolic constant.

Like an ordinary variable, an array can be either = local or global in extent, depending on whether the associated array declaration = lies inside or outside, respectively, the scope of any of the functions which constitute the program. Both local and global arrays can be initialized via their declaration statements. For instance,

int j[5] =3D {1,= 3, 5, 7, 9};

Single operation= s which involve entire arrays are not permitted in C. Thus, if x and y are similar arrays (i.e., the same data type, dimensionality, and size) then assignment operations, comparison operations, etc. involving these two arrays must be carried out on an element by element basis. This is usually accomplished wi= thin a loop (or within nested loops, for multi-dimensional arrays).

Reading and writing   array element by using a loop, usually for loop is using for example

#include<stdio.h><= /span>

#include<conio.h><= /span>

#include<stdlib.h>=

void main()

  {

     int arr1[1],i,n;=

     printf("Ent= er number of array elements");

     scanf("%d",&n);

     if(n>10&&n<=3D0)

        =    {

        =       printf("Invalid number of n \n");

        =       exit(1);

        =    }

     for(i=3D0;i<n= ;i++)

     scanf("%d",&arr1[i]);

    printf("Contant of array is \n");

    for(i=3D0;i<n;i++)<= o:p>

     printf("%d\n",arr1[i]);

}

arrays can be initialized at the declaration section also for example

int a[5]=3D{10,20,30,40,50}

  &nb= sp;         int a[]=3D{10,20,30,40,50}

Character Array

An array of character variables is in no way diffe= rent from an array of numeric variables, but programmers often like to think abo= ut the

m in a different way.

Notice that the only difference, is the declared t= ype of the array and the %c used to specify that the data is to be interpreted as a character in scanf and printf. The trouble with character arrays is that to= use them as if they were text strings you have to remember how many characters = they hold. In other words, if you declare a character array 40 elements long and store H E L L O in it you need to remember that after element 4 the array is empty. This is such a nuisance that C uses the simple convention that the e= nd of a string of characters is marked by a null character. A null character i= s, as you might expect, the character with ASCII code 0. If you want to store = the null character in a character variable you can use the notation \0 - but mo= st of the time you don't have to actually use the null character. The reason is that C will automatically add a null character and store each character in a separate element when you use a string constant. A string constant is indic= ated by double quotes as opposed to a character constant which is indicated by a single quote. For example

"A"

is a string constant, but

'A'<= o:p>

is a character constant. The difference between these two superficially similar types of text is confusing at first and the source of many errors. All you have to remember is that "A" consists of two characters, the letter A followed by \0 whereas 'A' is just the single character A. If you are familiar with other languages you might think that = you could assign string constants to character arrays and work as if a string w= as a built-in data type. In C however the fundamental data type is the array and strings are very much grafted on. For example, if you try something like

   char name= [40];

   name=3D"Hello"

it will not work. However, you can print strings u= sing printf and read them into character arrays using scanf. For example,

main()

   {

    static char name[40] =3D"hello";

    printf("%s",= name);

    scanf("%s",n= ame);

    printf("%s",= name);

}

This program reads in the text that you type, terminating it w= ith a null and stores it in the character array name. It then prints the character array treating it as a string, i.e. stopping when it hits the first null string. Notice the use of the "%s" format descriptor in scanf and printf to specify that what is being printed is a string.=

At this point the way that strings work and how th= ey can be made a bit more useful and natural depends on understanding pointers whi= ch is covered in later section.

Functions and Program Structure

A function is a = ``black box'' that we've locked part of our program into. The idea behind a functio= n is that it compartmentalizes part of the program, and in particular, that the = code within the function has some useful properties.

It performs some well-defined task, which will be = useful to other parts of the program.

It might be useful to other programs as well; that= is, we might be able to reuse it (and without having to rewrite it).

Function Basics

So what defines a function? It has a name that you= call it by, and a list of zero or more arguments or parameters that you hand to = it for it to act on or to direct its work; it has a body containing the actual instructions (statements) for carrying out the task the function is suppose= d to perform; and it may give you back a return value, of a particular type.

Here is a very s= imple function, which accepts one argument, multiplies it by 2, and hands that va= lue back:

int multbytwo(int x)

   {

     int retval;=

     retval =3D x * 2= ;

     return retval;

   }

On the first line we see the return type of the fu= nction (int), the name of the function (multbytwo), and a list of the function's arguments, enclosed in parentheses.

        &= nbsp;   How do we call a function? We've be= en doing so informally since day one, but now we have a chance to call one that we've written, in full detail. Here is a tiny skeletal program to call mult= by2

&nb= sp;

   #include <stdio.h>

   extern int multbytwo(int);

   int main()=

     {

        int i, j;

        i =3D 3;

        j =3D multbytwo(i);

        printf("%d\n", j);

        return 0;

      }

Recursive Functions

A recursive function is one which calls itself. This is another complicated idea which you are unlikely to meet frequently. We shall provide some examples to illustrate recursive functions.

Recursive functions are useful in evaluating certa= in types of mathematical function. You may also encounter certain dynamic data Structures such as linked lists or binary trees. Recursion is a very useful= way of creating and accessing these Structures.

Here is a recursive version of the factorial funct= ion. We saw a non recursive version of this earlier.

#include<conio.h>=

#include<stdio.h>=

  void main()

   {

     int n,fact;

     int rec(int);

     clrscr();

     printf("Ent= er a Number");

     scanf("%d",&n);

     fact=3D rec(n);<= o:p>

     printf("%d",fact);

   }

int rec(int x)

{

       int = f;

       if (= x=3D=3D1)

        =    return (1);

       else=

         = f=3Dx*rec(x-1);

       retu= rn(f);

}

Don't be frightened by the apparent complexity of recursion. Recursive functions are sometimes the simplest answer to a calculation. How= ever there is always an alternative non-recursive solution available too. This w= ill normally involve the use of a loop, and may lack the elegance of the recurs= ive solution.

POINTERS

A pointer is a v= ariable that points at, or refers to, another variable. That is, if we have a point= er variable of type ``pointer to int,`` it might point to the int variable , o= r to the cell of the array . Given a pointer variable, we can ask questions like, `What's the value of the variable that this pointer points to?''

Why would we want to have a variable that refers to another variable? Why not just use that other variable directly? The answer= is that a level of indirection can be very useful. (Indirection is just another word for the situation when one variable refers to another.)

Basic Pointer Oper= ations

            The first things to do with pointers are to declare a pointer variable, set it = to point somewhere, and finally manipulate the value that it points to. A simp= le pointer declaration looks like this.

int *ip;

This declaration looks like our earlier declarations, with one obvious difference: that asterisk. The asterisk means that ip, the variable we're declaring, is not of type int, but rather of type pointer-to-int. (Another way of looking at it is that *ip, which as we'll see is the value pointed to by ip, will be an int.)

We may think of setting a pointer variable to poin= t to another variable as a two-step process: first we generate a pointer to that other variable, then we assign this new pointer to the pointer variable. We= can say (but we have to be careful when we're saying it) that a pointer variable has a value, and that its value is ``pointer to that other variable''. This will make more sense when we see how to generate pointer values.

Pointers (that is, pointer values) are generated w= ith the ``address-of'' operator &, which we can also think of as the ``pointer-to'' operator. We demonstrate this by declaring (and initializing= ) an int variable i, and then setting ip to point to it.

int i =3D 5;

ip =3D &i; =

The assignment expression ip =3D &i; contains both parts o= f the ``two-step process'' &i generates a pointer to i, and the assignment operator assigns the new point= er to (that is, places it ``in'') the variable ip. Now ip ``points to'' i,.

I is a variable of type int, so the value in its box is a number, 5. ip is a varia= ble of type pointer-to-int, so the `value'' in its box is an arrow pointing at another box. Referring once again back to the ``two-step process'' for sett= ing a pointer variable: the & operator draws us the arrowhead pointing at i= 's box, and the assignment operator =3D, with the pointer variable ip on its l= eft, anchors the other end of the arrow in ip's box.

. For example, we could write something like

printf("%d\n", *ip);

which would print 5, since ip points to i, and i is (at the mo= ment) 5.

(You may wonder how the asterisk * can be the pointer contents= -of operator when it is also the multiplication operator. There is no ambiguity here: it is the multiplication operator when it sits between two variables,= and it is the contents-of operator when it sits in front of a single variable. = The situation is analogous to the minus sign: between two variables or expressi= ons it's the subtraction operator, but in front of a single operator or express= ion it's the negation operator. Technical terms you may hear for these distinct roles are unary and binary: a binary operator applies to two operands, usua= lly on either side of it, while a unary operator applies to a single operand.) =

we changed the value pointed to by ip, but if we declare anoth= er variable j.

int j =3D 3;

        &= nbsp;   ip =3D &j;
we've changed ip itself.The picture now looks like this

We have to be careful when we say that a pointer assignment changes ``what the pointer points to.'' Our earlier assignment <= o:p>

*ip =3D 7;

changed the value pointed to by ip, but this more recent assignment

ip =3D &j;

has changed what variable ip points to. It's true that ``what ip points to'' has changed, but this time, it has changed for a different reason. Neither i (which is still= 7) nor j (which is still 3) has changed. (What has changed is ip's value.) If = we again call

printf("%d\n", *ip);

this time it wil= l print 3.

We can also assign pointer values to other pointer variables. If we declare a second pointer variable.

int *ip2;

ip2 =3D ip;=

Now ip2 points w= here ip does; we've essentially made a ``copy'' of the arrow.

Now, if we set ip to point back to i again.<= /p>
ip =3D &i;

the two arrows p= oint to different places:

We can now see t= hat the two assignments

ip2 =3D ip;

*ip2 =3D *ip;

do two very different things. The first would make ip2 again p= oint to where ip points (in other words, back to i again). The second would stor= e, at the location pointed to by ip2, a copy of the value pointed to by ip; in other words (if ip and ip2 still point to i and j respectively) it would se= t j to i's value, or 7.

It's important to keep very clear in your mind the distinction between a pointer and what it points to. The two are like apples and oranges (or perhaps oil and water); you can't mix them. You can't ``set= ip to 5'' by writing something like

&nb= sp;

Arrays and Pointers as Function Arguments

Earlier, we learned that functions in C receive co= pies of their arguments. (This means that C uses call by value; it means that a function can modify one of its arguments without modifying the value in the caller.) We didn't say so at the time, but when a function is called, the copies of the arguments are made as if by assignment. But since arrays can'= t be assigned, how can a function receive an array as an argument? The answer wi= ll explain why arrays are an apparent exception to the rule that functions can= not modify their arguments. =

We've been regularly calling a function getline like this

char line[100];=

getline(line, 1= 00);

with the intention that getline read the next line of input in= to the character array line. But in the previous paragraph, we learned that when we mention the name of an array in an expression, the compiler generates a poi= nter to its first element. So the call above is as if we had written =

char line[100];=

getline(&li= ne[0], 100);

In other words, = the getline function does not receive an array of char at all; it actually rece= ives a pointer to char!

As we've seen throughout this chapter, it's straightforward to manipulate the elements of an array using pointers, so there's no particular insurmountable difficulty if getline receives a point= er. One question remains, though: we had been defining getline with its line parameter declared as an array

int getline(char= line[], int max)

&nb= sp;          {

            ...

}

We mentioned tha= t we didn't have to specify a size for the line parameter, with the explanation = that getline really used the array in its caller, where the actual size was specified. But that declaration certainly does look like an array--how can = it work when getline actually receives a pointer?

We mentioned that we didn't have to specify a size for the line parameter, with the explanation that getline really used the array in its caller, where the actual size was specified. But that declaration certainly does look like an array--how can it work when getline actually receives a pointer?

The answer is that the C compiler does a little something behind your back. It knows that whenever you mention an array nam= e in an expression, it (the compiler) generates a pointer to the array's first element. Therefore, it knows that a function can never actually receive an array as a parameter. Therefore, whenever it sees you defining a function t= hat seems to accept an array as a parameter, the compiler quietly pretends that= you had declared it as accepting a pointer, instead. The definition of getline above is compiled exactly as if it had been written.

STRUCTURES AND UNIONS
Structure=

A Structure is a collection of variables under a s= ingle name. These variables can be of different types, and each has a name which = is used to select it from the Structure. A Structure is a convenient way of grouping several pieces of related information together. =

A Structure can be defined as a new named type, th= us extending the number of available types. It can use other Structures, array= s or pointers as some of its members, though this can get complicated unless you= are careful.

Basic Operations of Structure<= /b>

A Structure type is usually defined near to the st= art of a File using a statement. Whi= ch defines and names a new type, allowing its use throughout the program. Structure usually occur just after= the #define and #include statements in a file.=

Xxx struct

     {

   char name[30];

   char course[50];<= /span>

   int age;
   int year;<= /p>
    } student; =

This defines a = new type student variables of type student can be declared as follows.

Str= uct student st_rec;

Notice how simil= ar this is to declaring an int or float. The variable name is st_rec, it has members called name, course, age and year.

Each member of a Structure can be used just like a normal variable, but its name will be a bit longer. To return to the exampl= es above, member name of Structure st_rec will behave just like a normal array= of char, however we refer to it by the name

st_rec.name=

Here the dot is = an operator which selects a member from a Structure. Where we have a pointer t= o a Structure we could dereference the pointer and then use dot as a member selector. This method is a little clumsy to type. Since selecting a member = from a Structure pointer happens frequently, it has its own operator -> which acts as follows. Assume that st_ptr is a pointer to a Structure of type stu= dent We would refer to the name member as

st_ptr -> nam= e

Arrays can also = be Structure member. Element of Structure can be used like other ordinary variable. Structure can also used as array of objects for example.

Union

A union is a variable which may hold (at different times) objects of different sizes and types. That is a union hold only one member at a time. C uses the union statement to create unions, for example.=

union number

   {

     short shortnumbe= r;

     long longnumber;=

     double floatnumb= er;

   } anumber<= /p>
defines a union called number and an instance of it called a number. number is a union tag and acts in the same way as a tag fo= r a Structure. All operation on union like that of Structure.=

Difference between Structure and union is Structure allocate storage space for all the members where as union allow only one member at a time. Application of u= nion is when we need only one member of a Structure for a particular application that = time we can use union.

FILES IN C

This section des= cribes the use of C's input / output facilities for reading and writing Files=

How will we specify that we want to access a parti= cular data File? It would theoretically be possible to mention the name of a File each time it was desired to read from or write to it. But such an approach would have a number of drawbacks. Instead, the usual approach (and the one taken in C's stdio library) is that you mention the name of the File once, = at the time you open it. Thereaf= ter, you use some little token--in this case, the File pointer--which keeps track (both for your sake and the library's) of which File you're talking about. Whenever you want to read from or write to one of the Files you're working with, you identify that File by using its File pointer (that is, the File pointer you obtained when you opened the File. As we'll see, you store File pointers in variables just as you store any other data you manipulate, so i= t is possible to have several Files open, as long as you use distinct variables = to store the File pointers.

You declare a variable to store a File pointer like this:

&nb= sp;          File *fp;

The type File is predefined for you by <stdio.h>. It is = a data Structure which holds the information the standard I/O library needs to keep track of the File for you. For historical reasons, you declare a variable w= hich is a pointer to this File type. The name of the variable can (as for any variable) be anything you choose; it is traditional to use the letters fp in the variable name (since we're talking about a File pointer). If you were reading from two Files at once you'd probably use two File pointers: <= /o:p>

*fp1, *fp2;

If you were reading from one file and writing to another you m= ight declare and input file pointer and an output file pointer.

File *ifp, *ofp;=

Like any pointer variable, a file pointer isn't any good until it's initialized to point to something. (Actually, no variable of any type is much good until you've initialized it.) To actually open a file, and receive the ``token'' which you'll store in your file pointer variable, you call fopen. fopen accepts a file name (as a string) and a mode value indicating among other things whet= her you intend to read or write this file. (The mode variable is also a string.= ) To open the file input.dat for reading you might call

ifp =3D fopen("input.dat", "r");

The mode string "r" indicates reading. Mode "w" indicates writing, so we could open output.dat for output like this.

ofp =3D fopen("output.dat", "w");

The other values= for the mode string are less frequently used. The third major mode is "a"= for append. (If you use "w" to write to a File which already exists, = its old contents will be discarded.) You may also add a + character to the mode string to indicate that you want to both read and write, or a b character to indicate that you want to do ``binary'' (as opposed to text) I/O.

One thing to beware of when opening Files is that = it's an operation which may fail. The requested File might not exist, or it migh= t be protected against reading or writing. (These possibilities ought to be obvi= ous, but it's easy to forget them.) fopen returns a null pointer if it can't open the requested File, and it's important to check for this case before going = off and using fopen's return value as a File pointer. Every call to fopen will typically be followed with a test, like this.

ifp =3D fopen("input.dat", "r");

I&= nbsp;       (ifp =3D =3D NULL)

{

    printf("can't open file\n");

    exi= t or return

&nb= sp;             }

f fopen returns a null pointer, and you store it in your file pointer variable and go off and try to do I/O with it, your program will typically crash.

It's common to collapse the call to fopen and the assignment i= n with the test.

if((ifp =3D fopen("input.dat", "r")) =3D=3D NULL)=

                printf("can'= t open File\n");

    exi= t or return

    }

You don't have to write these ``collapsed'' tests if you're not comfortable with them, but you'll see them in other people's code, so you should be able to read them.

&nb= sp;

I/O with file Pointers

            For = each of the I/O library functions we've been using so far, there's a companion function which accepts an additional File pointer argument telling it where= to read from or write to. The companion function to printf is fprintf, and the File pointer argument comes first. To print a string to the output.dat File= > we opened in the previous section, we might call .

fprintf(ofp, "Hello, world!\n");

The companion function to getchar is getc, and the File pointe= r is its only argument. To read a character from the input.dat File we opened in the previous sect= ion, we might call.

int c;

c =3D getc(ifp);<= /p>
The companion function to putchar is putc, and the File pointer argument comes last. To write a character to output.dat, we could call .

putc(c, ofp);

Our own getline = function calls getchar and so always reads the standard input. We could write a companion fgetline function which reads from an arbitrary File pointer.

#include <std= io.h>

/* Read one line= from fp, */

/* copying it to= line array (but no more than max chars). */

/* Does not place terminating \n in line array. */

/* Returns line = length, or 0 for empty line, or EOF for end-of-file. */

int fgetline(file *fp, char line[],= int max)

{

   int nch =3D 0;

   int c;

   max =3D max - 1; /* leave ro= om for '\0' */

  while((c =3D getc(fp)) !=3D EOF)

   {

     if(c =3D =3D '\n= ')

     break;

     if(nch < max)=

        {

        = line[nch] =3D c;

        = nch =3D nch + 1;

        }

    }

if(c =3D=3D EOF && nch =3D= =3D 0)

      return EOF= ;

      line[nch] = =3D '\0';

      return nch= ;

   }

Now we c= ould read one line from ifp by calling

char line[MAXLINE];

...

fgetline(ifp, line, MAXLINE);=

&nb= sp;

Predefined Streams

Besides the File pointers which we explicitly open= by calling fopen, there are also three predefined streams. stdin is a constant File pointer corresponding to standard input, and stdout is a constant File pointer corresponding to standard output. Both of these can be used anywher= e a File pointer is called for; for example, getchar() is the same as getc(stdi= n) and putchar(c) is the same as putc(c, stdout). The third predefined stream = is stderr. Like stdout, stderr is typically connected to the screen by default. The difference is that stderr is not redirected when the standard output is redirected. For example, under Unix or MS-DOS, when you invoke

program > Fil= e name

anything printed= to stdout is redirected to the File name, but anything printed to stderr still goes to the screen. The intent behind stderr is that it is the ``standard e= rror output''; error messages printed to it will not disappear into an output Fi= le. For example, a more realistic way to print an error message when a File can= 't be opened would be

if((ifp =3D fopen(Filename, "r= ")) =3D =3D NULL)

{

   fprintf(stderr, "can't = open File %s\n", File name);

   exit or return

}=

where File name is a string variable indicating the File name = to be opened. Not only is the error message printed to stderr, but it is also more informative in that it mentions the name of the File that couldn't be opene= d.

Closing Files

Although you can= open multiple Files, there's a limit to how many you can have open at once. If y= our program will open many Files in succession, you'll want to close each one as you're done with it; otherwise the standard I/O library could run out of th= e resources it uses to keep track of open Files. Closing a File simply involves calling fclose with the File pointer as its argument:

fclose(fp);

Calling fclose a= rranges that (if the File was open for output) any last, buffered output is finally written to the File, and that those resources used by the operating system = (and the C library) for this File are released. If you forget to close a File, it will be closed automatically when the program exits.

Reading a Data File

Suppose you wanted to read these numbers into an array. (Actua= lly, the array will be an array of arrays, or a ``multidimensional'' array) We c= an write code to do this by putting together several pieces: the fgetline func= tion we just showed, and the get words function from chapter 10. Assuming that t= he data File is named input.dat, the code would look like this.

#define MAXLINE 100

#define MAXROWS 10

#define MAXCOLS 10

int array[MAXROWS][MAXCOLS];<= /o:p>

char *Filename =3D "input.dat= ";

File *ifp;

char line[MAXLINE];

char *words[MAXCOLS];

int nrows =3D 0;=

int n;

int i;

ifp =3D fopen(Filename, "r&qu= ot;);

   if(ifp =3D=3D NULL)

     {

      fprintf(st= derr, "can't open %s\n", Filename);

      exit(EXIT_FAILURE);

     }

   while(fgetline(ifp, line, MA= XLINE) !=3D EOF)

     {

     if(nrows >=3D= MAXROWS)

        {

        = fprintf(stderr, "too many rows\n");

        = exit(EXIT_FAILURE);

        }

   n =3D getwords(line, words, MAXCOLS);

   for(i =3D 0; i < n; i++)<= o:p>

   array[nrows][i] =3D atoi(wor= ds[i]);

   nrows++;
}

Shorthand	Equivalent
i++; or ++i;	i=3Di+1;
i--; or --i;	i=3Di-1;

Shorthand	Equivalent
i +=3D10 i -=3D10 i *=3D10 i /=3D10=	i =3D i+10 i =3D i-10 i =3D i*10 i =3D i/10

C notation <= /b>	Meaning
=3D=3D	Equal&nbs= p; to
>	&nb= sp; Grater Than
<	Less Than=
>=3D	&nb= sp; = Grater than or equal to
<=3D	= &nb= sp; Less than or equal to
!=3D	= &nb= sp; not equal to =

VARIABLES AND = DATA TYPES<= /o:p>

Assignment Sta= tement The easiest example of an expression is in the assi= gnment statement. An expression is evaluated, and the result is saved in a variabl= e. A simple example might look like y =3D (m * x)= + c This assignment will save the value of the expression in variable y. <= /o:p>

Assignment Sta= tement
The easiest example of an expression is in the assi= gnment statement. An expression is evaluated, and the result is saved in a variabl= e. A simple example might look like

`y =3D (m * x)= + c`
This assignment will save the value of the expression in variable y. <= /o:p>