“C” What is a Language ? ............................................................................................................ 4

(1) Machine Languages :- .................................................................................................... 4 (2) Assembly Languages :- .................................................................................................. 4 (3) Procedure Oriented Languages ...................................................................................... 4

What is language Translators?............................................................................................. 5 (1) Compiler :- ..................................................................................................................... 5 (2) Interpreters :- .................................................................................................................. 5 Difference of Compiler – Interpreter :-................................................................................ 5

Why ‘C’ language ? ............................................................................................................... 5 FEATURES OF C LANGUAGE.......................................................................................... 6

FLEXIBLILITY:.................................................................................................................. 6 PORTABILITY: .................................................................................................................. 6 COMPACTNESS: ............................................................................................................... 6 REUSABILITY: .................................................................................................................. 6

C AS MIDDLE LEVEL LANGUAGE ................................................................................ 6 Problem oriented languages or high languages : ................................................................. 6 Machine oriented languages of Low Level Languages : ..................................................... 6 C as Middle Level Language : ............................................................................................. 6

BASIC STRUCTURE OF C PROGRAM ........................................................................... 7 Documentation Section:....................................................................................................... 7 Link Section:........................................................................................................................ 7 Definition Section: ............................................................................................................... 7 Global Declaration Section : ................................................................................................ 7 Main Function Section :....................................................................................................... 7 Subprogram Or Sub Function Section : ............................................................................... 7

VARIABLES .......................................................................................................................... 8 VARIABLE NAMING CONVENTION............................................................................. 8 KEYWORDS......................................................................................................................... 8

Data Types In C : ................................................................................................................... 8 Character : ............................................................................................................................ 9 Integer : ................................................................................................................................ 9 Float : ................................................................................................................................... 9 Long : ................................................................................................................................. 10

OPERATORS....................................................................................................................... 11 Arithmetic operators :- ....................................................................................................... 11 Relational Operators :- ....................................................................................................... 11 Logical Operators : ........................................................................................................... 12 Assignment Operators:....................................................................................................... 12 Increment and Decrement Operators : ............................................................................... 12 Conditional operators :....................................................................................................... 13 Sizeof Operator : ................................................................................................................ 13 Bitwise operators : ............................................................................................................. 13 The One’s Complement operator :..................................................................................... 13 Logical bit wise operators :................................................................................................ 14 Shift operators :.................................................................................................................. 14 Comma Operator :.............................................................................................................. 14 Precedence and Associativity Table .................................................................................. 15

DATA INPUT AND OUTPUT ........................................................................................... 16 Printf() function : ............................................................................................................... 16

1

Scanf() Function : .............................................................................................................. 17 Single character input – the getchar function : .................................................................. 18 Single character output – The putchar function:................................................................ 18

Decision Control Structure : ............................................................................................... 19 The if-else statement:......................................................................................................... 19

LOOP CONTROL STRUCTURE ..................................................................................... 21 While statement : ............................................................................................................... 21 FOR statement : ................................................................................................................. 23 BREAK STATEMENT: .................................................................................................... 25 CONTINUE STATEMENT .............................................................................................. 25 SWITCH-CASE Statement :.............................................................................................. 26 THE GOTO STATEMENT :............................................................................................. 28

ARRAY...................................................................................................................................... 29 DEFINING AN ARRAY :................................................................................................. 29 Single Dimension Array .................................................................................................... 29 MULTIDIMENTIONAL ARRAY.................................................................................... 29 Two Dimension Array ....................................................................................................... 30 ARRAY AND STRINGS .................................................................................................. 31 The gets and puts functions: .............................................................................................. 31 Strlen() ............................................................................................................................... 32 Strcpy() .............................................................................................................................. 32 Strcat()................................................................................................................................ 32 Strcmp() : ........................................................................................................................... 33 PROCESSING AN ARRAY : ........................................................................................... 33

FUNCTION ............................................................................................................................... 34 DEFINING A FUNCTION : ............................................................................................. 34 ACCESSING A FUNCTION : .......................................................................................... 35 Data-type name(); .............................................................................................................. 36 PASSING ARGUMENT TO A FUNCTIN : .................................................................... 36 SPECIFYING ARGUMENT DATA TYPES ; ................................................................. 36 CATEGORY OF FUNCTION : ........................................................................................ 37 No arguments and not return values: ................................................................................. 37 Arguments with return values :.......................................................................................... 37 RECURSION :................................................................................................................... 37 THE SCPOE AND LIFETIME OF VARIABLES IN FUNCTION : ............................... 38 Automatic variables : ......................................................................................................... 38 External variables : ............................................................................................................ 38 MULTIFILE PROGRAMS : ............................................................................................. 40 Static variables :................................................................................................................. 41 Register variable: ............................................................................................................... 41 PASSING ARRAYS TO A FUNCTION: ......................................................................... 41 PASSING BY BALUE APPROACH................................................................................ 42 PASS BY REFERENCE APPROACH ............................................................................. 43 LIBRARY FUNCTION:.................................................................................................... 43

POINTERS ........................................................................................................................... 44 AND & OPERATORS ...................................................................................................... 44 POINTER DECLARATIONS : ......................................................................................... 45 PASSING POINTER TO A FUNCTION : ....................................................................... 45 POINTER AND ONE DIMENTSIONAL ARRAY.......................................................... 47 OPERATIONS ON POINTERS........................................................................................ 48 POINTERS AND MULTIDIMENSIONAL ARRAYS : .................................................. 48

2

ARRAY OF POINTERS: .................................................................................................. 49 PASSING POINTER TO FUNCTIONS : ......................................................................... 51

Structures ................................................................................................................................... 52 Simple Structures ............................................................................................................... 52 The struct Keyword............................................................................................................ 52 Defining and Declaring Structures..................................................................................... 52 Accessing Structure Members ........................................................................................... 53 Arrays of Structures ........................................................................................................... 54 Pointer To Structure........................................................................................................... 56 Passing Structures as Arguments to Functions .................................................................. 56

FILE MANAGEMENT....................................................................................................... 58 Opening and closing a data file :........................................................................................ 58 Input-output operation on file : .......................................................................................... 59 THE GETC AND PUTC FUNCTIONS :.......................................................................... 59 THE FGETS AND FPUTS FUNCTIONS : ...................................................................... 60 THE FSCANF AND FPRINTF FUNCTIONS : ............................................................... 61 THE FREAD AND FWRITE FUNCTIONS :................................................................... 61 RANDOM ACCESS TO FILES :...................................................................................... 61 ftell : ................................................................................................................................... 61 rewind : .............................................................................................................................. 62

DYNAMIC MEMORY ALLOCATION ........................................................................... 63 Malloc().............................................................................................................................. 63 Calloc() .............................................................................................................................. 63

Program List......................................................................................................................... 64 C Theory ............................................................................................................................... 69

3

“C” WHAT IS A LANGUAGE ? Language is a collection of words and symbols which can be used to perform certain task or activities and to establish a communication between person to person. In the same manner computer languages are the collection of predefine key words which can be used to perform certain task and to communicate between to entities like between two machines or between human and computers or computers and others peripherals. There are three different level of programming languages. They are (1) Machine languages (low level) (2) Assembly languages (3) Procedure Oriented languages (high level) (4) Fourth Generation languages (4 GLS) (1) Machine Languages :- Computers are made of No. of electronic components and they all are two – state electronic components means they understand only the 0 – (pulse) and 1 (non – pulse). Therefore the instruction given to the computer must be written using binary numbers. 1and 0. Computers do not understand English or any other language but they only understand or respond to binary numbers (0 and 1). So each computer has its own Machine languages. (2) Assembly Languages :- As it was very tedious to understand and remember 0’s representing numerous data and instruction. So to resolve this problem mnemonics codes were developed. For example add is used as symbolic code to represent addition. SUB is used for subtraction. They are the symbolic representation of certain combination of binary numbers for example

S U B Which represents certain actions as computer understand only Machine language instructions a program written in Assembly Language must be translated into Machine languages. Before it can be executed this translation if done by another program called assembler. This assembler will translate mnemonic codes into Machine languages. (3) Procedure Oriented Languages In earlier assembly languages assembler programs produced only one Machine languages instruction for every assembly languages instruction. So to resolve this problem now assembler were introduced. Which can produce several machine level instructions for one assembly language instruction. Thus programmer was relieve from the task of writing and instruction for every machine operation performed. These languages contains set of words and symbols and one can write program with the combination of these keywords. These languages are also called high level languages. Basic, Fortran, Pascal and COBOL. The most important characteristic of high level languages is that it is machine independent and a program written in high level languages can be run on any computers with different architecture with no modification or very little modification. .

4

WHAT IS LANGUAGE TRANSLATORS? As we know that computer understand only the instruction written in the Machine language. Therefore a program written in any other language should be translated to Machine language. For this purpose special programs are available they are called translators or language processors. This special programs accept the user program and check each statement and produces a corresponding set of Machine language instructions. There are two types of Translators. (1) Compiler :- A Compiler checks the entire program written by user and if it is free from error and mistakes then produces a complete program in Machine language known as object program. But if it founds some error in program then it does not execute the single statement of the program. So compiler translate whole program in Machine language before it starts execution. (2) Interpreters :- Interpreters performs the similar job like compiler but in different way. It translates (Interprets) one statement at a time and if it is error – free then executes that statement. This continues till the last statement in the program has been translated and executed. Thus Interpreter translates and executes the statement before it goes to next statement. When it founds some error in statement it will immediately stop the execution of the program. Since compiler of Interpreter can translate only a particular language for which it is designed one has to use different compiler for different languages. Difference of Compiler – Interpreter :- Error finding is much easier in Interpreter because it checks and executes each statement at a time. So wherever it fine some error it will stop the execution. Where Compiler first check all the statement for error and provide lists of all the errors in the program.

Interpreter take more time for the execution of a program compared to Compilers because it translates and executes each statement one by one. WHY ‘C’ LANGUAGE ? In early of 1960 there were many languages available but they were used for some specific purpose. For example Cobol was used for commercial application Fortran was used for some scientific and engineering application. So at this stage people were searching some language which can fulfill the need of all type of application. So invention of different language taken place. The ‘C’ language becomes very popular due to its robustness rich set of built in function and operators that can be used to write any complex program. Sr. No. Year Language Developer Remarks 1 1960 ALGOL International Committee Too General, Too Abstract 2 1963 CPL Cambridge University 3 1967 BPCL Martin Richards &

Cambridge University

4 1970 B Kent Thomson at AT&T Laboratory

5 1972 C Denis Ritchie at AT&T Laboratories

Modular,General,

5

FEATURES OF C LANGUAGE There are several reasons why many computer professionals feel that C is at the top of the list : FLEXIBLILITY: C is a powerful and flexible language. C is used for projects as diverse as operating system, word processor, graphics, spreadsheets and even compilers for other language. C is a popular language preferred by professional programmers. As a result, a wide variety of C compilers and helpful accessories are available. PORTABILITY: C is a portable language. Portable means that a C program written for one computer system can be run on another system with little or no modification. Portability is enhanced by the ANSI standard by C, the set of rules for C compilers. COMPACTNESS: C is a language of few words, containing only a handful terms, called keywords, which serve as the base on which the language’s functionality is built. You might think that a language with more keyword would be more powerful. This isn’t true. As you will find that it can be programmed to do any task. REUSABILITY: C is modular, C code can and should be written in routine called functions. These functions can be reused in other applications or programs. By passing pieces of information to the function, you can create useful, reusable code. C AS MIDDLE LEVEL LANGUAGE All programming languages can be divided into two categories: Problem oriented languages or high languages : Examples of languages falling in this category are FORTRAN, BASIC, Pascal, etc. These languages have been designed to give a better programming efficiency, faster program development. Generally these languages have better programming capability but they are less capable to deal with hardware or Hardware related programming. Machine oriented languages of Low Level Languages : Examples of languages falling in this category are Assembly language and Machine Language. This languages have been designed to give a better machine efficiency i.e. faster program execution. Generally these languages have better hardware programming capability but it is very difficult and tedious to do create complex application like and business application or some commercial application

C as Middle Level Language : C stands in between these two categories. That’s why it is called a Middle Level Language, since it was designed to have both; a relatively good programming efficiency (as compared to Machine Oriented Language) and a relatively good machine efficiency (as compared to Problem Oriented Language).

6

BASIC STRUCTURE OF C PROGRAM C program can be viewed a s group of building blocks called functions. A function is a subroutine that may include one or more statement designed to perform a specific task. A C program may contain one or more section as shown below :

• • • • •

DocumentatThis section and purpose Link SectionThis section system librardefine link fo

# incl# incl

Definition SThis section constant one # define PI 3# define TemGlobal DeclaThis section function of thMain FunctiA main() funmore then 1program. AnSubprogramThey are thefunction candefine to solv

Documentation Section Link Section Definition Section Global declaration SectionMain() function section { Declaration Part Executable Part }

Subprogram Section Function1 () { } Function2 () { }

ion Section: contains set of comments lines consist of details like program name, author name or functionality of the program. : consist of instructions to be given to the compiler to link functions from the y. For example if you want to use some mathematical function then you have to r math.h file in link section. For Example ude<stdio.h> ude<math.h> ection: defines all the symbolic constants. For example PI=3.14. By defining symbolic can use these symbolic constant instead of constant value. .14 p 35 ration Section :

contains the declaration of variables which are used by more then more then one e program. on Section : ction is a heart of any ‘C’ language program. Any C program is made up of 1 or function. If there is only 1 function in the program then it must be the main execution of any C program starts with main() function. Or Sub Function Section : code section which are define outside the boundary of main function. This

be called from any point or anywhere from the program. Generally they are e some frequent tasks.

7

VARIABLES A variable is a named data storage location in your computer’s memory. By using a variable’s name in your program, you are, in effect, referring to the data stored there. VARIABLE NAMING CONVENTION To use variables in your C programs, you must know ho to create variable names in C,variables names must adhere to the following rules: • The name can contain letters, digits, and the underscore character(_). • The first character of the name must be a letter. The underscore is also a legal first

character, but its use is not recommended. • Case matters (that is uppercase and lowercase letters). Thus, the names count and Count

refer to two different variables. • C keywords can’t be used as variable names. A keyword is a word that is part of the C

language.

KEYWORDS There are words with specific meaning to “C” language system. They are known as keywords of “C” language. Keyword must not be used as variable names. There are 32 keywords in “C” language. Which are as under :

DAC ldat Va

Ch(sigInte (siFlo(sigDoLon(sigCh (unInte (unUninteLon

Auto double int struct break Else long switch case enum Register typeof char external return Union const float short unsigned Continue for signed void default Goto sizeof volatile do if Static while

TA TYPES IN C : anguage has very rich set of data types. At presently we will go through some of the basic a types available in C.

riable Type Keyword Bytes Required

Range Format

aracter ned)

Char 1 -128 to +127 %c

ger gned)

Int 2 -32768 to +32767 %d

at ned)

Float 4 -3.4e38 to +3.4e38 %f

uble Double 8 -1.7e308 to + 1.7e308 %lf g integer ned)

Long 4 2,147,483,648 to 2,147,438,647

%ld

aracter signed)

Unsigned char 1 0 to 255 %c

ger signed)

Unsigned int 2 0 to 65535 %u

signed long ger

unsigned long 4 0 to 4,294,967,295 %lu

g double Long double 10 -1.7e932 to +1.7e932 %Lf

8

Character : To access and to store single character it use char data type in C. Char data type occupies 1 bytes. It means that char data type use 1 byte of memory to store some character value. Declaration of character variable :

char ans; Assigning values to character variable :

Ans=’y’; 8 7 6 5 4 3 2 1 Sign 27 26 25 24 23 22 21 20 Above given is a general structure of character variable. The leftmost bit is used to indicate the positive or negative value of a variable. So the range for character variable is –27 to 27 –1 .means –128 to 127. Integer : To access and to store any integer value int data type is use. C’s int data type occupies 2 bytes in the memory. To declare any integer variable : Int rollno; Int accno; To assign or to store integer value in this variable: Rollno=10; Accno=100; 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1

Sign

215 214 2 13 212 211 210 2 9 2 8 27 26 25 24 2 3 22 21 20

Above given is a general structure of integer variable. The leftmost bit is used to indicate the positive or negative value of a variable. So the range for integer variable is –215 to 215 –1 .means –32768 to 32767. Float : To access and to store any real value float data type is use. C’s float data type occupies 4 bytes in the memory. To declare any float variable : Float per; Float rate; To Assign or to store some real value Per=70.20; Rate=123.45

9

32 1 Sign

231 20 Above given is a general structure of float variable. The leftmost bit is used to indicate the positive or negative value of a variable. So the range for float variable is –231 to 231 –1 . Means -3.4e38 to +3.4e38 Long : To access and to store any integer value long data type is use. C’s long data type occupies 4 bytes in the memory. To declare any long variable : long account; long price; To Assign or to store some long value account=123456; Rate=98765; 32 1 Sign

231 20 Above given is a general structure of long variable. The leftmost bit is used to indicate the positive or negative value of a variable. So the range for long variable is –231 to 231 –1 . Means - 2,147,483,648 to +2,147,438,647

10

OPERATORS Operator is symbol, which represents, a particular operation that can be performed on some data. The data itself (which can be either a variable or a constant) is called the “operand”. The operator thus operates on operand. They are Classified as (1) Arithmetic (2) relational (3) logical (4) Assignment (5) increment/decrement (6) conditional (7) bitwise (8) special

Arithmetic operators :- There are five arithmetic operators in “C”. They are : OPERATOR PURPOSE + Addition - Subtraction * Multiplication / Division % Remainder after integer division

Examples (Suppose A=10 and B=3) Expression Values A+b 13 a-b 7 A*b 30 A/b 3 A%b 1

Relational Operators :- There are four relational operators in “C”. They are: < less than <= less than or equal to > greater than >= greater than or equal to The associatively of these operators is left-to-right. Closely associated with the relational operator are the following two equality operators : = = equal to

! = not equal to Suppose that i, j and k integer variable whose values are 1,2 and 3 respectively, Seven logical expressions involving these variables are shown below. :

Expression Interpretation Value i<j True 1 (i+j)>=k True 1 (j+k)>(I+5) False 0 K!=3 False 0 J = = 2 True 1

11

Logical Operators : ‘C’ provides three logical operations. They are : Operator Meaning && AND || OR ! NOT These operators are referred to as logical AND logical OR and logical NOT respectively. The following table shows the result of the combined expressions depending on the value of the expression :

Operands Results Exp1 Exp2 Exp1 && exp2 Exp1 || exp2 0 0 0 0 0 Non-zero 0 1 Non-zero 0 0 1 Non-zero Non-zero 1 1

The associatively us left-to-right.

Assignment Operators: Assignment operators are use to form assignment expressions, which assign the value of an expression to an identifier. The most commonly used assignment operator is =. Assignment expression that make use of this operator are written in the form Identifier = Expression a= a+1 a+=1 a=a-1 a-=1 a=a*( c + d) a*=(c + d) a=a/(n-1) a/=(n-1) a=a%10 a%=10 Increment and Decrement Operators : “C” offers two special operator ++ and – called increment and decrement operators, respectively. There are “unary” operators since they operator on only one operand. The operand has to be a variable and not a constant. Thus the expression a++ is valid as 6++ is invalid. The use of these operates resulting incrementing or decrementing value of the variable is 1. So the expression a++ increment the value of a by 1 and the expression a- - decrements a by 1. These operators can be used either before or after their operand. (i.e. in either “prefix” or “postfix” position) so we can have a++(postfix) and ++a (prefix). Prefix and postfix have some effect if they are used in an isolated statement. For example, the effect of the following statements would be same :

a++; ++a;

However prefix and postfix operators have different effects when used in association with some other operator in “c” statement. For example, if we assume the value of a variable to be 5 and then assign that new value to b. The effect is exactly same. If the following two statements have been executed :

12 b = a++; b=++a;

On the other had, execution of the statement b = a++; will be first set the value of b to 5 and then increases the value of a to 6. The effect is now same as if the following statement had been executed :

b = a; b= a+1; [ Note : First precedence : R->L associatively)

Conditional operators : Simple conditional operations can be carried out with the conditional operator (?:) An expression that makes the use of the conditional operator is called a conditional expression. Conditional operators are also known as turnery operators.

Syntax: (condition) ? true : false Exp1 ? Exp2 : Exp3

Here if condition is evaluated as true then value of exp2 will be return and if condition is evaluated as false then exp3 will be return.

For example T=(I<0) ? 0 : 100

If I variable value is less then 0 then condition is evaluated as true and T will be assigned with 0 but if I variable value is greater then 0 then condition is evaluated as false and 100 will be assign to variable T. For example

Printf(“%d”, (I<0) ? 0:100); Sizeof Operator : The size of a compile time operator and when used with an operand, it returns the number of bytes the operand occupies. The operand may be variable, a constant or a data type qualifies. M = sizeof(sum); N= sizeof(long int); K= sizeof(253L); The size of operator is normally used to determine the length of array and structures, when their sizes are not known to the programmer. It is used to allocate memory space dynamically to variable during execution of a program. Bitwise operators : Some applications require the manipulation of individual bits within a word of memory. Assembly language or machine language is normally required for operations of this type. However C contains several special operators that allow such bitwise operations to be carried out easily and efficient. These bitwise operators can be divided into three general categories: the one’s complement operator, the logical bitwise operators, and the shift operators. “c” also contains several operators that combine bitwise operations with ordinary assignment.

The One’s Complement operator : The one’s complement operator (~) is a unary operator that causes the bits of its operand to be inverted (i.e. reversed) so that is become so a so become is. This operator always precedes its operand. The operand must be an integer type quantity (including integer, long, short, unsigned, or char).(Linearly the operand will be an unsigned octal or an unsigned hexadecimal quantity, though this is not a firm requirement.

Suppose int a=16 with 2 byte=16 bit pattern it will be 00000000 00010000 b=~a the b will have 16 bit pattern like 11111111 11101111

13

Logical bit wise operators : There are three logical bitwise operators : bitwise and ($), bitwise exclusive or(^) and bitwise or(!). Each of these operators requires two integer type operands. The operations are carried out independently on each pair of corresponding bits within the two operands will be. Thus the least significant bits( i.e. the rightmost bits) within the two operands will be compared then the least significant bits. And so on. Until these comparisons are :

B1 B2 B1&b2 B1^b2 B1 | b2 1 1 1 0 1 1 0 0 1 1 0 1 0 1 1 0 0 0 0 0

The associatively for each bitwise operator is left-to-right.

Shift operators : The two bitwise shift operator is shift left (<<) and shift right(>>). Each operator requires two operands. The first is an integer-type operand that represents the bit pattern to be shifted. The second is an unsigned integer that indicates the number of displacements (i.e. whether the bits in the first operand will be shifted by 1 bit position, 2 bit position, 3 bit positions and so on). This value cannot exceed the number of bits associated with the word size of the first operand. The left-shift operator causes the left by the bits in the first operand to be shifted to the left by the number of position indicated by the second operand. The leftmost bit positions that become vacant will be tilled with us.

A = 01101101 10110111 A<<6 = 0110 1100 0000 = 0x5dc0

All the bits originally assigned to a are shifted to the left six places, as the arrows indicate. The leftmost 6 bits (originally 011011) are lost. The rightmost 6 bits positions are filled with 00 0000.

The right shift operator causes all the bits in the first operand to be shifted to the right by the number of positions indicated by the second operand. The rightmost bits(i.e. the underflow bits) in the original bit pattern will be lost. If the bit pattern being shifted represents an unsigned integer, then the leftmost bit positions that become vacant will be filled with 0s. Hence, the behavior of the right-shift. When the first operand is an unsigned integer.

A= 0110 1101 1011 0111 A>>6 = 000 0001 1011 0110 = 061bc

We see that all the bits originally assigned to a are shifted to the right six places, as the arrows indicate. The rightmost 6 bits ( originally 11 011) are lost. The leftmost 6 bits positions are filled with 00 0000. Comma Operator : The comma operators are use primarily in conjunction with the for statement. This operator permits two different expressions to upper in situation where only one expression would ordinarily be used. For example, it is possible to write

For(expression la, expression lb; expression2; expression3) Statement Where expression la and lb are the two expression, separated by the comma operator, where only one expression would normally appear. These two expression would typically initialize two separate indices that would be used simultaneously within the for loop. Similarly, a for statement might make use of the comma operator in the following manner.

For(expression 1a; expression2;expression3a, expression3b) statement;

14

Here expression 3a and expression 3b separated by the comma operator, appear in place of the usual single expression. In this application the two separate expressions would typically be used to alter the two different indices used simultaneously within the loop. For example, one index might count forward while the order counts backward. In for loops. For(n=1,m=10; n<=m; m++, n++) Precedence and Associativity Table Precedence is a priority of the operator for evaluation or execution when there are more then 1 operator in a single expression or statement. If there are operators of same precedence then the expression will evaluated either from LEFT-TO-RIGHT or RIGHT-TO-LEFT. This is called an associativity of an operator. Description Operator Associativity Precedence Function expression ( ) L TO R Array expression [ ] L TO R Structure operator -> L TO R Structure operator . R TO L

1

Unary minus - R TO L Increment/Decrement ++ -- R TO L One’s complement R TO L Negation ! R TO L Address of & R TO L Value of address * R TO L Type cast (type) R TO L Size in bytes Size of R TO L

2

Multiplication * L TO R Division / L TO R Modulus % L TO R

3

Addition + L TO R Subtraction - L TO R

4

Left Shift << L TO R Right Shift >> L TO R

5

Less than < L TO R Less than equal to <= L TO R Greater than > L TO R Greater than or equal to >= L TO R

6

Equal to = = L TO R Not equal to != L TO R

7

Bitwise AND & L TO R 8 Bitwise exclusive OR ^ L TO R 9 Bitwise inclusive OR | L TO R 10 Logical AND && L TO R 11 Logical OR || L TO R 12 Conditional ? : R TO L 13 Assignment

= *,= ,/=, %= +=,-=,^=,|=,&= <<=,>>=

R TO L 14

Comma , R TO L 15

15

DATA INPUT AND OUTPUT As we know that any c program is made up of 1 or more then 1 function. Likewise it use some functions for input output process. The most common function are printf() and scanf(). Printf() function : Printf() function is use to display something on the console or to display the value of some variable on the console The general syntax for printf() function is as follows

printf(<”format string”>,<list of variables>); To print some message on the screen

Printf(“God is great”); This will print message “God is great” on the screen or console.

TIn inprHwthInPT T

T FlFprHvasc CchprHva

More Examples: printf(“\nIndia is the best”);printf(“\nVande Matram”); printf(“\nJay Hind”);

o print the value of some variable on the steger Variable :

t a=10; intf(“%d”,a);

ere %d is format string to print some inteill be printed by printf() function. This wiis output interactive by writing them t a=10;

rintf(“a=%d”,a); his will print “a=10” on the screen

o print multiple variable’s value one can uInt p=1000,r=10,n=5; Printf(“amount=%d rate=%d yea

his will print “amount=1000 rate=10 year=

oat Variable : loat per=70.20; intf(“Percentage=%f”,per);

ere %f is format string to print some flolue will be printed by printf() function. Treen.

haracter Variable : ar ans=’Y’; intf(“Answer=%c”,ans);

ere %c is format string to print single chalue will be printed by printf() function. T

Output India is the best Vande Matram Jay Hind

creen

ger value and a is the integer variable whose value ll print value of a “10” on the screen. You can make

se printf() function in following way.

t=%d”,p,r,n); 5” on the screen

at(real) value and per is the float variable whose his will print value of a “Percentage=70.20” on the

racter value and ans is the character variable whose his will print value of a “Answer=Y” on the screen.

16

Suppose we want to print “Amar” on the screen with character variable Char c1=’A’,c2=’m’,c3=’a’,c4=’r’ ; Printf(“Name = %c %c %c %c”,c1,c2,c3,c4); This will print “Name=A m a r” on the screen. You can use single printf() function to print different data type variable’s value also. Example

Int rno=10; Char res=’P’; Float per=75.70; Printf(“Rollno=%d Result=%c Percentage=%f”,rno,res,per);

This will print message “Rollno=10 Result=P Percentage=75.70” on the screen. Scanf() Function : Scanf() function is use to read data from keyboard and to store that data in the variables. The general syntax for scanf() function is as follows.

Scanf(“Format String”,&variable);

Here format string is used to define which type of data it is taking as input this format string can be %c for character, %d for integer variable and %f for float variable. Where as variable the name of memory location or name of the variable and & sign is an operator that tells the compiler the address of the variable where we want to store the value. One can take multiple input of variable with single scanf() function but it is recommended that there should be one variable input with one scanf() function.

Scanf(“Format string1,format string2”,&variable1,&variable2); For Integer Variable :

Int rollno; Scanf(“%d”,&rollno); Printf(“Enter rollno=”);

Here in scanf() function %d is a format string for integer variable and &rollno will give the address of variable rollno to store the value at variable rollno location.. For Float Variable :

Float per; Printf(“Enter Percentage=”); Scanf(“%f”,&per);

Here in scanf() function %f is a format string for float variable and &per will give the address of variable per to store the value at variable per location.

Head

For Character Variable : Char ans; Printf(“Enter answer=”);Scanf(“%c”,&ans);

re in scanf() function %c is a format string for character variable and &ans will give the dress of variable ans to store the value at variable ans location.

17

Single character input – the getchar function : Single characters can be entered into the computer using the “C” library function getchar. The getchar function is a part of the standard “C” language I/O library. It returns a single character from a standard input device (typically a keyboard). The function does not required any arguments through a pair of empty parentheses must follow the word getchar. In general terms, a reference to the getchar function is written as.

Character variable=getchar();

Where character variable refers to some previously declared character variable. A “C” program contains the following statements.

char c; c=getchar();

The first statement declares that c is a character type variable. The second statement causes a single character to be entered from the standard input device and then assigned to c. If an end-of file condition is encountered when reading character with the getchar function, the value of the symbolic constant EOF will automatically be returned. The detection of EOF in this manner offers a convenient way to detect an end of file, whenever and wherever it may occur. Appropriate corrective action can be taken. The getchar function can also be used to read multicharacter strings, by reading one character at a time a multiples loop.

Single character output – The putchar function: Single character can be displayed (i.e. written out of the computer) using the C library function putchar.The putchar function, like getchar is a part of the standard “C” language I/O library. It transmits a single character to a standard output device. The character being transmitted will normally be represented as a character-type variable. It must be expressed as an argument to the function, enclosed in parentheses following the word putchar. In general a reference to the putchar function is written as

Putchar (character variable)

Where character variable refers to some previously declared character variable. A “C” program contains the following statements.:

char c=’a’; putchar(c);

The first statement declares that c is character type variable. The second statement causes the current value of c to be transmitted to the standard output device where it will be displayed. The putchar function can be used to output a one-dimensional, character type array. Each character can then be written separately within a loop. 18

DECISION CONTROL STRUCTURE : The if-else statement: The if-else statement is used to carry out a logical test and then take one of two possible actions depending on the outcome of the test (i.e. whether the outcome is true or false).The else position of the if-else statement is optional. Thus, in its simplest general form, the statement can be written. If(expression)

statement; The expression must be placed in parenthesis, as shown. In this form, the statement will be executed only if the expression has non-zero value (i.e. true). If the expression has a value of zero (i.e. expression is false), then the statement will be ignored. The statement can be either simple or compound. In practice, it is often compound statement, which may include other control statements. The general form of an if statement which include the else clause is

If(expression) statement 1;

else statement 2;

If the expression has a non-zero value (i.e. if expression is true), then statement 1 will be executed. Otherwise, (i.e. expression is false), statement 2 will be executed. It is possible to next if…else statement within one-another, just as we did with loops, there are several different forms that nested if…else two-layer nesting is : In this situation, one can complete if…else statement will be executed if expression is nonzero(true) and another complete if else statement will be executed if expression is false (zero). It is of course, possible that statement 1, statement2, statement3 and statement4 will contain another if…else statements. We would then have multi layer nesting. Some other forms of two layer are :

If<exp1> {

statement1; } else {

if<exp2> {

statement2; }

}

19

if<exp1> { if<exp2> { statement1;

} else { statement2; }

else {

statement3; }

if<exp1> {

statement1; } else { if<exp2>

{ statement2;

} else

{ statement3;

} }

if<expr1> { if<exp2>

{ statement1; }

else { statement2; } }

20

LOOP CONTROL STRUCTURE If we want to perform certain action for no of times or we want to execute same statement or a group of statement repeatedly then we can use different type of loop structure available in C. Basically there are 3 types of loop structure available in C (1) While loop (2) Do..while (3) For loop While statement : The while statement is used to carry out looping operations. The general form of the statements

Initialization; While(exp) { statement 1; statement 2;

increment/ decrement; }

The enclose statements within two braces will be executed repeatedly as long as the expression evaluated as true. When the expression is evaluate a false or when condition will be false then it will come out from the loop and stop the execution of that loop. Initialization statement initialize some memory variable with some value. Increment or decrement operator increase or decrease the value of operator is use by expression. This statement can be simple of compound, though it is typically a compound statement, it must include some features, which eventually offers the value of expression, thus provides a stopping condition for the loop.

The practice, the included expression is usually a logical expression that is either true or false. (remember that true corresponds to non-zero value and false corresponds to zero value). Thus the statement will continue to execute as long as the logical expression is true.

The part of while statement, which contains the statement, is called the body of the loop. Body of the loop may have one or more statements. The braces are needed only if the body contains two or more statements. However, it is a good practice to use braces even if the body has only one statement. Suppose we want to display the consecutive digits 0,1,2,3,…9 with one digit on the each line. This can be accomplished with the following program.

Initiallyincrease

#include<stdio.h> main () {

int digit = 0; while(digit<=9) {

printf(“%d \n”,digit); ++digit ;

} }

, digit is assigned a value of 0. The while loop then displays the current value of digit, s its value by 1 and then repeats the cycle, until the value of the loop will be repeated

21

by 10 times, resulting in 10 consecutive lines of output. Each line will contain a successive integer value, beginning with and ending with 9. Thus when the program to run, the following output will be generated :

0 1 2 3 4 5 6 7 8 9 Do-While statement :

Sometimes, however, it is desirable to have a loop with the test for continuation at the end or each pass. This can be accomplished by means of the do-while statement. The general form of do-while statement is

Do {

statement1; statement2; increment/decrement operator;

} while(expression);

The enclosed statement within 2 braces will be executed repeatedly as the value of expression is not zero. Notice that statement will always be executed at least once. Since the test for repetition does not occur until the end of the first pass through the loop. The statement can be either simple or compound, though most applications will require it to be a compound statement. It must include some feature which eventually alters the value of expression so that the looping action can terminate. Since the expression is evaluated at the bottom of the loop, the do…while loop construct provides an exit… controlled loop and therefore the body of the loop is always executed at least once.

In practice, expression is usually a logical expression, which is either true(with a non zero value) or a false(with a value of 0). The included statement will be repeated (i.e. another pass will be made through the loop) if the logical expression is true.

For most applications it is more natural to test for continuation of a loop at the beginning rather than at the end of the loop for this reason, the do…while statement is use less frequently than while statement. Suppose that we want to display consecutive 0,1,2,3,…9 with one digit on each line. This can be accomplished with the following program.

#include <stdio.h> main() {

int digit = 0; do

{ printf(“%d”, digit++);

}while(digit<=9); }

22

The digit is initially assigned a value of 0. The do while loop displays the current value of digit. Increases it value by 1, and then tests to see if the current value of digit exceeds 0. If so loop terminates; otherwise the loop continues, using the new value of digit. Note that the last is carried out at the end of each pass through the loop. The net effect is that the loop repeated 10 times, resulting in 10 successive lines of output. Thus, when the program is run the following output is generated :

0 1 2 3 4 5 6 7 8 9 FOR statement : The for statement is another entry controller that provides a more concise loop control structure. The general form of the for loop is :

For(initialization, test condition, increment)

{ statement 1; statement 2;

}

The execution of the for statement is as follows : 1. Initialization of the control variables is done first, using assignments statement such as

I=0 and count=0. The variables I and count are known as loop controls. 2. The value of the control variables is tested using the test condition. The test condition is

relational expression, such as I>0 or I<10 that determines when the loop is terminated and the execution continues with statement that immediately follows the loop.

3. When the body of the loop is executed, the control is transferred back to the for statement either evaluating the last statement is the loop. Now, the control variable is incremented using and assignment statement such as I=I+1 and if the new value of the control is satisfied under test condition, then the body of the loop is executed. This process continues till the value of the control variable fails to satisfy the test-condition.

(a) Consider the following segment of a program :

This for loop is execwithin parentheses mend of the increment

The for statement allbe written as follows

For(x=0; x<9; x++) { printf(“%d”, x);

printf(“\n”); }

uted 10 times and prints the digits 0 to 9 in one line. The three sections ust be separated by a semicolons. Note that there is no semicolon at eh section x++.

ows for negative increments. For example, the loop discussed above can :

For(x=9; x>=0; x--) { Printf(“%d”,x0 Printf(“/n”); }

23

This loop is also executed 10 times. But the output would be from 9 to 0 instead of 0 to 9. Note that, braces are optional when the body of the loop contains only one statement.

Additional features of for loop : The for loop in C has several capabilities that are not found in the other loop constructs. For example, more than one variable can be initialized at a time in the for statement.

For(n=1,m=50; n<m; n++, m--) { p=m/n; printf(“%d%d%d \n”,n,m,p); }

This is perfectly valid. The multiple arguments in the increment section are separated by commas. The third feature is that the test condition may have nay compound relation and the testing need not be limited only to the loop control variable. Consider the example below :

Sum=0; For(I=1;I<20 && sum<100; I++) { sum=sum+I; printf((“%d \n”, sum); }

The loop uses a compound test condition with the control variable; and external variable sum. The loop is executed as long as both the conditions I<20 and sum<100 are true. The sum is evaluated inside the loop. It is also permissible to use expressions in the assignment statements of initialization and increment sections, For example, a statement of the type : For(z=(m+n)/2; x<0;x=x/2) is perfectly valid. Another unique aspect of the for loop is that one or more sections can be omitted, if necessary. Consider the following statements :

M=0; for(;m!=100;) { printf(“%d \n”, m); m=m+5; }

Both the initialization and increment sections are omitted in the for statement. The initialization has been done before the for statement and the control variable is incremented inside the loop. In such cases the sections are left blank. However, the semicolons separating the sections must remain. If the test condition is not present, the for statement sets up an

24

infinite loop. Such loops can be broken using break or go-to statements in the loop. We can set up time delay loop using the null statement as follow: For(j=1000;j>0;j--) {} The loop executed 1000 times without producing any output; it simply causes a time delay. Notice that the body of the loop contains only a semicolon, known as null statement. This can also be written as : For(I=1000; I>0; I--); This implies that C compiler will not give an error message. If we place a semicolon by mistake at the end of a for statement. The semicolon will be considered as a null statement and the program may produce some nonsense. Loops can be nested (i.e. embedded) one within another. The inner and outer loops need not be generated by the same type of control structure. It is essential that one loop be completely embedded within the other. There can be no overlap. Also each loop must be controlled by a different index. BREAK STATEMENT: The break statement is used to terminate loops or to exit a switch. The break statement will break or terminate the inner-most loop. It can be used within a while, a do-while, a for or a switch statement. The break statement is written simply as break; Without any embedded expressions or statement. For example,

The output wfor loop. CONTINUEThe continuIt does not structure. It

The output oskipped as w

For(I=1; I<=10; I++) { if(I==5) break; printf(“\nI=%d”,I);}

ill be 1,2,3,4 and then break will terminate this loop and stop the execution of the

STATEMENT e statement is used to skip or to bypass some step or iteration of looping structure. terminate the loop but just skip or bypass the particular sequence of the loop is simply written as continue;.

For(I=1; I<=10; I++) {

if(I==5) continue;

printf(“\nI=%d”,I); }

f the above program will be 1,2,3,4,6,7,8,9,10. The 5th iteration of the loop will be e have define the continue for that iteration. So it will not print the value ‘5’.

25

SWITCH-CASE Statement : The switch statement causes a particular group of statements to be chosen from several available groups. The selection is based upon the current value of an expression that is included within a switch statement. The general form of switch-case statement is :

Switch(expression) {

Case expression1 Statement1; Statement2; Case expression2 Statement1; Statement2; Case expression3 Statement1; Statement2; }

Usually each of these expression will be written as either an integer constant or a character constant. Each individual statement following the case labels may be either simple or complex. Where expression1 1, expression 2,………,expression m represent constant, integer valued expression .When switch statement is executed the expression is evaluated and control is transferred directly to the group of statements whose case labels value matches the value of the expression. If none of the case-label values matches the value of the expression, then non of the groups within the switch statement w8ll be selected in this case control is transferred directly to the statement that follows the switch statement. Example :

Switch (choice=getchar()) { case ‘r’ case ‘R’ printf(“RED”); break; case ‘w’ case ‘W’ printf(“WHITE”); break; case ‘b’ case ‘B’ printf(“BLUE”);

break; }

Thus RED will be displayed if choice represents either r or R, WHITE will be display choice represents either w or W and BLUE will be displayed if choice represents either b or B. Nothing will be displayed if any other character has been assigned to choice. Notice that each group of statements has two case labels, to account for either upper or lower case. Also, note that each of the first two group ends with the break statement. The break statement causes

26

control to be transferred out of the switch statement thus preventing more than one group of statement from being executed. One of the labeled groups of statements within the switch statement may be labeled default. This group will be selected if none of the case labels matches the value of expression. The default group may appear anywhere within the switch statement. It need not necessary be placed at the end. If none the case labels matches the value of the expression and the default group is present, then the statement will take no action. Here is a variation of switch statement :

none odefaulexpres Each oare nocharaccase cthe usfor eq Noticeof the order requirstatemhas a statem

Switch(choice=toupper(getchar()) { case ‘R’ : printf(“RED”); break; case ‘B’ : printf(“BLUE”); break; case ‘W’ : printf(“WHITE”); break; default : printf(“ERROR”); break; }

The switch statement now contains a default group, which generates an error message if f the case labels matches the original expression. Each switch statement now contains a t group, which generates an error message if none of the case labels matches the original sions.

f the first three groups of statements now has only one case labels. Multiple case labels t necessary in the example, since the library function toupper causes all incoming ters to be converted to the upper case. Hence choice will always be assigned an upper haracter. In a special sense, the switch statement may be thought of as an alternative to e of nested if-else statements, though it can only replace those if else statements that tests uality. In such situations using the switch statement is generally much more convenient.

that each group of statement ends with a break statement in order to transfer control out switch statement. The break statement is required within each of the first three groups in to prevent the succeeding groups of statement from executing. This last group does not e a break statement since control will automatically be transferred out of the switch ent after the last group has been executed. This last break statement is included, however matter of good programming practice. So that it will be present, if another group of ent is added later.

27

THE GOTO STATEMENT : The goto statement is used to alter the normal sequence of program execution by transferring control to some other part of the program. In its general for the goto statement is written as goto label; Where label is an identifier used to label the target statement to which control will be transferred. Control may be transferred to any other statement within the program. The target statement must be labeled and the label must be followed by a color. Thus the target statement will appear as label : statement. Each labeled statement within the program must have unique label, i.e. no two statement can have same label. The common application of goto are :

1. Branching around statement or groups of statements under conditions. 2. Jumping to the end of a loop under certain conditions, thus by passing the reminder

of the loop during the loop during the current pass. 3. Jumping completely out of a loop under certain conditions, thus terminating the

execution of the loop. Branching ground statement can be accomplished with the if-else statement, jumping to the end of a loop can be carried out with the continue statement, and jumping out of a loop easily completed using the break statement. The uses of these structured features are preferable to the used of the goto statement because the use of goto tends to encourage logic that skips all over the program.

Occasional situations do arise, however, in which the goto statement can be useful. Consider, for example, a situation in which it is necessary to jump out of a doubly nested loop if a certain conditions are detected. This can be accomplished with two if break statements. One within each loop, though this is awaked. A batter solution in this particular situation might make user of the goto statement to transfer out of both loops at once. 28

ARRAY Array is a collection or group of similar data type elements stored in contiguous memory. The individual data items can be characters, integers, floating points numbers and so on . Here contiguous memory allocation means array occupies contiguous bytes as needed in the memory. DEFINING AN ARRAY : Arrays are defined in much the same manner as ordinary variables. Except that each array name must be accompanied by a size specification number of elements for a one-dimensional array. The size specified by positive integer expression enclosed in square brackets. The expression is usually written as a positive integer constants. For example if we want to declare an array of 10 integer values then we can define it as following. The general form is

Storage class data type array[expression] = {vlaue1, value2,…valuen}

Single Dimension Array Int a[10]; a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]

2 bytes

2 bytes

2 bytes

2 bytes

2 bytes

2 bytes

2 bytes

2 bytes

2 bytes

2 bytes

2001 2003 2005 2007 2009 2011 2013 2015 2017 2019

Each array elements is referred to by specifying the array name followed by one or more subscripts. With each subscript enclosed in square brackets. Each subscript must be expressed as a non-negative integer : thus in the n- element array x, the array elements arr[0], arr[1], arr[2]…arr[n-1]. The value of each subscript can be expressed as an integer constant, an integer variable or a more complex integer expression. The number of subscripts determines the dimensionality of the array. For example, x[I] refers to an element in the one dimensional array x. Similarly y[I][j] refers to an element in the two dimensional array..

MULTIDIMENTIONAL ARRAY

Multidimensional, array is defined in much the same manner as one-dimensional arrays, except that a separate pair of square brackets is required for each subscript. Thus a two dimensional array will require two pairs of square brackets, three dimensional array will require three pairs of square brackets and so on.

In general terms, a multidimensional array definition can be written as Storage_class data_type array[exp1][exp2]…[expn];

Where storage class refers to the storage class of the array, data type is its data type. Array is the array name and exp1, exp2,… expn are positive valued expressions that indicate the number of array element associated with each subscript. The storage class is optional, the default values are automatic for arrays that are defined inside of a function, and external for arrays defined outside of a function.

29

For example, Float table [50][50]; Char page[24][80]; Static double records[100][66][255]; Static double records[L][M][N];

Two Dimension Array Int a[5][5];

0 1 2 3 4

A[0][0] A[0][1] A[0][2] A[0][3] A[0][4] A[1][0] A[1][1] A[1][2] A[1][3] A[1][4] A[2][0] A[2][1] A[2][2] A[2][3] A[2][4] A[3][0] A[3][1] A[3][2] A[3][3] A[3][4] A[4][0] A[4][1] A[4][2] A[4][3] A[4][4]

The first line defines table as a floating point array having 50 rows and 50 columns (hence 50 x 50 = 2500 elements) and the second line establishes page as a character array with 24 rows and 80 columns (24 x 80 =1920 elements), the third array can be thought of as a set of double precision tables, each having 66 lines and 266 columns (hence 100 x 66 x 255 = 1,683,000 elements).

The last definition is similar to the preceding definition except that the symbolic constant L,M,N defines the array size. Thus the values assigned to these symbolic constant will determine the actual size of the array.

If a multidimensional array definition includes the assignment of initial values, then care must be given to the order in which the initial values are assigned to the array elements(remember only external and static arrays can be initialized). The rule is that the last (right most) subscript increases most rapidly and the first(left most) subscript increases least rapidly. Thus the elements of a two-dimensional array will be assigned by rows, that is the element of the first row will be assigned, then the element of the second row and so on.

For example, consider following two-dimensional array definition :

Int values[3][4] = {1,2,3,4,5,6,7,8,9,10,11.13};

Note that values can be thought of a table having three rows and for columns (four element per row.) Since the initial values are assigned by rows (i.e. last subscript including most rapidly, the results this initial assignment are as follows:

Value[0][0] = 1 Value[0][1] = 2 Value[0][2] = 3Value[0][3] = 4 Value[1][0] = 5 Value[1][1] = 6 Value[1][2] = 7 Value[1][3] = 8 Value[2][0] = 9 Value[2][1] = 10 Value[2][2] = 11 Value[2][3] = 12

30

Remembers that the first subscript ranges from 0 to 2 and the second ranges from 0 to 3. This example can be written as :

The natural oinitial valuesassigned to dimensional aelement of rowithin a pair hand, the num

Multidimensielement-by-elarrays to a funmust include size specificaprogram. Thewith a one-dim

At individualzero. This incassigned non

The array sizarray definitioof initial valu ARRAY ANDThe gets and

The gets andstandard inpuargument muinclude whitewill terminateRETURN key

The gets and and displayinline of text in

Int values[4][3] {

{1,2,3}, {4,5,6}, {7,8,9}, 10,11,12}

};

rder in which the initial values are assigned can be altered by forming groups of enclosed in braces. The values within each innermost pair of braces will be those array element whose last subscript changes most rapidly. In a two rray, for example, the value within the inner pair of braces will be assigned to the w, since the second subscript increase most rapidly. If there array two few values of braces, the remaining elements of that row will be assigned zeros. On the other ber of values within each pair of braces cannot be exceed the defined row size.

onal arrays are processed in the same manners as one-dimensional arrays, an ement basis. However, some care is required when passing multidimensional ction. In particular, the formal argument declarations within a function definition

explicit size specifications in all of the subscript positions except the first. These tion must be consistent with the corresponding size specifications in the calling first subscript position may be written as an empty pair of square brackets as ensional array.

array element that are not assigned explicit values will automatically to set to ludes the remaining elements of an array in which certain elements have been

zero values.

e need not be specified explicitly when initial values are included as a part of an n, with a numerical array, the size will automatically be set equal to the number

es included within the definition.

STRINGS puts functions:

puts functions facilitate the transfer of strings between the computer and the t/output devices. Each of these functions accepts a single argument. The

st be a data item that represents a string(e.g. character array). The string may space characters. In the case of gets, the string will enter from the keyboard and with a new line character(i.e. the string will end when the user presses the ).

puts functions offer simple alternatives to the use of scan f and printf for reading g strings, as illustrated in the following example. Here is a program that reads a to the computer and then writes it back out in its original form :

31

#include<stdio.h> main() {

char inne[80]; gets(line); puts(line); }

This program utilizes gets and puts to transfer the line of text into and out of the computer. Most C compilers include library functions that allow strings to be compared. Copied or concatenated. Other functions permit operations on individual character within strings. For example, they allow individual characters to be found within strings and so on. The following example illustrate the use of some of these library functions :

Strlen() This function counts a number of characters present in a string while giving a call to the function we are to pass the base address of the string. Total numbers of characters of the stings are counted without counting null character, returning length of the string.

Static char msg[] = “Lord krishna”; Int n; N=strlen(msg); Printf(“length of string =%d”, n);

Strcpy() This function copies the contents of one string to another. The base address of source and target strings are supplied to the function.

Static char source[] = “Lord Krishna”; Static char target[15]; Strcpy(target, source); Printf(“Source string is : %s”, source); Printf(“target string is :%s”,target);

Strcat() This function concatenates the source string at the end of target sting.

Static char s[] = “Lord”; Static char t[] = “Krishna”; Strcat(t,s); Printf(“source string is %s\n”, s); Printf(“target stirng is %s\n”, t);

This function compare two strings to find out whether they are same of different. The process of character wise comparison continues till a mismatch is attained or – end of string. If two strings are identical, it returns a values zero, if they are not, it returns numeric difference between ASCII values of non-matching characters. 32

Strcmp() : This function compares two strings and returns some integer value. If both the strings are equal then it returns 0 otherwise it returns some other integer value.

Main() { static char s1[]=”Jerry”; static char s2[]=”Ferry”; static char s3[]=”jerry boy” int I,j,k; I = strcmp(s1, “jerry”); J= strcmp(s1, s2); J=strcmp(s1, s3); Printf(“%d %d %d”, I,j,k); }

PROCESSING AN ARRAY : Single operations involving entire arrays are not permitted in C. thus if a and b are similar arrays, assignment operations. Comparison operations, and so on must be carried out on an element-by-element basis. This is usually accomplished within a loop where each pass of loop will therefore equal the number of array elements to be passed. For example,

#include<stdoio.h> #define EOL ‘\n’; main() { char letters[80]; int tag, count=0; while(letter[count] = getchar() != EOL) count ++; tag = count; count=0;

while(count<tag) {

putchar(toupper(letter[count])); ++count;

} }

33

FUNCTION DEFINING A FUNCTION : A function has three principal components :

the first line, the argument declarations the body of the function

The first line of a function definition contains the byte specification of the value returned byte the function, followed by the function name and (optionally) a set of parameters separated by comas and enclosed in parenthesis. The type specification can be omitted if the function returns an integer or a character, in entry pair of parenthesis must follow the function name if the function definition does not include any arguments. In general terms, the first line can be written as :

Data-type name(formal arg1, arg2, argn)

Where data type represents the data type of the value, which is returned, and name represents the function name.

The formal argument allows information to be transferred from the calling portion of the program to the function. They are also known as parameter on formal parameters.(the corresponding arguments in the functions reference are called actual arguments since they define the information actually being transferred. The identifiers used as formal argument are local in the sense that they are not recognized outside of the function. Hence, the names of the formal arguments may be same as the names of the other identifiers that appear outside the function definition. The argument declaration follows the first time. All format arguments must be declared at the point in the function. Each format argument must have the same data type as its corresponding actual arguments. That is each formal argument must be of the same data type as the data items it receives from the calling portion of the program. The remainder of the function definition is a compound statement that defines the action to be taken by the function. This command statement is sometimes referred to as the body of the function. It must follow the formal argument declarations. Like any other compound statements, the statement can contain expression statements. Other compound statement, control statements, and so on. As a result it can even access itself. This process is known as recursion. For example,

Low-to-up(Char el) {

char c2 c2 = c1>=’a’ && c1<=’z’) ? (‘A’+cl-‘a’) : cl;

return c2; }

34

The first line contains the title, low-to-up followed by the formal argument cl, within is enclosed n parameters. Note that g1 represents the lowercase character that is transferred to function from the calling portion of the program. Notice that this function returns a character content which actually an integer value. Therefore, a type specification is not required in the first line. It would be permissible, however, to write the first line as Char low-to-up(c1) The first formal argument c1 is declared to be a char – type. The body of the function follows this. Which begins on the third line. Notice that the body contains the declaration of the local char-type variable c2. following the declaration of a statement that tests whether c1 represents a lowercase letter. Finally, the program information is returned from the function to the calling portion of the program via the return statement. The return statement also causes control to be returned to the point from which the function was accessed. In general terms, the return statement is written as return(expression); The value of the expression is returned to the calling portion of the program. The expression is optional. However, a return statement can be written without it. If the expression is omitted , the return statement simply causes control to never back to the calling porting of the program, without any information transfer. Now let us momentarily return to the function type specification, which appears in the first line of the function definition. This type specification can be omitted if the function returns an integer quantity or a character. If the function returns different type of quantity, such as a long integer, floating point or double precision quantity, however, the first line of the function definition must include a corresponding type specification. Now suppose the data type specified in the first line is inconsistent with the expression that appears in the return statement. Under such conditions the compiler will attempt to convert the quantity to be represented by the expression that the data type specified in the first line. This could result in a compilation error, as it might in value a partial loss of data. ACCESSING A FUNCTION : A function can be accessed (i.e. called) by specifying its name, followed by a list of arguments enclosed in parentheses and separated by commas. If the function call does not require any arguments, an empty pair of parenthesis must follow the function’s name. The function call may appear to itself (that is, it may comprise a simple expression), and it may be one of the operands within a more complex expression. The arguments appearing in the function call are referred to as actual arguments. In contrast, to the formal arguments that appear in the first line of the function definition.(they are also known simply as arguments or as actual parameters). In a normal function call there will be one actual argument for each formal argument. The actual arguments may be expressed as constants, single variables, or more complex expressions. However, actual argument must be of the same type as its corresponding formal arguments. There may are several different calls to the same function from various places within a program. The actual argument may differ from one function call to another, within each function call, however, the actual argument must correspond to the formal arguments in the 35

function definition.; i.e. the number of actual argument must be same as the number of formal argument and each actual arguments must be of the same data as its corresponding for argument. If a function returns a non-integer quantity and the portion of the program containing the function call precedes the function definition, then there must be a function declaration in the calling position of the program. This is sometimes referred to as a forward declaration. The function declaration effectively informs the compiler that a function will be accessed before it is defined. In its simplest form, a function declaration can be written as, Data-type name(); Where data-type refers to the data type of the quantity returned by the function and name refers to the function name. Function calls can span several levels within a program; function A can call function B which can call function C and so on. Also function a can call function c directly, and so on. PASSING ARGUMENT TO A FUNCTIN : When a single value is passed to a function via an actual argument. The value of actual argument is copied to the function. Therefore, the value of the corresponding formal argument can be altered within the function. But the value of the actual argument within the calling routine will not change. This procedure for passing the value of an argument i/o a function is known as passing by value. Passing an argument by value has advantages and disadvantages on the plus. It allow a single-value used actual argument to be written as an expression rather than, being restricted to a single variable. Moreover, if the actual argument is expressed as a single variable. It prevents information from being transferred back the calling portion of the program via arguments. Thus, passing by value is restricted to a one-way transfer of information. Array is passed differently than single-valued entities. If an array name is specified as an actual argument the individual array elements are not copied to the function. Instead, the location of the array (i.e. the location of the first element) is passed to the function. If an element of the array is accessed within the function; the access will refer to the location of the array element relative the location of the first element. Thus any alteration to an array element within the function will carry over to the calling routine. SPECIFYING ARGUMENT DATA TYPES ; An additional reason for including a function declaration within the calling portion of a program it is possible to include the data type of the arguments within the function declaration. The compiler will then convert the value of each actual argument to the declared data type ( if necessary ) and then compare each (converted) actual data type with the corresponding formal function declarations will allow the programmers to be informal of data type, inconsistencies detected during the compilation process. When the argument data types are specified in a function declaration; the general form of the function declaration can be written as : Data-type name(argument type1, argument type2,… argument typen); 36

Where data type represents the data type of the quantity returned by the function, name represents the function name and argument type 1 argument type 2 … argument type n refers to argument data types of the first argument, second argument and so on. Remember that the argument data type are optional even in the situations that requires a function declaration. Most C compilers supports the use of the keyword void in function definition as a return data type indicating that the function does not return anything. Function declaration may also include void for the same purpose. In addition void may appear in an argument list, in both function definition and function declarations, to indicate that a function does not require arguments. In the later case, void appears by itself in the area normally used for argument specifications. CATEGORY OF FUNCTION : A function, depending and where argument are present or not and where a value is returned or not, may belong to one of the following categories. No arguments and not return values: When a function has no arguments, it does not receive a data from the calling function. Similarly, when it does not return a value, the calling function does not receive any data from calling function. In fact, there is not data transfer between the calling function and the called function. We would ensure that the function call has matching arguments. In case, the actual arguments are more than the formal arguments, extra actual arguments are discarded. On the hand, if the actual arguments are less than the formal arguments, the unmatched formal arguments are initialized to some garbage values. Any mismatch in data type may also result in passing of garbage value. Remember no error message will be generated. While the formal arguments must be void variable names; the actual arguments may be variable name expression or constants. The variable used in actual arguments may be assigned values before the function call is made. Arguments with return values : When function is called with arguments, then called function will receive the arguments. Then the statement included within the body at the called function will be executed. RECURSION : Recursion is a process by which a function calls itself repeatedly, until some specified condition has been satisfied. The process is used for repetitive computation in which each action is stated on forms of previous result. The process is used for repetitive computation in which each action in terms of a previous result. Many iterative problems can be written in this form. In order to solve a problem recursively, two condition must be satisfied. First, the problem must be written in recursive form and second the problem example, we wish to calculate the factorial of a positive integer quantity. We would normally express this problem as n1=1 x 2 x 3 x 4 … x n where n is the specified positive integer. However, we can also express in another way, by writing n=1 = n*(n-1). This is a recursive statement of the problem, in which last expression provides a stopping condition for the recursion. 37

When a recursive program is executed the recursive function calls are not executed immediately. Rather, they are placed on a stack until the condition that terminates the recursion is encountered. The function calls are then executed in reverse order, as they are popped off the stack. If a recursive function contains local variables, a different set of local variables will be created during each call. The name of the local variables, will be cause always be the same, as declared within the function. However, the variables will represent a different set of values each time the function is executed. Each set of values will be stored on the stack, so that they will be available as the recursive process “unwinds” i.e. as the various function calls are “popped” off the stack and executed. THE SCPOE AND LIFETIME OF VARIABLES IN FUNCTION : A variable in C can have any one of the four storage classes : Automatic variables : Automatic variables are declared inside a function in which they are to be utilized. They are created when the function is called and destroyed automatically when the function is exited, hence the name automatic. Automatic variables are therefore private to the function in which they are declared. Because of this property, automatic variables are also referred to as local or internal variable. A variable declared inside a function without storage class specifications, by default, an automatic number in the example below is automatic.

One important feature of automatic variable is that their value cannot be changed accidentally. This assures that we may declare and use the same variable name in different function in the same program without causing any confusion to the compiler. There two consequences of the scope and longevity of auto variables. First any variable local to main will normally live throughout the whole program, although, it is active only in main. Secondly, during recursion, the nested variables are unique auto variables, a situation similar to function, nested auto variable with identical names.

Automatic, variable can also be defined within a set of braces known as “blocks” they are meaningful only inside the block where they are defined.

External variables : Variables that are both alive and active throughout the entire program are known as external variables. They are also known as global variables. Unlike function in the program external variables are declared outside a function. For example the external declaration of integer number and float length might appear is :

Int number; Float length = 7.5; Main() { --- --- }

38

function1() { --- --- } function2() { --- --- }

the variables number and length are available for use in all the three functions. In case a local variable and a global variable have the same name, the local variable will have preceded over the global variable in the function where it is declared.

Once a variable has been declared as global, any function can use it and change its value. Then subsequent function can reference only that new value. Because of this property, we should try to use global variables only for tables of for variables shard between functions when it is inconvenient to pass them as parameters.

One other aspect of a global variable is that it is visible only form the point of declaration to the end of the program.

Note that the extern declaration does not allocate storage space for variables. In case of arrays, the definition should include their size as well.

An extern within a function provides the type information to just that one function. We can provide type information to all function within a file by placing external declaration before any of them, as shown below.

Extern float height [] Main () { int t; void printout(); --- --- printout(); } void printout () { int t; --- --- } float height(size);

39

MULTIFILE PROGRAMS : Multiple source files can share a variable provided it is declared as an external variable appropriately variable that are shared by two or more files are global variables and therefore must declared them according in one file and then explicitly define them with extern in other files. The extern specifies tells the compiler that the following variables types and names have already been declared elsewhere and now need to create storage space for them. For example,

the extern, declaratglobal in two diffewhich variable to uand accessed in oidentifies the functfunction. Althoughexplicitly declare s

File 1.c Main() { extern int m; int l; --- --- } function1() { int j; --- --- } file 2.c int m; function2() { int il; --- --- } function3() { int count; --- --- }

ion in place where secondary reference are made, if we declare a variable as rent files used by a single, program then the linker will have a conflict as to se and therefore, is use a warning. When a function is defined in one file ther, the later file must include a function declaration. The declaration ion we usually place such declarations at the beginning of the file, before all all functions are assumed to be external, it would be good practice to

uch functions with the storage class extern.

40

Static variables : As the name suggest, the value of static exist until the end of the program. A variable can be declared static using the keyword static like:

Static int x; Static float y;

A static variable may be either an internal type or an external type depending on the piece of declaration. Internal static variables are those which are declared inside a function. The scope of internal static variable extend up to the end of the function in which they are defined. Therefore, internal static variable are similar to auto variables, except that they remain in existence throughout the remainder of the program. Therefore, internal static variables can be used to retain values between function calls.

A static variable is initialized only once, when the program is compiled. It is never initialized again. An external static variable is declared outside that program. The difference between a static external variable and simple external variable is that the static external variable is available only within the file where it is defined while the simple external variables can be accessed by other files.

It is possible to control the scope of the function. For example, we would like a particular function accessible only to the function in the file in which it is defined. And not to function in other files. This can be accomplished by defining that function with the storage class static.

Register variable: We can tell the compiler that a variable should be kept in one of the machine’s register instead of keeping in the memory where normal variables are stored. Since a register access is much faster than a memory access. Keeping frequently accessed variables in the register will lead to faster execution of program. This is done as follows :

Register int count;

Since only a few variables can be placed in the register, it is important to carefully select the variable for the purpose. PASSING ARRAYS TO A FUNCTION:

An array name can be used as an argument to a function, thus permitting the entire array to be passed to the function. The manner in which the array is passed differs mainly. However, from that of an ordinary variable.

To pass an array to a function, the array mane must appear by itself without brackets or subscripts as an actual argument within the function call. The corresponding format argument is written in the same manner, though it must be declared as an array within the formal argument declaration. When declaring array as a format argument, the array name is written with a pair of empty square brackets. The size of the array is not specified within the format argument declaration.

The following program outline illustrates the passing of an array from the main portion of the program to the function :

41

Main() { int n; float avg; float list[100]; float average(int a, float x[]); --- --- avg = average(n,list); --- } float average(n,x) { int a; float x[]; --- ---

}

within main we see a call to the function average. This function call contains two actual argument the integer variable n and the one-dimensional floating-point array list. Notice that list appears as an ordinary variable within the function call. In the first line of the function definition we see two formal arguments, called a and x. the formal argument declarations establish a as an integer variable and x as an one-dimensional floating point array. Thus there is a correspondence between the actual argument list and the formal argument x. note that the size of x is not specified within the formal argument.

If the first line of a function definition includes the formal argument declaration, each array name appearing as a formal argument must be followed by an empty pair of square braces. We can pass the elements of array to the function in two ways :

• pass by value approach • pass by reference approach

PASSING BY BALUE APPROACH

When each element of array is passed one by one to the functions as an actual argument, at that time element behaves as an ordinary variable. This manner of passing array value is called pass by value approach. In such cases, formal argument need not be an array. It may be any ordinary variable. That element then be accessed throughout the function and then control returns to the calling function, that alteration can not be recognized in the calling portion of the program because passing element process will make a copy of original element to the formal argument.

42

PASS BY REFERENCE APPROACH

When an array is passed to a function, however the values of the array elements are not passed to the function. Rather the array name is interpreted as address of the first array element (i.e. the address of the memory location containing the first array element). This address is assigned to the corresponding format argument when function is called. The formal argument therefore becomes a pointer to the first array element. Argument passed in this manner are said to be passed by reference.

When a reference is mad to an array element within the function, the value of the element subscript is added to the value of the pointer to indicate the address of the specified array element. Therefore any array element can be accessed from within the function, alteration will be recognized in the calling portion of the program.

The return statement cannot be used to return an array. Therefore, if the elements of an array are to be passed back to the calling portion of the program, the array must either be defined as an external array whose scope includes both the function and the calling portion of the program, or it must be passed to the function as a formal arguments. LIBRARY FUNCTION: Library functions are routines that carry out various commonly used operations or calculations. They are contained within one or more library files that accompany each C compiler. During the process of converting a C source program into an executable object program, the compiled source program is linked with the library final program will be assembled from two or more separate files, even though the original source program may have been contained within a single file. The source program must therefore include declarations for the library functions, just as it would for programmer’s defined functions that are defined in separate files. C places the required library function declaration in special source files, called header files. Most C compilers include several header files, each of which contains declarations that are functionally related. For example, stdio.h is a header file containing declaration for i/o routines; math.h contains declarations for certain mathematical function and so on. The header files also contain other information related to the use of the library functions, such as symbolic constant definitions.

The required header files must be merged with the source program during the compilation process. This is accomplished by placing one or more #include statements at eh beginning of the source program or at the beginning of the individual files.

Machine independence is a significant advantage in this approach to the use of library function and header files. The machine independent features can be provided as library function, as characters contain or as macros that are included within the header files. A typical C program will therefore run on many different computers without alteration. Provided the appropriate ability resulting from this approach is a major contributor to the popularity of C. 43

POINTERS

A pointer is a variable that represents the location of a data item, such as a variable or an array element. Pointers have a number of useful applications. For example, pointer can be used to pass information back and forth between a function and a reference point. In particular, other provides a way to return multiple data items from a function via arguments. Pointer also permits references to other functions to be specified as arguments to a given function. This has the effect of passing function as arguments to the given functions. Pointers are also closely associated with arrays and therefore provide an alternative way to access individual array elements. AND & OPERATORS Suppose v is a variable that represents some particular data item. The address location can be determined by the expression &v. where & is a unary operator called the address operator. That evaluates the address of its operand.

Now let us assign the address of v to another variable pv. Thus pv = &v; This new variable is called pointer to v. since it “points to” the location where v is stored in address, not its value. Thus pv is referred to as a pointer variable. The relationship between pv and v is illustrated in the following figure.

The data item raccessed by the expresoperates only on a poi(i.e. contents of same mwill both represent theassumed that u and v a

The unary operators &operators. This group arithmetic operators. T

The address operator(&ordinary variables or arithmetic expressions

The indirection operatoto v (i.e. pv=&v) thecorresponding variableassignment statement. of an ordinary variable

Pointer variables can pvariables. Thus a poinpv=&v). also a pointeprovided both pointer variable can be assigne

address of v

epresented by v. (i.e. the dsion *pv where * is a unarynter variable. Therefore, *pemory cell). Furthermore,

same value. i.e. the value re declared to have the same

and * are members of theof operators has a higher he associativity of the unary

) must act upon operand single array elements. Th

such as 2*(u+v).

r(*) can only act upon opern an expression such as * v. thus an indirect refere

This provides another meth (e.g. v) within a more comp

oint to numeric or characterter variable can be assigner can be assigned the valuvariables point to data itemd a null (zero ) value.

44

value of v

ata item stored in v’s memory cells) can be operator called the indication operator, that v and v both represent the same data item. if we write pv = &v and u=*pv then u and v of v will indirectly be assigned to u. (it is data type).

same precedence group as the other unary precedence than the groups containing the operators is right to left.

associated with unique addresses. Such as us the address operator cannot act upon

ands that are pointers. However, if pv points pv can be used interchangeably with its nce can also appear on the left side and

od for assigning a value to an array element licated expression.

variables, arrays, functions or other pointer d the address of an ordinary variable (i.e. e of another pointer variable (i.e. pv=px) s of the same type. More over, a pointer

POINTER DECLARATIONS : Pointer variables, like all other variables, must be declared before, they may be used in C program. When a pointer variable is declared, the variable name must be preceded by an asterisk(*). This identifies the fact that the variable is a pointer. The data type that appears in the declaration refers to the object of the pointer. i.e. the data item that is stored in the address represented by the pointer, rather than the pointer itself.

Thus a pointer declaration may be written in general terms as :

Data_type *ptvar;

Where ptvar is the name of the pointer variable and data type refers to the data type of the pointer object. Remember that an asterisk must precede ptvar.

For example,

Float u,v; Float *pv; --- pv = &v;

The first line declares u and v to be floating point variables. The second line declares pv to be a pointer whose object is a floating-point quantity. i.e. pv points to a floating point quantity. note that pv represents an address not a floating-point quantity. An asterisk should not be included in the assignment statement.

Within a variable declaration, a pointer variable can be initialized by assigning in the address of another variable, remember that the variable whose address is assigned to the pointer variable must have been declared earlier in the program, for example,

Float u,v; Float *pv=&v;

PASSING POINTER TO A FUNCTION : Pointers are often passed to a function as arguments. This allows data items within the calling portion of the program to be accessed by the function altered within the function and then returned to the calling portion of the program in altered form. We refer to this use of pointer as passing of arguments by reference (or by address or by location).

When an argument is passed by value, the data item is copied to the function. Thus any alteration made to the data item within the function is not carried over into the calling routine. When an argument is passed by reference, however (i.e. when a pointer is passed to a function) the address of a data item is passed to the function. The contents of that address can be accessed freely, either within the function or within the calling routine. More over change that is made to the data item(i.e. to the contents of the address) will be recognized in both the function and the calling routine, thus the use of pointer as a function argument permits the corresponding data item to be altered globally from within the function. When pointers are used as argument to a function the formal arguments that are pointers must each be preceded by an asterisk. Also, if a function declaration is included in the coding portion of the program. The data type of each argument that corresponds to a pointer must be followed by an asterisk. Both these points are illustrated in the following example :

45

#include <stdio.h> main() {

int n=1, v=3; void fun2(int pu, int *pv) ; printf(“ \n after calling func2 : u=%d v=%d “ , u,v) ;

} void fun2(int *pu, int *pv) {

*pu=0 ; *pv=0 ; printf(\n within fun2 pu=%d pv=%d”, pu,*pv); return;

}

here, fun2 receives two pointer to integer variables as its arguments. The arguments are identified as pointers by the indirection operators (i.e. the asterisk) that appear in the argument declaration, in addition declaration indicates that the pointers represents the integer quantities.

Within fun2, the contents of the pointer address are reassigned the values 0.0; since, the address are recognized in both fun2 and main, the reassigned values will be recognized within main after the call to fun2, therefore, the integer variables u and v will have accessed indirectly, by referencing the pu and pv. This is necessary because the variable u and v are not recognized such as within fun2.

The items in parentheses identify the arguments as pointers to integer quantities. The pointer variable, pu and pv have not been declared elsewhere in main.In the declaration of the formal argument within the first line of fun2, that is void func2(int *pv, int *pv) .The formal arguments pu and pv are consistent with the dummy arguments in the function prototype. In this example the corresponding variable names are the same though this is generally not required.

An array name is actually a pointer to the array. i.e. the array name represents the address of the first element in the array. therefore, an array name is treated as pointer when it is passed to a function. However, it is not necessary to precede the array names with an ampersand within the function call. An array name that appears as a formal argument within a function definition can be declared either as a pointer or as an array of unspecified size.

It is possible to pass a portion of an array, rather than an entire array, to a function. To do so, the address of the first array element to be passed must be specified with the argument. The remainder of the array, starting with specified array element, will then be passed to the function.

A function can also return a pointer to the calling portion of the program. The do so, the function definition and any corresponding function declaration must indicate that the function will return a pointer. this is accomplished by preceding the function name with an asterisk. The asterisk must appear in both the function definition and the function declaration.

46

POINTER AND ONE DIMENTSIONAL ARRAY If x is a one-dimensional array, then the address of the first array element can be expressed as either &x[0] or simply x. moreover, the address of the second array element can be written as either &x[1] or as (x+1). And so on. In general the address of I+1 th array element is expressed as (x+I). Since x[1] and (x+1) both represent the address of 1 element of x. it would seem reasonable that x[1] and *(x+1) both represent the contents of that address. i.e. the value of the 1st element of x for example.

#include <stdio.h> main() { static int x[5] = {10, 11, 12, 14}; int I; for(I=0; I<5; I++) printf(“\n I=%d x[I]=%function *(x+I)=%d &x[I] = %d(x+I)%d”, x[I], *(x+I),&x[I],x+I); }

executing this program results the following output : I=0 x[I]=10 *(x+I)=10 &x[I]=72 x+I=72 I=1 x[I]=11 *(x+I)=11 &x[I]=74 x+I=74 I=2 x[I]=12 *(x+I)=12 &x[I]=76 x+I=76 I=3 x[I]=13 *(x+I)=13 &x[I]=78 x+I=78 I=4 x[I]=14 *(x+I)=14 &x[I]=7A x+I=7A

We can see that the value of the ith array element can be represented either x[I] or x[I+1] and the address of the ith element can be represented by either &x[I] or x+i. When assigning a value an array element such as x[I], the left side of the assignment statement may be written as either x[I] or as *(x+I). Thus a value may be assigned directly to an array element or it may be assigned to the memory area whose address is arbitrary address to an array name or to an array element. Thus expression such as (x+1) and &x[I] cannot appear on the left side of an assignment a\statement. For example. these four statement are all equivalent.

Line[2] = line[1]; Line[2] = *(line+1); *(Line+2) = line[1]; *(Line+2) = *(line+1);

The address pf an array element cannot be assigned to some other array element. We cannot write a statement such as.

&line[2] = &line[1]; we can assign the value of one array element to another through a pointer. if we wish, for example,

pl = &line[I] line[2]=*pi pl = line+l; *(line+2) = *pl;

47

numeric array element cannot be assigned initial values if the array is defined as a pointer variable. Therefore a conventional array definition is required if initial values will be assigned to the element of a numerical array. however, a character type pointer variable can be assigned an entire string as a part of the variable declaration. Thus a string can conveniently be represented by either a non-dimensional array or a character pointer. OPERATIONS ON POINTERS In particular an integer value can be added to or subtracted from a pointer variable though the resulting expression must be interpreted very carefully. Suppose for example that, px is the pointer variable representing the address of the same variable x, we can write expressions such as ++px, --px, (px+3), (px-1), where I is an integer variable. Such expression will represent an address located some distance of the integer quantity and the number of bytes or words associated with the data item to which px points. Suppose for example, that px points to an integer quantity, and each integer quantity requires 2 bytes of memory. Then the expression (px+3) will result in an address 6 bytes beyond the integer to which px points as illustrated following ;

Px-> 2 bytes v (px+3)

One pointer variable can be subtracted from another provided both pointer point to element of the same array. the resulting value indicates the number of words or bytes separating the corresponding array elements.

Pointer variable can be compared provided both variable point to object of the same data type. Such comparisons can test for either quality or inequality. Moreover, a pointer variable can be computed with 0.

The permissible operations on pointers are summarized below :

1. a pointer variable can be assigned the address of an ordinary variable (e.g. pv=&v) 2. a pointer variable can be assigned the value of another pointer variable (e.g. pv=px)

provided both pointers points to the object of the same data type. 3. a pointer variable can be assigned a null(zero) value (e.g. pv=null) 4. an integer quantity can be added to or subtracted from a pointer variable (e.g. pv+3,

++pv, pv-1) 5. one pointer variable can be subtracted from another provided both pointer points to the

element of the same array. 6. the pointer variables can be compared provided both pointers point to the object of the

same type.

Other arithmetic operations on pointers are not allowed. Thus a pointer variable cannot be multiplied by a constant. Two pointer variables cannot be added and so on. POINTERS AND MULTIDIMENSIONAL ARRAYS : A two dimensional array, for example is actually a collection of one-dimensional arrays . therefore, we can define a two dimensional array as a pointer to a group of contiguous one-dimensional arrays. A two-dimensional array declaration can be written Data-type (*ptvar) expression 2; This concept can be generalized to higher dimensional arrays that is Data-type (*ptvar) [expression 2][expression 3] … [expression n]; 48

In these declarations data type refers to the data type of the array. ptvar is the name of the pointer variable. Array is the corresponding array name an expression 1, expression 2, … expression n are positive –valued integer expression that indicate the maximum number of array element associated with each subscript. The parentheses that surround the array name should normally be evaluated right to left. Suppose that x is a two-dimensional integer array having 10 rows and 20 columns. We can declare x as a Int(*x)[20]; In this declaration, x is defined to be a pointer to a group of contiguous, one-dimensional 20 element integer arrays. Thus x points to the first 20-element array, which is actually the first row (row 0) of the original two-dimensional array. Similarly, (x+1) points to the second 20 elements array. which is the second row(row 1) of the original two-dimensional array and so on. An individual array element within a multidimensional array can also be accessed by repeatedly using the indirection operator. Usually, however this procedure is more awkward then the conventional method for accessing an array element. The following example illustrates the use of the indirection operator. Suppose that x is a two dimensional integer array having 10 rows and 20 columns, as declared as Int(*x) [20]; The item in row2, column 5 can be accessed by working either. X[2][5] or *(*(x+2)+5) Here, (x+2) is a pointer to row 2, therefore, the object of this pointer *(x+2), refers to the entire row since row2 is a one-dimensional array. *(x+2) is actually a pointer to the first element in row 2. we now add 5 to the pointer. hence, (*(x+2)+5) is a pointer to element 5 in row 2. the object of this pointer, refers to the item in column 5 or row 2 which is x[2][5]. ARRAY OF POINTERS: A multidimensional array can be expressed in terms of an array of pointers rather than as a pointer to a group of contiguous arrays. In such situations the newly defined array will have one less dimension that the original multidimensional array. such pointer will indicated the beginning of separate (n-1) dimensional array. In general terms a two-dimensional array can be defined as one-dimensional array of pointes by writing Data-type *array(expression 1); Similarly an n-dimensional array can be defined as (n-1) dimensional array of pointer by writing, Data-type *array[expression 1][expression 2]…[expression n]; 49

In these declaration data type refers to the data type of the original n-dimensional array. array is the array name and expression 1, expression 2, expression n are positive valued integer expressions that indicate the maximum number of element associated with each subscript. A right-to-left rule first associates the pairs of square brackets with array, defining the named object as an array. the preceding asterisk then establishes that the array will contain pointers. The last (the right most) expression is when defining an array of pointers. Where as the first (the left most) expression is omitted when defining a pointer to a group of arrays. When an n-dimensional array expressed in this manner an individual array element within the n-dimensional array can be accessed by a single use of the indirection operator for example, We can define x as a one dimensional array of pointers by writing Int *x[10]; Hence, x[0] points to the beginning of the first row, x[1] points to the beginning of the second row and so on. Note that the number of element within each row is not explicitly specified. An individual array element, such as x[2][5] can be accessed by writing, *(x[2]+5) In this expression, x[2] is a pointer to the first element in row 2 so that x[2] +5 points to element 5 within row 2. the object of this pointer, *(x[2] +5) therefore refers to x[2][5]. Now consider a three-dimensional floating-point array t. suppose the dimension of t is 10 x 20 x 30. this array can be expressed as a two-dimensional array of pointers by writing Float *t[10][20]; Therefore we have 200 pointers, each pointing to a one-dimensional array. an individual array element, such as t[2][3][5] can be accessed by writing *(t[2][3]+5) In this expression, t[2][3] is a pointer to the first element in the one-dimensional array represented by t[2][3]. Hence (t[2][3]+5) points to element 5 within this array. the object of this pointer *(t[2][3]+5) therefore represents t[2][3][5]. Pointer arrays offer a particularly convenient method for storing strings. In this situation, each array element is a character type pointer that indicated the beginning of separate string. Thus an n-element array can be point to n different strings. Each individual string can be accessed by referring to its corresponding pointer. For example, char name[10][12]; here name contains 10 rows to accommodate the 10 strings. Each row must be large enough to store at least 12 characters. A better way to do this is to define a 10 element of pointer, that is, Char *name[10]; Thus, name[0] will indicate the first name. Name[1] will indicate the second name and so on. Just as individual strings can be accessed by referring to the corresponding pointers. (i.e. corresponding array element). So can individual string element be accessed through the use of 50

the indirection operator. For example, *(*(name+2)+3) refers to the forth character in the third string of the array name. If the element of the array is sting pointers, a set of initial values can be specified as a part of the array declaration. In such cases the initial values will be strings, where each string corresponds to a separate array element. Remember however that an array must be declared static if it is initialize within a function. For example

Static char *name[5] = { “pacific”, “Atlantic”, “Indian”, “Caribbean”, “Bering” };

in this example, name is a 5-element array of pointers. The first array element (i.e. the first pointer ) will point to Pacific, the second element will points to Atlantic, and so on. PASSING POINTER TO FUNCTIONS : Pointer parameters are commonly employed in string functions. Consider the function copy which copies one sting to another. Copy(s1,s2); Char *s1, *s2;

51

Structures Simple Structures A structure is a collection of one or more variables types grouped under a single name for easy manipulation. The variables in a structure, unlike those in an array, can be of different variable types. A structure can contain any of C's data types, including arrays and other structures. Each variable within a structure is called a member of the structure. The struct Keyword

Defining and Declaring Structures

The svariabipulatisimplestruct given instanwithoustructu NO 2 Byt

struct tag { structure_member(s); /* additional statements may go here */ } instance;

2001

Struct student { int no; char nm[5]; float per; }; struct student S1;

truct keyword is used to declare structures. A structure is a collection of one or more les (structure_members) that have been grouped under a single name for easy man-on. The variables don't have to be of the same variable type, nor do they have to be variables. Structures also can hold arrays, pointers, and other structures.The keyword identifies the beginning of a structure definition. It's followed by a tag that is the name to the structure. Following the tag are the structure members, enclosed in braces. An ce, the actual declaration of a structure, can also be defined. If you define the structure t the instance, it's just a template that can be used later in a program to declare res. Here s1 is student kind of variable which has 3 members no,name and per.

NAME Per es 5 Bytes 4 Bytes

2002 2003 2004 2005 2006 2007 2008 2009 2010 2011

Struct student{ int no; char nm[5]; float per; }S1,S2;

52

These statements define the structure type student and declare two structure variable S1 and S2 of type studnet. S1 and S2 are each instances of type student Each structure variable contains 3 members no, name and per.

Accessing Structure Members Individual structure members can be used like other variables of the same type. Structure members are accessed using the structure member operator (.), also called the dot operator, between the structure name and the member name. Thus variable s1 can be access in following way S1.no=10; S1.name=”AMAR”; S1.per=80; To display the screen locations stored in the structure variable s1, you could write printf("%d,%s,%f", s1.no, s1.name,s1.per); At this point, you might be wondering what the advantage is of using structures rather than individual variables. One major advantage is that you can copy information between structures of the same type with a simple equation statement. Continuing with the preceding example, the statement S2 = S1; is equivalent to this statement: S2.no=S1.no=; S2.name=S1.name; S2.per=S1.per; When your program uses complex structures with many members, this notation can be a great time-saver. Other advantages of structures will become apparent as you learn some advanced techniques. In general, you'll find structures to be useful whenever information of different variable types needs to be treated as a group. For example, in a mailing list database, each entry could be a structure, and each piece of information (name, address, city, and so on) could be a structure member. Example 1 /* Declare a structure template called SSN */

struct SSN { int first_three; char dash1; int second_two; char dash2; int last_four; }

/* Use the structure template */ struct SSN customer_ssn;

53

Example 2 /* Declare a structure and instance together */

Examp/* Decla

ArraysIf you cyou candone. Yto workexampleeach pe

A phonof muchdefined struct eThis stastructurthese strcreationthe dataelement list[1] =

struct date { char month[2]; char day[2]; char year[4]; } cur_date;

le 3 re and initialize a structure */

struct time { int hours; int minutes; int seconds; } time_of_birth = { 8, 45, 0 };

of Structures an have structures that contain arrays, can you also have arrays of structures? You bet ! In fact, arrays of structures are very powerful programming tools. Here's how it's ou've seen how a structure definition can be tailored to fit the data your program needs with. Usually a program needs to work with more than one instance of the data. For , in a program to maintain a list of phone numbers, you can define a structure to hold

rson's name and number:

struct entry { char fname[10]; char lname[12]; char phone[8]; };

e list must hold many entries, however, so a single instance of the entry structure isn't use. What you need is an array of structures of type entry. After the structure has been

, you can declare an array as follows:

ntry list[1000]; tement declares an array named list that contains 1,000 elements. Each element is a e of type entry and is identified by subscript like other array element types. Each of uctures has three elements, each of which is an array of type char. This entire complex is diagrammed in When you have declared the array of structures, you can manipulate in many ways. For example, to assign the data in one array element to another array , you would write

list[5];

54

This statement assigns to each member of the structure list[1] the values contained in the corresponding members of list[5]. You can also move data between individual structure members. The statement strcpy(list[1].phone, list[5].phone); copies the string in list[5].phone to list[1].phone. If you want to, you can also move data between individual elements of the structure member arrays: list[5].phone[1] = list[2].phone[3]; This statement moves the second character of list[5]'s phone number to the fourth position in list[2]'s phone number. (Don't forget that subscripts start at offset 0.) Listing 11.3 demonstrates the use of arrays of structures. Moreover, it demonstrates arrays of structures that contain arrays as members. Example

#include <stdio.h> /* Define a structure to hold entries. */ struct entry { char fname[20]; char lname[20]; char phone[10]; }; /* Declare an array of structures. */ struct entry list[4]; int i; main() { /* Loop to input data for four people. */ for (i = 0; i < 4; i++) { printf("\nEnter first name: "); scanf("%s", list[i].fname); printf("Enter last name: "); scanf("%s", list[i].lname); printf("Enter phone in 123-4567 format: "); scanf("%s", list[i].phone); } /* Print two blank lines. */ printf("\n\n"); /* Loop to display data. */ for (i = 0; i < 4; i++) { printf("Name: %s %s", list[i].fname, list[i].lname); printf("\t\tPhone: %s\n", list[i].phone); } return 0;

}

55

Pointer To Structure We can also address or point the structure variable with structure pointer itself. Also we can access the members of structure variable with the pointer variable

The PasLikshouseof m Ex

/* /*

# include<stdio.h> Void main() { struct emp { int empno; char nm[20]; float sal;

}; struct emp e1={10,”RAJ”,10000}; Struct emp *p; P=&e1; Printf(“%d %s %f”,e1.empno,e1.nm,e1.sal); Printf(“%d %s %f”,p empno,p nm,p sal);

}

operator is used to refer to the structure elements with pointer.

sing Structures as Arguments to Functions e other data types, a structure can be passed as an argument to a function. Listing 11.5 ws how to do this. This program is a modification of the program shown in Listing 11.2. It s a function to display data on the screen, whereas Listing 11.2 uses statements that are part

ain().

ample

#include <stdio.h> /* Declare and define a structure to hold the data. */ struct data { float amount; char fname[30]; char lname[30]; } rec; void print_rec(struct data x) { printf("\nDonor %s %s gave $%.2f.\n", x.fname, x.lname,x.amount); }

The function prototype. The function has no return value, */ and it takes a structure of type data as its one argument. */

56

main() { /* Input the data from the keyboard. */ printf("Enter the donor's first and lastnames,\n"); printf("separated by a space: "); scanf("%s %s", rec.fname, rec.lname); printf("\nEnter the donation amount: "); scanf("%f", &rec.amount); /* Call the display function. */ print_rec( rec ); return 0; }

57

FILE MANAGEMENT

A file is a place on the disk where a group of related date is stored. Some basic file operation can be given as :

naming a file opening a file reading data from a file writing data to a file closing a file

Opening and closing a data file : When working with a file steps it to establish a buffer area, where information is temporarily stored while being transferred between the computer’s memory and the data file. This buffer area allows information to be read from or written to the data file more rapidly then would otherwise be possible. The buffer area is established by writing FILE *ptvar; Where FILE (uppercase required) is a special structure type that establishes the buffer area and ptvar is a pointer variable that indicates the beginning of the buffer area. The structure type file is defined with a system include file : typically stdio.h A data file must be opened or created before it can be created or processed. Thus associates the file name with the buffer area. It also specifies how the data file will be utilized. That is a read only file, a write-only file or a read/write file, in which both operations are permitted. The library function fopen is used to open a file. This function is typically written as : Ptvar = fopen(file_name, file_type) Where file_name and file_type are strings that represents the name of the data file and the manner in which the data file will be utilized, respectively. The name chosen for the file_name must be consistent within the rules for naming files, as determined by the computer’s operating system. The file_type must be one of the strings shown in the following table : File_type meaning “r” open an existing file for reading only.

“w” open a new file for writing only. If the file with specified file_name currently exists it will be destroyed and new file is created in its place.

“a” open an existing file for appending. A new file will be created if the file with the specific file_name does not exist.

“r+” open an existing file for both reading and writing. “w+” open a new file for both reading and writing. If a file with

the specified file_name currently exists, it will be destroyed and a new file is created in its place.

“a+” open an existing file for reading and writing. A new file will be created if the file with the specified file_name does not exist.

58

The fopen function returns a pointer to the beginning of the buffer area associated with the file. A NULL value is returned if the file cannot be opened as for example, when and existing file cannot be found. Finally a data file must be closed at eh end of the program. This ensures that all outstanding information associated with the file is flushed out from the buffers and all links to the file are broken. It also prevents any accidental misuse of the file. In case there is a limit to the number of files that can be kept open simultaneously, closing of unwanted file might help open the required files. Another instance, where we have to close a file is when we want to reopen the same file in a different mode. This can be accomplished with the library function fclose. The syntax is simply : fclose(fptvar); Example

Input-output op THE GETC AN The simplest filetime. Assume tha fpWrites the charapointer fpt. Simimode. For examp CWould read chacharacter positioTherefore, the re For example,

#include <stdio.h> main() {

FILE *fpt; Fpt=fopen(“simple.dat”,”w”);fclose(fpt);

}

eration on file :

D PUTC FUNCTIONS :

i/o functions are fgetc and fputc. These are used to handle one character at a t a file is opened with mode w and file point fpt. Then, the statement utc(c,fpt); cter contained in the character variable c to the file associated with FILE larly getc is used to read character from a file that has been opened in read le, the statement

= fgetc(fp2); racter from file whose file pointer is fp2. the file pointer moves by one n for every operation of getc and putc. The getc will have been reached. ading should be terminated when EOF is encountered.

59

Main() { FILE *fp; Char c; Fp = fopen(“input”, “w”); While(c=getchar()) != EOF) { fputc(c,fp); } fclose(fp); f1 = fopen(“input”,”r”); while(c=fgetc(f1)) != EOF)

{ printf(“%c”,c); }

fclose(f1); }

THE FGETS AND FPUTS FUNCTIONS : These functions are used to handle a string at a time. Assume that a file is open in the write mode and file pointer is fp1, then the statement Fputs(s,fp1); Writes the string contained in the character arrays to the file associated with FILE pointer fp1. similarly, fgets is used to read a string of particular length from a file that has been opened in read mode. For example, Fgets(s,79,fp1); Would read string of 79 character from the file whose file pointer is fp1. The fgets will return NULL character when reached at the end of file. Therefore the reading should be terminated when NULL is encountered. For example,

#include<stdio.h> main() { FILE *fp; Char c[80]; Fp = fopen(“INPUT”, “w”); While(strlen(getc(c)>0) { fputs(c,fp); fputc(“\n”, c); }

fclose(fp) ; fp = fopen(« INPUT », « r ») ; while(gets(c,79, fp) = NULL) printf(“%s \n”,c); fclose(fp);

}

60

THE FSCANF AND FPRINTF FUNCTIONS : These functions are used to read or write in formatted from from/to the files. The general form of fprintf is Fprintf(f1, “%s%d%function”, name, age, 7.5); Here f1 is the file pointer name is an array variable of type character, age is integer variable. The general form of fcanf is :

Fscanf(fp, “control string”, list); This statement would cause the reading of the items in the list from the file specified by fp, according to the specifications contained in the control string. For example, Fcanf(f2, “%s” “%d” ”%f”, item, qty,price); Fcanf returns the number of items that are successfully read. When the end of the file is reached, it returns the value of EOF. THE FREAD AND FWRITE FUNCTIONS : Some applications involve the use of data files to store blocks of data, where each block consists of a fixed number of contiguous bytes. Each block will generally represent a complete data structure, such as a structure or an array. for such applications it may be desirable to read the entire block from the data file or write the entire block to the file. The library function fread and fwrite are intended to be used in situations of this size of the data block, the number of data block being transferred and file pointer. thus typical fwrite and fread functions : Fwrite(&customer, sizeof(record),1,fpt); Fread(&customer, sizeof(record),1,fpt) Where customer is a structure variable of type record and fpt is the file pointer associated with the data file that has been opened for input/output. Once an unformatted data file has been created with fwrite, it can be read with fread function. The function returns a zero value if an end-of-file condition has been detected and non-zero value if an end-of-file is not detected. Hence, a program that reads an unformatted data file can be reading file, as long as the value returned by fread is non-zero value. RANDOM ACCESS TO FILES : There are occasions however, when we are interested in accessing only a particular part of a file and not in reading the other parts. This can be achieved with the help of the function fseek, ftell and rewind available in the library. ftell : ftell take a file pointer and returns a number of type long that corresponds to the current portion. This function is useful in saving the current position of a file, which can be used in the program. It takes the following form.

N =ftell(fp); N would give the relative offset (n bytes) of the current position. This means that n bytes have already bean read.

61

rewind : rewind takes a file pointer and resets the position to the start of the file. For example the statement :

Rewind(fp); N=ftell(fp);

Would assign to fp because the file position has been set to the start of the file by rewind. This function helps us in reading a file more than once. Without having to close and open the file. fseek : fseek function is used to move the position to a desired location within the file. It takes the following form. Fseek(fpt, offset, position) Fpt is a pointer to file concerned. Offset is a number of variable of type long and position is an integer number. The offset specifies the number of bytes(position) to be moved from the location specified by position. The position can take one of the following three values :

0 beginning of file 1 current position 2 end of file

The offset may be positive, meaning move forward and negative, meaning move backwards. When the operation is successful, fseek returns a zero. If we attempt to move beyond the file boundaries and error occurs and fseek returns. 62

DYNAMIC MEMORY ALLOCATION The process of allocating memory at run time is known as dynamic memory allocation. malloc() and calloc() are library routines known as “Memory Management Functions” that can be used for allocating and freeing memory during program execution.

Malloc() A block of memory may be allocated using the function malloc(). The function reserves a block of memory of specified size and returns a pointer of type void. This means that we can assign it to any type of pointer. it takes the following form.

Ptr = (cast_type *) malloc(byte_size) Ptr is a pointer of type cast_type. The malloc returns a pointer of cast_type to an area of memory of size byte_size. For example,

X = (int *) malloc(100*sizeof(int)); On successful execution of this statement a memory space equivalent to “100 times for the size of int” bytes is reserved and the address of the first byte of the memory allocated is assigned to the pointer x of type int. Similarly statement

Cptr = (char *) malloc(10); Allocates 10 byte of space for the cptr of type char. We may also use malloc to allocate space for complex data types such as structures. For example, Stptr = (struct store*)malloc(sizeof(struct store)); Where stptr is pointer of type struct store. The malloc allocates a block of contiguous bytes. The allocation can fall if the space in the heap is not sufficient to satisfy the request. If it fails it returns a NULL.

Calloc() Calloc is memory allocation function that is normally used for requesting memory space at runtime for storing derived data types such as arrays and structures. Calloc allocates multiple block of storage, each of the same size and then sets all bytes to zero. The general form of calloc is ;

Ptr = (cast_type *) calloc(n,elem_size); The above statement allocates contiguous space of n blocks. Each of size elem_size. All bytes are initialized to zero and a pointer to the first byte of allocated region is returned. If there is not enough space, a NULL pointer is returned. The following segment of program allocates space to a structure variable.

struct student {

char name[25]; float age; long int id_num;

}; type of struct student record;

record *stptr; int class size=30;

stptr = (record *) calloc(class_size, sizeof(record));

record is of type struct student, having three members name, age and id_num. The calloc allocates memory to hold data for 30 such records.

63

PROGRAM LIST (1) Write a program that perform the addition, subtraction, division and multiplication of 2 values. (2) Write a program to count the simple interest. (3) Write a program that find maximum of 2 values. (4) Write a program that interchange or swap the values of 2 variables. (5) Write a program that find minimum and maximum out of 3 values. (6) Write a program to interchange the value of 2 variable without using 3rd variable (7) Write a program that take input of 5 subjects marks. Count the percentage. Print the result for following condition If student has 70% or more then 70% then DISTINCTION. If student has percentage between 60 and 69 then FIRST CLASS. If student has percentage between 50 and 59 then SECOND CLASS. If student has percentage between 40 and 49 then PASS CLASS. If student has percentage less then 40 then FAIL. (8)Write a program that take input of 5 subjects marks. If student get 40 or more then 40 then he is PASS in that subject otherwise FAIL print the result for following condition. If student is pass in all subjects then declare PASS. Is student is fail in 1 or 2 subject then declare ATKT. If student is fail in more then 2 subject then declare FAIL. (9) Write a program that perform the following output for n rows 1 1 2 1 2 3 1 2 3 4 (10) Write a program that perform the following output for n rows 1 2 2 3 3 3 4 4 4 4 (11) Write a program that perform the following output for n rows 1 2 3 4 5 4 3 2 1 1 2 3 4 4 3 2 1 1 2 3 3 2 1 1 2 2 1 1 1 (12) Write a program that perform the following output for n by n matrix without using array 1 2 3 4 5 10 9 8 7 6 11 12 13 14 15 20 19 18 17 16 21 22 23 24 25

64

(13) Write a program that perform the following output for n rows 1 3 5 6 8 9 10 (14) Write a program that perform the following output for n rows * * * * * * * (15) Write a program that perform the following output for n rows

1 1 2 1 2 3 1 2 3 4

(16) Write a program to perform the following output for n rows 1 0 1 1 0 1 0 1 0 1

(17) Write a program to perform the following output for n rows 1 * 2 * * * 3 * * * * * 4 * * * * * * * (18) Generate the value of n! factorial for n number (19) 1+2+3+4+5+6 up to n terms (20) 1+3+5+7+9 up to n terms (21) 1+2+4+5+7+8 up to n terms (22) X+ X2 + X3 + X4 + X5 up to n terms (23) X/Y + X2/Y2 + X3/Y3 up to n terms (24) X/Y + X2/Y + X2/Y2 + X3/Y2 + X3/Y3 up to n terms (25) A+AR+AR2+AR3+AR4 up to n terms (26) 1! + 2! + 3! + 4! + 5! Up to n terms (27) 1! + 3! + 5! + 7! Up to n terms (28) X + X3 + X5 + X7 up to n terms (29) X/1 + X2/22 + X3/33 + X4/44 up to n terms (30) AB+CD+A2B2+C2D2 up to n terms (31) Write a program to generate fibona series 0,1,1,2,3,5,8,13 up to n terms. (32) 1*3 + (1+2) * 32 + (1+2+3) * 33 + (1+2+3+4) 34 up to n terms (33) 1!/2! + 3!/4! + 5!/6! Up to n terms (34) X/1! - X3/3! + X5/5! - X7/7! Up to n terms (35) Write a program to check whether the entered no is odd or even. (36) Write a program to calculate the sum of odd and even number between given no of series. 65

(37) Write a program for following output for n no of rows( Pascal triangle) 1

1 1 1 2 1 1 3 3 1

1 4 6 4 1 (38) Write a program for following output for n no of rows. 1 0 1 1 0 1 0 1 0 1 (39) Write a program that count the area for circle, square, rectangle and triangle using Switch-Case control structure (40) Write a program that take input of percentage in integer only. Print the result for following condition using Switch-Case control structure. If student has 70% or more then 70% then DISTINCTION. If student has percentage between 60 and 69 then FIRST CLASS. If student has percentage between 50 and 59 then SECOND CLASS. If student has percentage between 40 and 49 then PASS CLASS. If student has percentage less then 40 then FAIL. (41) Write a program that take input of year in 4 digit. Determine whether the year is leap year or not.(try to solve this problem with && and or operator) (42)Write a program that determine the grade of steel according to following condition. 1 Hardness must be greater then 50 2 Carbon must be less then 0.7 3 Tensile must be greater then 5500

Take the input for above qualities through keyboard from user Grades are decided as follows.

Grade A if all 3 conditions are met. Grade B if condition (1) and (2) are met. Grade C if condition (2) and (3) are met. Grade D if condition (1) and (3) are met. Grade E if only one condition met. Grade F if none of conditions are met. (43) Write a program to find maximum from 3 values using conditional operator. (44) Write a program that generate same output as of program no (10) using break statement. (45) Write a program that performs the sum of given numbers until user says no using Go-To statement. (46) Write a sample program that demonstrate the use of Continue statement. 66

(47) Write a program that find maximum and its position from 10 number using array. (48) Write a program that sort the value in ascending order in array. (49) Write a program that generate the array of distinct or unique values from the array given by user. (50) Write a program that calculates the total marks and percentage for 5 subject marks using array. (52)Write a program that arrange the array values in reverse order. (53) Write a program that perform the summation and subtraction of two matrices. (54) Write a Program that perform the sum of rows and sum of column for n by n matrix (55) Write a Program that perform the sum of rows and sum of column for m by n matrix (55) Write a program that take the input of sales of 5 salesman for 4 different quarter of year. Count the total sales perform by each salesman and sales performed during each quarter also perform the grand total sales. (56) Write a program that perform the sum of diagonal elements of n by n matrix (57) Write a program of spiral matrix using 2-D matrix. (58) Write a function to count the simple interest.. (59) Write a function that count compound interest. (60) Write a function to generate the square of any given number (61) Write a function which should work as a power function (62) Write a functions to count the area of circle, triangle, rectangle and square. (63) Write a function to print any character for n no of time. (64) Write a function which should work as absolute function. (65)Write a program witch demonstrate the use of pre and post increment and decrement operator also define the use of assignment operator like +=, -= , *= , /=. (66)Write a functions which should work like a isnum() ,isalpha() ,ischar() functions . (67)Write a functions which should work like (1) asc() function which returns an integer value of given character(2) char() function which returns character value for given integer value. (68)Write a function to interchange the two value a and b (Call By Reference) witch passes the 2 arguments in form of address of a and b variable with declaration like Void swap(int *, int *). (69)Write a void function which count the area and perimeter of circle(Call By Reference) witch passes radius , address of area variable and address of perimeter variable with declaration like Void count(float , float *, float *) (70)Write a function to count mean for discrete data. User has to pass only n no of values and address of first element of an array with declaration like float mean(int *,float *) (71)Write a function to find out maximum from of n no of values. User has to pass n no of elements and Address of first variable in an array. With declaration like int findmax(int,int *). (72) Write a function to arrange integer values in ascending order in an array witch passes n of elements and address of first element of an array with declaration like void arrange(int,int *) (73)Write a program that demonstrate the use of gets() and puts() . (74)Write a program that demonstrate the use of strcmp(), strlen(), strcpy(), strrev(), strupr(), strlwr() and strcat() built-in function. (75)Write a program that take input of name of 10 students with gets() and just print them with puts() function. 67

(76)Write a program or function which should work like a strlen() function. (77)Write a program or function which should work like a strcmp() function. (78)Write a program or function which should work like a strcpy() function. (79)Write a program or function which should work like a strcat() function. (80)Write a program or function which should work like a strrev() function. (81)Write a program or function which should work like a strupr() function. (82)Write a program or function which should work like a strlwr() function. (83)Write a program that take input names of 10 students. Arrange them in ascending order in string array. (84)Write a program that take input paragraph of 10 lines. Count total no of word and total no of characters (Excluding blank spaces). (85)Write a pre-processor directives which returns (1) area of circle (2) perimeter of circle (86)Write a pre-processor directives which checks works like a (1) isdigit() (2) isalpha() functions (87)Write a preprocessor directives which demonstrate the use of #ifdef and #ifndef. (88)Write a preprocessor directives which use some symbolic directives for (&&,||,==) to operators. (89)Write a simple program using structure that demonstrate different type of declaration of structure variable (90)Write a program using structure that accept rollno,name and percentage of students. (91)Write a program that demonstrate the use of aray of structure variable (92)Write a program that demonstrate how one structure variable can be copied into another (93)Write a program that demonstrate the use of structure and function. (94)Write a program that access the structure variable using pointer. (95)Write a program that demonstrate the use of nested structure. For example

struct marks struct student { { int s1; int rollno; int s2; char name[20]; int s3; struct mark m1; int tota; }s1; };

(96)Write a program that demonstrate the use of getch(),getche(),getchar() and putchar() functions. (97) Write a program that demonstrate the use of formatted input with

(%[ ]) operator. (98)Write a program that demonstrate the use of formatted output like

printf("%10d",rollno); ,printf("%10.2f",salary) and printf("%*.*s",10,5,name) (99)Write a simple program that explain the precedence(priority) and associativity. 68

C THEORY 1. Describe the several features of C language. 2. Explain the structure of c program. 3. Explain why C language is called middle level language. 4. List all the relational operators available in C Explain with suitable example 5. List all the logical operators available in C Explain with suitable example 6. List all the assignment operators available in C Explain with suitable example 7. List all the arithmetic operators available in C Explain with suitable example 8. Explain pre and post increment-decrement operator with suitable example. 9. List all the Bitwise operators available in C Explain with suitable example 10. Explain sizeof() operator with suitable example. 11. Explain conditional opertor or turnery operator with suitable example. 12. Explain precedence and associativity with suitable example. 13. Explain automatic type conversion and casting with suitable some example. 14. List all the basic or primary data-types available in C with their format specifier and size in

bytes and their declaration statement. 15. Explain the differnace between getch(),getche() and getchar() functions. 16. Explain the difference between gets() and scanf() function and printf() and puts function

with suitable example 17. Explain formatted output with suitable example 18. Explain formatted input with % [ ] with suitable example 19. Explain nested if-else control structure with suitable example. 20. Explain Switch-Case with suitable example. 21. Explain Go-To statement with some suitable exmple 22. Explain types of loops with their syntex available in C. Explain any one with suitable

example. 23. Explain break-continue with suitable example. 24. Explain one-dimension array with some example and how elements are allocated with

space in memory. 25. Explain tow-dimension array with some suitable example. 26. List some of the built-in string handling function with some suitable example. 27. Explain the user define function with their structure and with small suitable example. 28. List the advantages or feature of functions. 29. Explain recursion with suitable example. 30. List all the storage class available in c and specify the scope, lifetime,storage and their

default initial value. 31. Explain what is pointer with some small example. 32. Explain call by value and call by reference with suitable example 33. Explain structure and also define how members of structure variable can be accessed and

how they are allocated in memory. 34. Explain what is macro or preprocessor directives.explain the use of # define, # ifdef,#

ifndef and # include with some suitable example.

69