Introduction to programming languages:-
All the programming languages can be divided into two categories.
Machine oriented languages (or) Low level languages:-
These languages have been designed to give a better machine efficiency,
i.e., Faster program execution.
Eg. : Assembly language, Machine Language.
Problem Oriented Languages (or) High Level Languages :-
These languages have been designed to give a better programming efficiency,
i.e., faster program development.
Eg. : FORTRAN, BASIC, PASCAL etc.,
Steps to learning English language:-

Steps to learning computer (programming) language :-



Introduction to C Language :-
C is a programming language developed at AT & T’s Bell Laboratories of USA in 1972. It was designed and written by a man named “Dennis Ritchie”.
C stands in between the above two [(a) & (b)] categories of languages. That is why it is often called a middle level language, since it was designed to have both: a relatively good programming efficiency (as compared to Machine Oriented Languages) and a relatively good machine efficiency (as a compared to problem oriented languages).
The C character set :
A character denotes any alphabet, digit, or a special symbol used to represent information. Following table shows the valid alphabets, numbers and special symbols allowed in C:

Alphabets A, B, C ... Z
and
a, b, c ... z
Digits 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Special Symbols ~ à Tilde
! à Exclamation mark
# à Harsh
% à Percentage
^ à Cap or Crown or Carrot
& à Ampersand
* à Asterisk
( à Open parentheses
) à Closing parentheses
_ à Underscore
- à Minus
+ à Plus
= à Equal
| à Pipe
\ à Backward slash { à Open brace
} à Closing brace
[àOpen bracket
] àClosing bracket
: à Colon
; à Semi colon
“à Double quotation mark
’ à Single quotation mark
< à Less than
> à Greater than
, à Comma
. à Dot
? à Question mark
/ à Forward slash

Constants, Variables (Identifiers): -
The alphabets, numbers and special symbols when properly combined form constants, variables and keywords. Let us see what are constants and variables in C. A constant is a quantity that does not change. This quantity can be stored at a location in the memory of the computer. A variable can be considered as a name given to the location in memory where this constant is stored. Naturally that content of the variable can change.
Eg. : 3x2 + 4x + 5 = 0
Here, 3,4, 5 and 0 cannot change, they are called constants, whereas the quantities x can vary or change hence this is called a variable.
Types of C constants :-
C constants can be divided into two major categories:
Primary constants,
Secondary constants

Rules for constructing Integer Constants :
An integer constant must have at least one digit.
It must not have a decimal point
It could be either positive or negative
If no sign precedes an integer constant it is assumed to be positive
No commas and blanks are allowed within an integer constant.
The allowable range for integer constants is –32768 to +32767 (Because an integer constant occupies 2 bytes of memory in computer).
Integer constants must fall within this range because the IBM compatible microcomputers are usually 16 bit computers which cannot support a number falling out side the above mentioned range. For a 32 bit computer of course the range would be much larger.
E.g. 450, + 590, -267
Rules for constructing Real Constants:-
Real constants are often called floating point constants. The real constants could be written in two forms, Fractional form and Exponential form.


Rules for fractional form:-
A real constant must have at least one digit
It must have a decimal point
It could be either positive or negative. Default sign is positive
No commas & blanks are allowed within a real constant.
E.g. 296.0, +1.272, -48.01
Rules for Exponential form:-
The exponential form of representation of real constants is usually used if the value of the constant is either too small or too large. If however does not restrict us in any way from using exponential form of representation for other real constants.
In exponential form of representation, the real constant is represented in two parts. The part appearing before ‘e’ is called mantissa, whereas the part following ‘e’ is called exponent.
The mantissa part and the exponential part should be separated by a letter ‘e’
The mantissa part may have a positive or negative sign. Default sign is positive.
The exponent must have at least one digit which must be a positive or negative integer. Default sign is positive.
Range of real constants expressed in exponential form is –3.4e38 to 3.4e38. (Because a floating point constant occupies 4 bytes of memory in computers).
Eg. : +5.2e-7,
4.5e8,
-0.2e+3
Note: 5.2e-7 = 5.2 x 10-7
4.5e8 = 4.5 x 108
Rules for constructing character constants :-
A character constant is either a single alphabet, a single digit or a single special symbol enclosed within single inverted commas both the inverted commas should point to the left( ’ ).
Eg. : ‘A’ is not a valid character constant
’A’ is a valid character constant.
The maximum length of a character constant can be 1 Character.
Range of character constants expressed in signed integers is –128 to +127 (or) expressed in unsigned integers is 0 to 255. Because a character constant occupies 1 byte of memory in computer.
Rules for constructing variable names :-
A variable name is any combination of 1 to 8 alphabets, digits, or underscores ( _ ). Some compilers allow variable names whose length could be up to 40 characters. Still, it would be safer to stick to the rule of 8 characters.
The 1st character in the variable name must be an alphabet.
No commas or blanks are allowed within a variable name.
No special symbol other than an underscore ( _ ) can be used in a variable name.
Eg. : empname, bas_sal, varl …. etc.
Data Types of C Variables :-
In C, a quantity which may vary during program execution is called a variable. Variable names are names given to locations in the memory of computer where different data are stored. These locations can contain integer, real or character constants. In any language, the type of variables that it can support depends on the types of data that is can handle. This is because a data stores in a location with a particular type of variable name can hold only that type of data. For example, a data stored in a memory location with an integer variable name, must be an integer data, one stored in location with a real variable name must be a real data and the one stored in location with a character variable name must be a character data. The following are the keywords for these data types.
Integer data type à int
Real data type à float
Character data type à char


C Keywords:
Keywords are the words whose meaning has already been explained to the C compiler (or in abroad sense to the computer). The keywords cannot be used as variable names because if we do so we are trying to assign a new meaning to the keyword, which is not allowed by the computer. The keywords are also called “Reserved Words”. There are only 32 keywords available in C, following is the list of keywords in C.
auto double if static
break else int struct
case enum long switch
char extern near typedef
const float register union
continue far return unsigned
default for short void
do goto signed while
C Instructions ( Expressions (or) Statements):
There are basically four types of instructions in C.
(a) Type Declaration Instruction
(b) Input / Output Instruction
(c) Arithmetic Instruction
(d) Control Instruction
Type Declaration Instruction :
This instruction is used to declare the type of variables being used in the program. Any variable used in the program must be declared before using it in any statement. The type declaration statement is usually written at the beginning of the C program.
Eg. : int basic;
float hra, ta, da;
char gender;


Input / Output Instruction :
These are used to perform the function of supplying input data to a program and obtaining the output results from it.
Eg. : scanf (“%d”,&basic); /* input instruction .*/
printf (“%d”, basic); /* output instruction.*/
Arithmetic Instructions :
A C arithmetic instruction consists of a variable name on the left hand side of = and variable names and constants on the right hand side of = the variables and constants appearing on the right hand side of = are connected by arithmetic operators like +, -, *, and /.
Eg. : perimet = 2 * (b+l);
Here, *, + are arithmetic operators,
= is the assignment operator,
2 is an integer constant,
perimet, b, l are the variables, which are declared in declaration section.
The variables and constants together are called ‘operands’ which are operated upon by the “arithmetic operators” and the result is assigned, using the assignment operator (=), to the variable on left hand side.
Note :
* C allows only one variable on left hand side of =
i.e. z = k*l is legal,
Whereas k*l = z is illegal
* A statement similar to arithmetic instruction is many times used for storing character constants in character variables.
i.e. a = ’F’ is also an arithmetic instruction.
* Arithmetic operations can be performed on ints, floats, and chars.
i.e. z = ’x’ + ’y’ is perfectly valid.
Since the addition is performed on the ASCII values of the characters and not on characters themselves. The ASCII (American Secret (Standard) Code for Information Interchange) of ‘x’ and ‘y’ are 120 and 121, and hence can definitely be added.
Operators:-
1) Unary Operators :-
Any operator which operates on only one operand is called Unary operator. These are :
- à Unary minus, used to negate any number
++ à Increment by 1
-- à Decrement by 1
sizeof (variable) à This is used to return the memory size of variable in no. of bytes.
Eg. : (i) a = -a;
a++; This is called post increment
++a; This is called pre increment
a--; This is called post decrement
--a; This is called pre decrement
a = sizeof (int); which returns 2
i.e., The memory size of integer.
(2) Binary (or) Arithmetic Operators :-
Any operator which operates on two operands is called binary operator. Arithmetic operators are used to calculate arithmetic expressions. The operators are :
* à Multiplication
/ à Division
% à Modulus (or) Remainder Operator
+ à Addition
- à Subtraction
. Eg. : a = 25%4; which gives the value 1 for a
(3) Relational Operators :-
These operators are used to compare two variables.
< à Less than
< = à Less than & equal to
> à Greater than
> = à Greater than or equal to
= = à Equal to
! = à Not equal to
(4) Logical Operators :
These operators are used to compare multiple conditions at a time.
&& à And
|| à Or
! à Not
Assignment Operators :
These operators are used to store values of some variables into another.
=, *=, /=, %=, +=, - =, &=, ^=, |=, <<=, >>=
Eg. : (i) a = 15%4;
(ii) a * = 4; which is also written as a=a*4; which means that a is multiplied by 4 and restores it.
Bitwise Operators :
These operators are used to operate with bits (i.e. 0’s and 1’s).
~ à One’s complement
<< à Left Shift
>> à Right Shift
& à Bitwise AND
^ à Bitwise XOR (Exclusive OR)
| à Bitwise OR
Structure of C :
C language has a structured way for constructing a C program, that is why C is called a structured programming language.



[ Documentation Section ]
[ Linkage Section ]
[Global declaration section ]
< main ( )
{
Local declaration section;
……………………..
……………………..
Body of main ( ) ;
……………………..
……………………..
} >

[ Function definition section ]
Documentation section :
This section is used to give the information about the program to other users.
This is also called comments section
Comment about programme should be enclosed within /*...*/.
Any no. of comments can be given at any place in the program.
Comments cannot be nested
i.e., /* calculation of /* simple x/ interest */ is invalid.
A comment can be split over more than one line.
Eg. : /* calculation of simple interest.
Author : Y. Kanitkar
Date : 25-07-2005 */
Linkage Section:
This linkage section is used to link one file to another. For this we use the preprocessor directive #include. This directive causes one file to be included in another. The preprocessor command for file inclusion books like this :
# include “filename” (or) # include <>
And it simply causes the entire contents of filename to be inserted into the source code at that point in the program.
The meanings of each of these forms :
# include “filename” : This command would look for the given file in the current directory as well as the specified list of directories as mentioned in the include search path that might have been set up.
E.g:- # include “C:\TC\decimal.C”
# include : This command would look for the given file in the specified list of directories only.
Eg. : # include
Global declaration section :
This section is used to declare the global variables i.e., This global variables are used in entire program.
Eg. : int sal;
float hra;
In this section we have another feature, that is macro definition #define directive or more commonly just a “macro”.
Syntax for macro definition.
# define
Eg. : #define PI 3.1415
Here, PI is called macro template,
3.1415 is called macro expansion
In C programming it is customary to use capital letters for macro templates.
Macro templates and macro expansions are separated by blanks or tabs.
Space between # and define is optional
Macro definition is never to be terminated by a semi colon (;).
main ( ) :
Any C program is nothing but a combination of functions. main ( ) is one such functions. Empty parentheses {( )} after main are necessary.
The set of statements belonging to a function are enclosed within a pair of braces ({}).
Any variable used in the program must be declared before using it.
Eg. : int p, n;
float r, si;
Function definition section :
This section is used to define user defined functions, if necessary.
In the above structure of C, the documentation section, linkage section, global declaration section, and function definition section are optional, and the main ( ) block is essential for every C program.
Note :
Statement in between [ ] is optional
Statement in between < > is essential
Rules for constructing C program :
Blank spaces may be inserted between two words to improve the readability of the statement. However, the blank spaces are not allowed within a variable, constant or keyword.
Usually all statements are entered in small case letters.
C has no specific rules for the position at which a statement is to be written. That is why it is often called a free-form language.
Any C statement always ends with a semi colon (;)
First C Program :
/* Purpose : Calculation of simple interest.
Author : Y. Kanitkar
Date : 25-7-2005
*/
# include <>
main ( )
{
int p, n;
float r, si;
p = 5000; /* Principle value */
n = 5; /* No. of years */
r = 8.5; /* Rate of interest */
si = p*n*r/100; /* Formula for simple interest */
printf (“Simple Interest is :%f”, si);
}
Note :
printf ( ) : it is used to print values of the variables on the screen.
The general form,
printf (“”, );
Format string could be
%f for real values (float)
%d for integer values
%c for character values.
Calculation of simple interest, using scanf() function.
main ( )
{
int p, n;
float r, si;
printf (“\n Enter principle, no.of years, rate:”) ;
scanf (“%d %d %f”, &p, &n, &r);
si = p*n*r/100;
printf (“\n simple interest = Rs. %f /-“, si);
}
Note :
scanf ( ) : This function is used to take values from keyboard. The ampersand (&) before the variable in the scanf statement is a must. & is a pointer operator, it is called address of value operator.
CONTROL INSTRUCTIONS IN C
As the name suggests the “Control Instructions” enables us to specify the order in which the various instructions in a program are to be executed by the computer. In other words the control instructions determine the “flow of control” in a program. There are 4 types of control instructions in C. They are :
Sequence control instruction,
Selection or Decision control instruction,
Repetition or loop control instruction,
Case control instruction.
(a) Sequence Control Instruction :
The Sequence Control Instruction ensures that the instructions are executed in the same order in which they appear in the program.
The flow of control looks like this :









(b) Selection or Decision Control Instruction :
Decision control instruction allow the computer to take a decision as to which instruction is to be executed next depending on condition, hence is called conditional statement.
if :-
Syntax :- if ()
Statement(s);
Here, if the given condition is true then the statements in if block will execute, otherwise that statements will ignore by the compiler.
Eg. : if (a = = o)
printf (“ a is vanish”);

(2) if .. else :-
Syntax : if ()
statement(s);
else
statement(s);


Here, if the given condition is true then the if block will execute, or if the condition is false then the else block will executed.
Eg : if (a < 0)
printf (“a is a –ve value”);
else
printf (“a is a +ve value”);
(3) if.. else if :-
syntax : if ()
statements1;
else if ()
statements2;
else
statements3;
Eg. : if (a < 0)
printf (“a is –ve”);
else if (a>0)
printf (“a is +ve”);
else
printf (“a is zero”);
(4) Nested if … else :-
Syntax :- if ()
{
statements ;
if ()
statements;
……
……
else
statements;
}
else
statements;
else if ladder :-
Syntax :-
if ()
Statements;
else if ()
Statements;
else if ()
Statements;
……….
……….
else
Statements;
Conditional operator (or) Ternary Operator :-
The conditional operators ? and : are some times called ternary operators since they take three arguments. In fact, they form a kind of foreshortened if .. then .. else.
Syntax :- Expression 1? Expression 2 : expression 3;
Here, if expression 1 is true (that is if the value is non-zero), then the value returned will be expression 2 otherwise the value returned will be expression 3.
Eg. : (i) (a<0) ? printf (“a is –ve”) : printf (“a is +ve”);
(ii) y = ((a>=65 && a<=90) ? 1:0);
Repetition & Loop Control Instructions :-
The Loop Control Instructions helps computer to execute a group of statements repeatedly. The versatility of the computer lies in its ability to perform a set of instruction repeatedly. This involves repeating some portion of the program either a specified number of times or until a particular condition is being satisfied. This repetitive operation is done through a loop control structure.
C allows us three types of loop contract structures viz.,
while
do…while
for
while :-
Syntax : -
[initialize counter;]
while (condition)
{
Body of loop;
[Increment/decrement counter;]
}
Here, the statements within the pair of braces called body of the loop. The parentheses after the while contains a condition. So long as this condition remains true all statements within the body of the loop keep getting executed repeatedly. The variable counter is many a times called either a ‘Loop Counter’ or an ‘index variable’.
Eg. : This loop is used to print 1 to 1000 numbers on the screen.
i = 1;
while (i< = 1000)
{
printf (“\n %d”, i);
i++;
}
do … while :-
Syntax :- do
{
body of do…while;
}while (condition);
The do..while loop works like a while loop. The do…while tests the condition after having executed the statements within the loop. This means that do…while would execute its statements at least once, even if the condition fails for the 1st time itself.
Eg. :- i = 1
do
{
printf (“\n %d”, i);
i ++;
}while (i<=1000);


for :-
This is probably the most popular looping control. The for allows us to specify three things about in a single line :
setting a loop counter to an initial value.
Testing the loop counter to determine whether its value has reached the number of repetitions desired.
Increasing the value of loop counter each time the program segment within the loop has been executed.
Syntax :-
for ([initialize counter]; ; [increment/decrement counter])
{
body of loop;
}







Eg. :
for (i = 1; i< = 1000; i++)
printf (“\n %d”, i);
Multiple initializations in the for loop :
* The initialize counter expression can contain more than one statement separated by a comma,
Eg. : for (i = 2, j = 1; j<=10; j++)
* Multiple statements can also be used in the increment /decrement counter expression of loop.
Eg. : for (i = 2; j = 1; j< = 10; i++; j++)
* Only one expression is allowed in condition expression. This expression may contain several conditions linked together using logical operators.
Eg. : for (i = 2, j = 1; (j<=10 && i<=20); i++, j++)
Nesting of Loops :-
Any loops within another loops are called nested loops.
Eg. :
for (i = 1; i < = 3; i++)
{
for (j = 1; j<=3; j++)
printf (“ %d”, i);
printf (“\n”);
}
The Odd Loop :
The loops that we have used so far executed the statements within them a finite number of times, i.e, decided by user at runtime are called an odd loop.
Eg. :
while (another = = ’y’)
{
printf (“Hello!”);
printf (“Do you want to another display(y/n):”);
scanf (“%c”, &another);
}
break Statement :-
The keyword break allows us to jump out of a loop instantly, without waiting to get back to the conditional test.
Eg. :
i = 2;
while (i<=num-1)
{
if (num %i = = 0)
{
printf (“Given number is not a prime number”);
break;
}
i++;
}
if (i = = num)
printf (“\nGiven number is a prime number”);
continue Statement :
The keyword continue allows us to take the control to the beginning of the loop, bypassing the statements inside the loop which have not yet been executed.
Eg. : /* To print all combinations of 1,2,3 */
for (i = 1; i<=3; i++)
for (j = 1; j<=3; j++)
for (k=1; k<=3; k++)
{
if(i = = j || j = = k || i = = k)
continue;
printf (“%d %d %d”, i, j, k);
}
d) Case control instruction :-
The control statement which allows us to make a decision from the number of choices is called a switch, or more correctly a switch-case-default, since these three keywords go together to make up the control statement.




Syntax :
switch (choice variable)
{
case constant 1 : statements; break;
case constant 2 : statements; break;
……….………………………………
………….……………………………
case constant n : statements; break;
default : statements;
}
Here, Choice variable à integer/character variable
Constants à integer/character constant
Eg. :
switch (ch)
{
case 1 : a = b + c; break;
case 2 : a = b – c; break;
case 3 : a = b * c; break;
case 4 : a = b/c; break;
case 5 : a = b%c; break;
default : printf (“\n invalid choice …!”);
}

Note:-
We can use cases in any order.
We can mix integer and character constants in different cases of a switch.
Some times there may not be any statement in some of the cases in switch, but still they might turn out to be useful.
Even if there are multiple statements to be executed in each case there is no need to enclose these within a pair of braces.
If we have no default case, then the program simply falls through the entire switch and continues with the next instruction that follows the control structure.
The break statement when used in a switch takes the control outside the switch. However, use of continue will not take the control to the beginning of switch as one is likely to believe.
A switch may occur within another switch, which is called nested switch statements.
The switch statement is very useful while writing menu driven programs.
We can have after the case is an int constant or a char constant. Even a float is not allowed.
goto statement :
This is used to jump from any statement to another statement in a C program.
Syntax : goto ;
Here, label is the target position of goto statement
i.e. : statements;
Eg. : Repeat : printf (\nenter a value :”);
scanf(“%d”,&a);
if (a<0)
goto Repeat;


POINTERS
Introduction :
Memory is organized as a sequence of byte – sized (1 byte = 8 bits) locations. These bytes are numbered beginning with a zero. The number associated with a byte is known as its address or memory location. A pointer is an entity which contains a memory address. Thus, a pointer is a number which specifies a location in memory. The key concepts and terminologies associated with memory organization are,
Each byte in memory is associated with a unique address.
Addresses are positive integer values that range from zero to some positive integer constant corresponding to the last location in the memory.
An address is an integer having fixed number of bits, labeling a byte in the memory.
Every object (data or program code) that is loaded into memory is associated with a valid range of addresses, that is, each variable and each function in a program starts at a particular location, and spans across consecutive addresses from that point onwards depending upon the size of the data item.












The size of the data type referenced by the pointer is the number of bytes that may accessed directly by using that address.
Pointers :
Pointer variables are defined as variables that contain the memory addresses of data or executable code. Normally, a pointer variable, like any other variables, is declared so that it will work only with data of a given type each pointer variable can point only to one specific type (int, float, char ….) of data.
Uses of pointers :
Accessing array elements.
Passing arguments to functions by reference.
Passing arrays and strings to functions.
Creating data structures such as linked tests, trees, graphs, and so on.
Obtaining memory from the system dynamically.
Address operator (&) :
All the variables defined in a program (including pointer variables) reside at specific addresses. It is possible to obtain the address of a program variable by using the address operator & (ampersand). When used as a prefix to the variable name, the & operator gives the address of that variable.
Eg. : a = 100;
b = &a;
Here b stores the address of variable a. Where b must be a pointer variable and declared before using it.




Pointer Variables :
Pointers are also variables and hence, must be defined in a program like any other variable. The rules for declaring pointer variable names are the same as ordinary variables.
Syntax : *;
Eg. : int *b;
Dereferencing Pointers :
Dereferencing is an operation performed to access and manipulates data contained in the memory location pointed to by a pointer. The operator *(asterisk) is used to dereference pointers. A pointer variable is dereferences when the unary operator *, in this case called the indirection operator, is used as a prefix to the pointer variable or pointer expression. Any operation performed on the dereferences pointer directly affects the value of the variable it points to. Here is an example.
Eg. : int *b, a, c = 200;
a = 100;
b = &a; // b contains address of a
*b + = 20; // dereference b, a = a +20
c = *b; // same as c= a








void Pointers :
The void pointers can contain the address of any type of variable.

Eg. : void *a, *b;
int c;
float d;
a = &c;
b = &d;
Pointers to void cannot be directly dereferences like other pointer variables by using *. Prior to dereferencing a pointer to void, it must be suitably typecast to the required data type. A pointer to void may be type cost by preceding its name with a relevant data type followed by an asterisk, both of which are enclosed within a pair of parentheses.
Eg. : printf (“c contains : %d”, ((int)a));
printf (“d contains :%f”, *((float *)b));
Pointer arithmetic :
The C language allows arithmetic operations to be performed on pointer variables.
The arithmetic operators available for use with pointers can be classified as : ++, --, +,-.
The C compiler takes the size of the data type being pointed to into account, while performing arithmetic expressions on a pointer. For example, if a pointer to an integer is incremented using the ++ operator (preceding or succeeding the pointer) then the address contained in the pointer is incremented by two and not one, assuming that an integer occupies two bytes in memory. Similarly incrementing a pointer to a float causes the initial address contained in the float pointer to be actually incremented by 4 and not 1 (float occupies 4 bytes memory).
In general, a pointer to some type, d-type (where d-type may be int, float, char…) when incremented by an integral value i, will result in the following value:
(Current address in pointer) + i * sizeof (d-type)
to be the new incremented pointer value. This concept applies to all arithmetic operations performed on pointer variables in a program. Pointer arithmetic becomes very significant for accessing and processing array elements efficiently.
Note : Pointer arithmetic cannot be performed on void pointer, since they have no type associated with them.
Pointer to Pointers :
Pointer is a type of data in C : hence we can also have pointers to pointers, just as we have pointers to integers. Pointers to pointers offer flexibility in handling arrays, passing pointer variables to functions, etc.,
Syntax : **;
Eg. : int *a, **b, c = 100;
a = &c;
b = &a;


ARRAYS AND STRINGS
ARRAY:
An array is a sequence of data in memory, where in all data are of the same type, and are placed in physically adjacent locations.
For example, a sequence of 10 integers stored one after another in memory represents an array.
E.g. :

Array declaration syntax :
array name [];
Eg. : int marks [30];
Here, the number 30 tells how many elements of the type int will be in our array. This number is often called the “dimension” of the array. The bracket [ ] tells the compiler that we are dealing with an array. This array is called ‘one dimensional array’.
Accessing array is done with subscript, the number in the brackets following the array name. This number specifies the elements position in the array. All the array elements are numbered, starting with 0. Thus, marks [2] is not the second element of the array, but the third. In our example we are using the variable i as a subscript to refer to various elements of the array.



Eg. : for (i = 0; i<=29; i++)
{
printf (”\n Enter marks:”);
scanf (“%d”, &marks [i]);
}
Note:-
An array is a collection of similar elements.
The first element in the array is numbered 0, so the last element is 1 less than the size of the array.
An array is also known as a subscripted variable.
Before using an array its type and dimension must be declared.
However big an array its elements are always stored in contiguous memory locations.
Array initialization syntax :
arrayname[] = {elements separated by commas };
Eg. : (i) int num [6] = {1,2,3,4,5,6};
(ii) int num[ ] = {15,16,81,92,53};
Till the array elements are not given any specific values, they are supposed to contain garbage values.
If the array is initialized where it is declared mentioning the dimension of the array is optional.
Forms of accessing an array element is, num [i], is represents the element in ith location, * (num + i), *(i + num), i [num] are also valid.
More than one dimensional arrays :
So far we have explored arrays with only one dimension. It is also possible for arrays to have two or more dimensions. The two dimensional array is also called a matrix.
Declaration syntax :
[dimension 1][dimension 2]...[dimension n];
Eg. : int student [10] [30];
Initializing a 2 – dimensional (2D) array :-
int matrix1[ ] [2] = {
{123, 124},
{546, 556},
{405, 306}
};
or this would work,
int matrix1 [ ] [2] = { 123, 124, 546, 556, 405, 306 };

It is important to remember that while initializing an array it is necessary to mention the second (column) dimension, where as the first (row) dimension is optional.
Memory map of a 2D array :
In memory whether it is a one-dimensional, or a two dimensional array, the elements are stored in one continuous chain. The arrangement of array elements of a two-dimensional array in memory is :

* Forms of accessing a two dimensional array element is,
num [i][j], is represents the element in ith row and jth column
*(num[i] +j), *(*(num+i)+j)
Note : In C there is no check to see if the subscript used for an array exceeds the size of the array. Data entered with a subscript exceeding the array size will simply be placed in memory outside the array; probably on top of other data, or on the program itself. This will lead to unpredictable results, to say the least, and there will be no error message to warn you that you are going beyond the array size. In some cases the computer may just hang.
STRING:
The way a group of integers can be stored in an integer array, similarly a group of characters can be stored in a character array. Character arrays are many a time also called strings.
A string constant is a one-dimensional array of characters terminated by a NULL (’\0’).
Eg. : char name [ ] = { ’C’, ’L’, ’A’, ’N’, ’G’, ’U’, ’A’, ’G’, ’E’, ’\0’};
Note :
Each character in the array occupies one byte of memory and the last character is always ’\0’.
’\0’ is called NULL character, its looks like two characters, but it is actually only one character.
’\0’ and 0 are not same. ASCII value of ’\0’ is 0, whereas ASCII value of 0 is 48.
The elements of the character array are stored in contiguous memory locations.
The terminating NULL (’\0’) is important, because it is the only way the functions that work with a string can know where the string ends.
A string not terminated by a ’\0’ is not really a string, but merely a collection of characters.
A character array is stored in memory look like this

C provides a shortcut for initializing strings.
Eg. : char name [ ] = “CLANGUAGE”;
In this declaration ’\0’ is not necessary, C inserts ’\0’ automatically.
Pointers are used to declare strings.
Eg. : char *name=”C language”;
The %s used in printf ( ) as a format specification for printing out a string. The same specification can be used to receive a string from the keyboard.
Eg. : scanf (“%s”, name);
printf (“%s”, name);
(i) The scanf ( ) function fills in the characters typed at keyboard into the array until the enter key (or) spacebar is hit. Once the enter is hit, scanf ( ) places a ’\0’ in the array. Naturally, we should pass the base address of the array to the function scanf ( ).
(ii) scanf ( ) is not capable of receiving multi-word strings. Therefore names such as “Ranga Rao” would be unacceptable.
gets ( ) : It is capable of receiving only one string at a time, the plus point with gets ( ) is it can receive a multi-word string.
Eg. : gets (name);
puts ( ) : It is used to display only one string at a time unlike printf ( ), puts ( ) places the cursor on the next line.
Eg. : puts (“Hello !”);
puts (name);
Standard Library String Functions :
With every C compiler a large set of useful string handling library functions are provided.
1) strlen ( ) : Returns the length of the given string.
Syntax : strlen();
Eg. : L = strlen (“student”); returns 7.
2) strlwr ( ) : Converts given string to lower case.
Syntax : strlwr ()
Eg : strlwr (s);
Here, if *s = “STUDENT” then after execution of the above statement it becomes *s = “student”.
3) strupr ( ) : Converts given string to upper case.
Syntax : strupr ()
Eg. : strupr (s);
Here, if *s = “student” then after execution of the above statement it becomes *s = “STUDENT”.
4) strcat ( ) : Appends one string at the end of another.
Syntax : strcat (, ),
Eg. : strcat (t, s);
Here, if t[ ] = “C ” and s[ ] = “Language” then after execution of the above statement t[ ] = “C Language”.
5) strncat ( ) : Appends 1st n characters of a string at the end of another.
Syntax : strncat (, , no. of characters);
Eg. : strncat (t, s, 1);
Here, if t[ ] = “Let Us” and s[ ] = “Clanguage”. Then after execution of the above statement, t[ ] = “Let Us C”.
6) strcpy ( ) : Copies a string into another.
Syntax : strcpy (, )
Eg. : strcpy (t,s);
Here, if t[ ]=”above” and s[ ]=”below” then after execution of the above statement t[ ] becomes “below”.
7) strncpy ( ) : Copies 1st n characters of a string into another.
Syntax : strncpy (, ,no. of characters);
Eg. : strncpy (t,s,3);
Here, if t[ ]=”above” and s[ ]=”below” then after execution of the above statement t[ ] becomes “bel”.
8) strcmp ( ) : Compares two strings. It returns the difference between ASCII values of 1st and 2nd strings.
Syntax : strcmp (, )
Eg. : (i) v = strcmp (“COMPUTER”, “COMPUTER”);
It returns “0”, i.e., The strings are equal.
(ii) v = strcmp (“Computer”, “COMPUTER”)
It returns 32, because the ASCII value of “o” is 111, and the ASCII value of “O” is 79 then ’o’-’O’ = 111 – 79 = 32
9) strncmp ( ) : Compares 1st n characters of two strings.
Syntax : strncmp (, , no. of characters),
Eg. : v = strncmp (“Computer”, “Compiler”, 4);
It returns 0 i.e. two strings, are equal at 1st 4 characters.
10) stricmp( ) (or) strcmpi( ) : Compares two strings without regard
to case . (‘i’ denotes that this function ignores case).
Syntax : stricmp (, );
Eg. : v = stricmp (“COMPUTER”, “computer”);
It returns, ‘0’, i.e., both strings are same.
11) strnicmp ( ) : Compares 1st n characters of two strings without
regard to case.
Syntax : strnicmp (, , no. of characters);
Eg. : v = strnicmp (“COMPUTER”, “Compiler”, 4);
It returns “0”.
12) strdup ( ) : Returns a duplicate a string.
syntax : s = strdup ();
where‘s’ is a character string variable (pointer)
Eg. : char *t;
t = strdup (“Computer”)
Now, *t becomes “Computer”.
13) strchr ( ) : Returns 1st occurrence of a given character in a string.
Syntax : string variable = strchr (, );
And then calculate, “ – ” for required value.
Eg. : t = strchr (str, ‘S’);
v = t – str;
Here, consider str[ ] =
It returns “2” to v.
14) strrchr ( ) : Returns lst occurrence of a given character in a string.
Syntax : string variable = strrchr (, );
Eg. : t = strrchr (str, ‘S’);
v = t – str;
Here, consider str[ ] =
It returns “6” to v.
15) strstr ( ) : Returns 1st occurrence of a given string in another string.
Syntax : string variable – strstr (, );
Eg. : t = strstr (“chairs”, “air”);
v = t – “chairs” ,It returns 2,
16) strset ( ) : Sets all characters of string to a given characters.
Syntax : strset (, );
Eg. : strset (s, ‘*’);
Here if s [ ] = “TEXT”, then after the execution of the above statement it change to s [ ] = “****”;
17) strnset ( ) : Sets 1st n characters of a string to a given character.
Syntax : strnset (, , );
Eg. : strnset (s, ‘@’, 2);
Here, if s [ ] = “TEXT”, then after the execution of the above statement it change to s [ ] = “@@XT”
18) strrev ( ) : Reverses the given string.
syntax : strrev ();
Eg. : strrev (s);
Here, if s[ ] = “DOG”, changes to s[ ] = “GOD”.
Array of strings : An array of strings is a two dimensional array of characters.
Syntax : char arrayname [dimension1] [dimension2];
The second dimension specifies the length of the longest array string and each string is accessed by “arrayname [string number]”. Here, we do not need the second index. Arrayname [string number] is sufficient to access string at string number in array.
Eg. : char names [4][10] = { “Sachin”,
“Inzamam”,
“Sourav”,
“Sanath”
};
These strings arranged in memory look like this :

Array of pointers to strings :
A pointer variable always contains an address. Therefore, if we construct an array of pointers it would contain a number of addresses (Base addresses of respective names) i.e. Base address of 1st name is stored in 1st location, and 2nd name base address is stored in 2nd location and so on.
Eg. : char * names [ ] = { “Sachin”,
“Inzamam”,
“Sourav”,
“Sanath”
};
These strings are arranged in memory look like this

In the two dimensional array of characters, the strings occupied 40 bytes. As against this in array of pointers, the strings occupy only 29 bytes. Note that in two-dimensional array of characters, the last name ended at location number 1040, whereas in array of pointers to strings, it ends at 1029. Thus, one reason to stores strings in an array of pointers is to make a more efficient use of available memory.
Limitation of array of pointers to strings :
When we are using a two dimensional array of characters we are at liberty to either initialize the strings where we are declaring the array or receive the strings using scanf ( ) function. However, when we are using an array of pointers to strings we can initialize the strings at the place where we are declaring the array, but we cannot receive the strings from keyboard using scanf ( ).
FUNCTIONS
Definition : A number of statements grouped into a single logical unit is referred to as a function.
The functions are generally divided into two categories :
(a)Pre-defined functions:-
These functions were defined, previously in the computer.
Eg. : scanf ( ), printf ( ), clrscr ( ), strlen ( ), ….etc.
(b)User –defined functions:-
These functions are defined by the user, if necessary.
Eg. : factorial ( ), sum ( ), reverse ( ), …. etc.,
The above two types of functions further classified as two types :
Value return functions, Eg. : strlen ( )
Non-value return functions, Eg. : clrscr ( ).
Function definition : This is used to write code for a user defined function in a program.
Syntax : [return type] function name (var1, var2, …. var n)
var1, var2, …, var n;
{
Body of function;
}
(or)
[return type] functionname (type var1, type var2, …, type varn)
{
Body of function;
}
The function definition is also called “called function”. In this called function the return type and var1, var2, … varn are optional
Function calling : A function gets called when the function name is followed by a semicolon (;).
Syntax : functionname (var1, var2, …, varn);
Where, var1, var2, … Varn are optional,
The parameters in called function var1, var2, … varn are called “formal parameters”. Whereas the parameters in calling function var1, var2, …, varn are called “actual parameters”.
Eg. : main ( )
{
user ( );
}
user ( )
{
printf (“\n1 am in user defined function”)
}
Note:-
C program is a collection of one or more functions.
Any C program contains at least one function.
If a program contains only one function it must be main ( ).
In a C program if there are more than one functions present, then one (and only one) of these functions must be main ( ), because program execution always begins with main ( ).
There is no limit on the number of functions that might be present in a C program.
Each function in a program is called in the sequence specified by the function calls in main ( ).
After each function has done its thing, control returns to main(). When main ( ) runs out of function calls, the program ends.
All C functions enjoy a state of perfect equality. No precedence, no priorities, nobody is nobody’s boss.
One function can call another function.
Any function can be called from any other function. Even main ( ) can be called from other functions.
A function can be called any number of times.
The order in which the functions are defined in a program and the order in which they get called need not necessarily be same.
Eg. : main ( )
{
mess1 ( );
mess2 ( );
}
mess2 ( )
{
printf (“\n This is function 2”);
}
mess1 ( )
{
printf (“\n This is function1”);
}
A function can call itself. Such a process is called “Recursion.”.
A function can be called from other function, but a function cannot be defined in another function.
Eg. : main ( )
{
printf (“\n I am in main”);
India ( )
{
printf (“\n I am in India’);
}
}
This program code gives an error.
Use of functions :
Writing functions avoids rewriting the same code over and over.
Using functions it becomes easier to write programs and keep track of what they are doing. If the operation of a program can be divided into separate activities, and each activity placed in a different function, then each could be written and checked more or less independently. Separating the code into modular functions also makes the program easier to design and understand.
E.g: Write a program to add two numbers.
main ( )
{
add ( ) ;
}
add ( )
{
int a, b;
scanf (“%d%d”, &a, &b);
printf (“\n%d + %d = %d”, a,b, a+b);
}
Passing values between functions :
The functions that we have used so far have not been very flexible. Now we want to communicate between the “calling” and the “called” functions. The mechanism used to convey information to the function is the “argument”. The arguments are sometimes also called “parameters”.
Eg. : The format string and the list of variables used inside the parentheses in the printf ( ), scanf ( ) functions are called arguments.
Program : Eg. : Write a program to calculate sum of 3 numbers using functions.
int sum(int, int, int );
main ( )
{
int a, b, c, sum;
printf (\n Enter any 3 numbers”);
scanf (“%d%d%d”, &a, &b, &c);
sum = sum3 (a,b,c);
printf (“\n Sum = %d’, sum);
}
int sum3 (int x, int y, int z)
{
int d;
d = x + y + z;
return (d);
}
* In this program, from the function main ( ) the values of a, b and c are passed on to the function sum3( ), by making a call to the function sum3( ) and mentioning a, b, and c in the parentheses :
sum = sum3 (a,b,c);
In the sum3( ) function these values get collected in three variables x, y and z : Sum3 (int x,int y,int z);
The variables a,b and c are called “actual arguments” whereas the variables x,y and z are called “formal arguments”. Any number of arguments can be passed to a function being called. However, the type, order and number of the actual and formal arguments must always be same.
Instead of using different variable names x,y,z. We could have used the same variable names a,b and c. But the compiler would still treat them as different variables since they are in different functions.
* There are two methods of declaring the formal arguments. The one that we have used in our program and another one is known as Kernighan and Ritchie (K&R) method.
i.e.,
sum3 (x,y,z)
int x,y,z;
This method is not used in these days.
* In the earlier programs the moment closing brace ( }) of the called function was encountered the control returned to the calling function. No separate return statement was necessary to send back the control.
This approach is fine if the called function is not going to return any meaningful value to the calling function. In the above program, however, we want to return the sum of x, y and z therefore, it is necessary to use the “return” statement.
The “return” statement serves two purposes :
(i) On executing the return statement it immediately transfers the control back to the calling program.
It returns the value present in the parentheses after return, to the calling program. In the above program the value of sum of three numbers is being returned.
* There is no restriction on the number of return statements that may be present in a function. Also, the return statement need not always be present at the end of the called function.
* Whenever the control returns from a function some value is definitely returned. If a meaningful value is returned then it should be accepted in the calling program by equating the called function to some variable.
Eg. : char capital(char );
main ( )
{
char a, r ;
scanf (“%c”, &a);
r = capital (a);
printf (“%c”, r);
}
char capital(char x)
{
if(x>=65 && x<=90)
return x;
else if(x>=97 && x<=122)
return x-32;
else
return ’*’;
}
* All the following are valid return statements.
return (a);
return (5);
return;
In the last statement a garbage value is returned to the calling function since we are not returning any specific value.
* If we want that a called function should not return any value, in that case, we must mention so by using the keyword void, otherwise we must mention the data type of returned value. If we do not mention the type of returned value, compiler takes default return type as integer.
Eg. : void display ( )
{
printf (“\n Be simple, be sample”);
}
* A function can return only one value at a time. Thus return (a,b) is invalid.
* If the value of a formal argument is changed in the called function, the corresponding change does not take place in the calling function.
Scope of variables : There are two types of variables available in C according to their scope.
(i) Global variables : If we declare variables in the global declaration section, then these variables are use in entire program.
(ii) Local Variables : If we declare variables in the specified function block, then these variables will work only on this function block.
E.g:
int a; /* Where ‘a’ is global variable. */
main( )
{
int b; /* Where ‘b’ is local variable in main( ). */
my( );
}
void my( )
{
int b; /* Where ‘b’ is local variable in my( ). */
printf(“%d”,b);
}
Here, the both b’s are not same.
Function declaration and prototypes :
Any C function by default returns an int value. More specifically, whenever a call is made to a function, the compiler assumes that this function would return a value of the type int. If we desire that a function should return a value other than an int, then it is necessary to explicitly mention so in the calling function as well as in the called function. And the function type is declare in the variable declaration section, this is called the “prototype” of that function.
E.g :
float square(float);
main( )
{
float a,b;
printf(“\nEnter any number:”);
scanf(“%d”,&a);
b=square(a);
printf(“\nSquare of %f is %f”,a,b);
}
float square(float x)
{
float y;
y=x*x;
return y;
}

Arguments can generally be passed to functions in one of the two ways :
(i) Sending the values of the arguments :
The “value” of each of the actual arguments in the calling function is copied into corresponding formal arguments of the called function. With this method the changes made to the formal arguments in the called function have no effect on the values of actual arguments in the calling function. This is called “call by value”.
Eg. :
main( )
{
int a=30,b=50;
printf(“\nBefore swapping: a = %d, b = %d”,a,b);
swapcbv(a,b);
printf(“\nAfter swapping: a = %d, b = %d”,a,b);
}
void swapcbv(int x,int y)
{
int t;
printf(“\nBefore swapping: x = %d, y = %d”,x,y);
t=x;
x=y;
y=t;
printf(“\nAfter swapping: x = %d, y = %d”,x,y);
}
Output :
Before swapping a = 30, b = 50
Before swap x = 30, y = 50
After swap x = 50, y = 30
After swap a = 30, b = 50
(ii) Sending the addresses of the arguments :
The “addresses” of actual arguments in the calling function are copied into formal arguments of the called function. This means that using these addresses we would have an access to the actual arguments and hence we would be able to manipulate them. This method is called “call by reference”.

main( )
{
int a=30,b=50;
printf(“\nBefore swapping: a = %d, b = %d”,a,b);
swapcbr(&a,&b);
printf(“\nAfter swapping: a = %d, b = %d”,a,b);
}
void swapcbr(int *x,int *y)
{
int t;
printf(“\nBefore swapping: x = %d, y = %d”,*x,*y);
t=*x;
*x=*y;
*y=t;
printf(“\nAfter swapping: x = %d, y = %d”,*x,*y);
}
Output :
Before swapping a=30,b=50
Before swapping x=30,y=50
After swapping x=50,y=50
After swapping a=50,b=30

Note : Using a call by reference intelligently we can make a function return more than one value at a time, which is not possible by using “call by value”.
Recursion: Expressing an entity in terms of itself is called recursion. And a function that contains a function call to itself (recursive call), or a function call to a second function which eventually calls that 1st function, is known as a recursive function
E.g. /* Recursive function for find factorial of given number.*/
int fact(int x);
void main( )
{
int n,f;
printf(“\nEnter any +ve integer:”);
scanf(“%d”,&n);
f=fact(n);
printf(“\nThe factorial value of %d is: %d”,n,f);
}
int fact(int x)
{
if(x = = 0)
return 1;
else
return x*fact(x-1);
}

Three important conditions must be satisfied by way recursive function.
Each time a function calls itself it must be closer, in some sense to a solution.
There must be a decision criterion for stopping the process or computation.
We do not use recursive calls within loops.


Arrays to functions :
Arrays can be passed as arguments to functions. Thus, just passing the address of 0th element of the array to a function is as good as passing the entire array to the function. It is also necessary to pass the total number of elements in the array; otherwise the function would not know the size of the array.
* The address of 0th element (is called base address) can also be passed by just passing the name of array
Eg. :
void main( )
{
int a[30],n;
printf(“\nEnter array size:”);
scanf(“%d”,&n);
scan(a,n);
print(a,n);
}
void scan(int *d,int x) /* Call by reference. */
{
int i;
for(i=0;i scanf(“%d”,d[i]);
}
void print(int d[30],int x) /* Call by value. */
{
int i;
for(i=0;i printf(“%d\t”,d[i]);
}
DATA TYPES AND STORAGE CLASSES
The primary data types themselves could be of several types, viz.,
Integers, long and short :
* An integer constant is any number in the range –32768 to +32767. This is because an integer constant always occupies two bytes in memory.
* Out of the two bytes used to store and integer, the highest bit (16th bit) is used to store the sign of the integer.
This bit is 0, if the number is +ve.
1, if the number is –ve
* Long integers would occupy 4 bytes of memory. These variables are declared using the keyword “long”.
Eg. : long int a ; (or) long a;
* Long integers cause the program to run a bit slower, but the range of values that we can use is expanded from –2147483648 to +2147483647.
* If we add the suffix ‘L’ or ‘l’ at the end of the number, it indicates it is long integer.
Eg. : 45 is an integer and would occupy two bytes, whereas 45L is a long integer and hence would occupy 4 bytes of memory.
* short int is nothing but our ordinary int.
* short int are need less space in memory and thus help speed up program execution.
Eg. : short int a; (or) int a;
Integers, signed and unsigned :
* Unsigned integers are used to represent only +ve numbers. The 16th bit is now free and is not used to store the sign of the number, unsigned int still occupy two bytes.
Eg. : unsigned int a; (or) unsigned a;
By default short int is a signed short int and a long int is a signed long int.
Chars, signed and unsigned :
* Both signed char and unsigned char occupying one byte each, but having different ranges.
* A signed char is same as our ordinary char and has a range from –128 to +127.
* An unsigned char has a range from 0 to 255.
Floats and doubles :
* A float occupies 4 bytes in memory and can range from –3.4e38 to +3.4e38.
* A double occupies 8 bytes in memory and can range from –1.7e308 to +1.7e308.
Eg. : double a;
A long double occupies 10 bytes in memory and can range from –1.7e4932 to 1.7e4932.
Eg. : long double a;

Data type Range Bytes Format
signed char -128 to +127 1 %c
unsigned char 0 to 255 1 %c
short signed int -32768 to +32767 2 %d
short unsigned int 0 to 65535 2 %u
long signed int -2147483648 to +2147483647 4 %ld
long unsigned int 0 to 4294967295 4 %lu
float -3.4e38 to + 3.4e38 4 %f
double -1.7e308 to +1.7e308 8 %lf
long double -1.7e4932 to + 1.7e4932 10 %Lf
Scope : Scope of a variables can be defined as the region over which the variable is visible or valid. We shall deal with scope fewer than two categories.
(i) Block scope : A block is defined as a sequence of statements enclosed between curly braces ({&}).
In other words, a block is a compound statement.
Eg. A function body is a block, because it is simply a sequence of statements enclosed within curly braces.
This is referred to as nesting of blocks.
(ii) File scope : Variables declared outside all functions are said to have global scope. Global variables can be classified under two categories.
Static (or) file static variables, whose scope is limited to the file in which it is declared,
Global variables, which can be accessed across files which are linked together.
Extent : The period of time during which memory is associated with a variable is called the extent or life of the variable.
Storage classes : The life time of a variable is characterized by its storage class. The storage class of a variable indicates the allocation of storage space to the variable. Thus, storage classes define the extent of a variable.
Storage class tells us,
* Where the variable would be stored.
* What will be the initial value of the variable, if the initial value is not specifically assigned. (i.e. the default initial value)
* What is the scope of the variable i.e., in which functions the value of the variable would be available.
* What is the life of the variable i.e. how along would the variable exists.
There are 4 storage classes in C
(a) Automatic storage class à auto
(b) Register storage class à register
(c) Static storage class à static
(d) External storage class à extern
(a) Automatic storage class :
All variables declared within a function are auto by default. The extent of a variable is defined by its scope. Variables declared auto can only be accessed only within the function or the nested block within which they are declared. They are created when the block is entered into and destroyed when it is exited.
Storage à Memory
Default initial value à An unpredictable value, which is often called a
garbage value.
Scope à Local to the block in which the variable is defined.
Life à Till the control remains within the block in which
the variable is defined.
Eg. : auto int a; (or) auto a;
Program :
void main( )
{
auto int i=1;
{
auto char i=’B’;
{
auto int i=5;
printf(“%d\n”,i);
}
printf(“%c\n”,i);
}
printf(“%d\n”,i);
}
Sample run:-
5
B
1


Register storage class :
C allows the use of the prefix “register” in primitive variable declarations. Such variables are called register variables, and are stored in the registers of the microprocessor (CPU). The number of variables which can be declared register are limited. If more variables are declared as register variables, they are treated as auto variables. Because the number of CPU registers are limited (14 in case of micro computers), and they may be busy doing some other task. A value stored in a CPU register can always be accessed faster than the one which is stored in memory. Therefore, if a variable is used at many places in a program it is better to declare its storage class as register. Good examples of frequently used variables are loop counters. We cannot use register storage class for all types of variables. Because the CPU registers in a microcomputer are usually 16 bit registers and therefore cannot hold a float value or a double value, which require 4 and 8 bytes respectively for storing a value.
Storage à CPU registers
Default initial value à Garbage value
Scope à Local to the block in which the variable is defined.
Life à Till the control remains within the block in which
the variable is defined.
Eg. :
void main( )
{
register int i;
for(i=0;i<=100;i++)
printf(“%d\n”,i);
}
c) Static storage class :
Use “static” storage class only if you want the value of a variable to persist between different function calls. A typical application of this storage class is recursive functions.
Storage à Memory
Default initial value à Zero
Scope à Local to the block in which the variable is defined.
Life à Value of the variable persists between different
function calls.
Eg. :
void main( )
{
static int i;
if(i<=10)
{
printf(“%d”,i++);
main( );
}
}
Sample Run : 012345678910
(d) External storage class :
Use “extern” storage class for only those variables which are being used by almost all the functions in the program. This would avoid necessary passing of these variables as arguments when making a function call. Declaring all the variables as extern would amount to a lot of wastage of memory space because these variables remain active throughout the life of the program.
Storage à Memory
Default initial value à Zero
Scope à Global
Life à As long as the program’s execution does not come
to an end.
Eg. : extern int a;
STRUCTRURE AND UNIONS
Structure :
A structure contains a number of data types grouped together. These data types may or may not be of the same type.
Syntax :
struct
{
;
;
………………………………
………………………………
;
} [structure type variables];
Here, the identifier “” is called “structure tag” or simply “tag”. This tag is considered to be a new type defined by the user. No memory has been allocated to the structure so far. To use this structure in a program, we must define a structure variable as :
struct ;
or in the above style.
Eg. :
struct employee
{
char name[20];
int number;
float salary;
} emp1,emp2;



(or)
struct employee
{ char name[20];
int number;
float salary;
} ;
struct employee emp1,emp2;
Here, the statement defines a new data type called struct employee. Each variable of this data type will consists of a character variable ‘name’, an int variable ‘number’, and a float variable ‘salary’.
* The closing brace ( }) in the structure type declaration must be followed by a semicolon (;).
* It is important to understand that a structure type declaration does not tell the compiler to reserve any space in memory. All a structure declaration does is it defines the ‘form’ of the structure.
* Usually structure type declaration appears at the top of the source code file, before any variables or functions are defined. In very large programs they are usually put in a separate header file, and the file is included in whichever program we want to use this structure type.
Accessing structure elements : In structures we can access individual elements of a structure using a dot (.) operator.
Eg. : emp1.salary, is refer to salary of emp1.
* Note that before the dot there must always be a structure variable and after the dot there must always be a structure element.
Storage of structure elements : Whatever be the elements of a structure, they are always stored in contiguous memory locations.
Eg. : struct employee emp1 = { “Ram”, 34,2000.0};
Memory map of structure elements




It is possible to declare an array of structures. The array will have individual structures as its elements.
Eg. :
struct employee
{
char name[20];
int number;
float salary;
} employs[1000];
Here, employs is an array of 1000 employee structure. Each element of the array employs will contain the structure of type employee. The employee structure consists of three individual members: an array name, number and salary.
The syntax we use to reference each element of the array employs is similar to the syntax used for arrays of ints and chars.
E.g:
employs[0].name, is used to refer the 1st employee name.
employs[938].number, is used to refer the 939th employee number.
In an array of structures all elements of the array are stored in adjacent memory locations. Since each element of this array is a structure, and since all structure elements are always stored in adjacent locations you can very well visualize.
Eg. : employs [0]’s name, number and salary would be immediately followed by employs [1]’s name, number, and salary and so on.
The values of a structure variable can be assigned to another structure variable of the same type using the assignment operator. It is not necessary to copy the structure elements “piece-meal”. Obviously, programmers prefer assignment to piece-meal copying.


E.g:
void main( )
{
struct employee
{
char name[20];
int number;
float salary;
}e1,e2;
struct employee e3={ “Sachin”,5,20000.50};
/* Piece-meal copying */
strcpy(e1.name,e3.name);
e1.number=e3.number;
e1.salary=e3.salary;
/* Copying all elements at a time */
e2=e3;
printf(“\n%s\t%d\t%f”,e1.name,e1.number,e1.salary);
printf(“\n%s\t%d\t%f”,e2.name,e2.number,e2.salary);
printf(“\n%s\t%d\t%f”,e3.name,e3.number,e3.salary);
}
One structure can be nested within another structure using this facility complex data types can be created.
Eg. :
struct students
{
char name[20];
int number;
struct date
{
int day;
int month;
int year;
}doj;
int marks;
}student1;
Here, student1.doj.month refers the student1’s month of joining and student1.doj.year refers the student1’s year of joining.
A structure variable can also be passed to a function. We may either pass individual structure elements or the entire structure at a time.
Eg. :
Display(e1.name,e1.number,e1.salary); /* calling */
void Display(char *s,int n,float a) /* definition */
{
printf(“\n%s\t%d\t%f”,s,n,a);
}
(or)
Display(e1); /* calling */
void Display(struct employee e) /* definition */
{
printf(“\n%s\t%d\t%f”,e.name,e.number,e.salary);
}
We can have a pointer pointing to a structure. Such pointers are known as “structure pointers”. In such cases C provides an operator ‘->’, called an “arrow operator” to refer to the structure elements. Remember that on the left hand side of the “.” Structure operator, there must always be a structure variable, whereas on the left hand side of the “->” operator there must always be a pointer to a structure.


E.g:
void main( )
{
struct employee
{
char name[20];
int no;
float sal;
} *ptr;
struct employee e1={“Aswin”,512,2000.0};
ptr=&e1;
printf(“\n%s\t%d\t%f”,e1.name,e1.no,e1.sal);
printf(“\n%s\t%d\t%f”,ptr->name,ptr->no,ptr->sal);
}
This structure in memory

Note : - Initialization not allowed in structure declaration.
UNIONS :
A union is a data type in C which allows the overlay of more than one variable in the same memory area. All variables inside a union share storage space. The compiler will allocate sufficient storage for the union variables to accommodate the largest element in the union. Other elements of the union use the same space. This is how a union differs from a structure. Individual variables in a union occupy the same location in memory. Thus, writing into one will overwrite the other. Elements of a union are accessed in the same manner as the elements of a structure.
Syntax:
union
{
;
;
…………………………….
…………………………….
;
} [union type variables];
E.g:
union position
{
int left;
int right;
int top;
int bottom;
} cursor1, cursor2;
Differences between structure and unions :
· The amount of memory required to store a structure variable is the sum of sizes of all the members in addition to the padding bytes that may be provided by the compiler. On the other hand, in case of a union, the amount of memory required is the same as that required by its largest member.


E.g:-
struct a
{
int i;
char ch[2];
} s;

union a
{
int i;
char ch[2];
} s;
While all the structure members can be accessed at any point of time, only one member of a union may be accessed at any given time. This is because, at any instant only one of the union variables will have a meaningful value, only that member which is last written, can be read. At this point, other variables will contain garbage.
E.g:-
if s.i=512 then s.ch[0]=0 and s.ch[1]=2
if s.ch[0]=50 then s.i=562 and s.ch[1]=2
Uses of structures and unions :
Structures are used to maintain database management
Changing the size of the cursor.
Clearing the contents of the screen.
Placing the cursor at appropriate position on screen.
Drawing any graphics shape on the screen
Receiving a key from the keyboard
Checking the memory size of the computer
Finding out the list of equipment attached to the computer
Formatting a floppy
Hiding a file from the directory
Displaying the directory of a disk
Sending output to printer
Interacting with the mouse.

I/O FUNCTIONS
There are numerous library (pere-define) functions available for I/O (input/out put). These can be classified into three broad categories:
Console I/O functions:-
Functions to receive input from keyboard and write output to VDU.
Disk I/O functions:-
Functions to perform I/O operations on floppy disk or hard disk.
Port I/O functions:-
Functions to perform I/O operation on various ports.
Console I/O functions:-
Console I/O function can be further classified into two categories:
Formatted and
Unformatted console I/O functions.

Ex:- printf( ),scanf( ) Ex:- puts( ), gets( ).
Formatted Functions:- Allow the input read from the keyboard or the output displayed on the VDU [visual display unit i.e, monitor] to be formatted as per our requirements.
Ex:- If values of average marks and percentage marks are to be displayed on the screen, than the details like where this output would appear on the screen, how many spaces would be present between the two values, the number of places often the decimal points...etc, can be controlled using formatted functions.
printf( ):- used to print values on the screen.
Syntax:- printf(“” [variables list separated by commas]);
Format string contains:
Characters that are simply printed as they are
Conversion specification that being with “a%” sign.
Escape sequences the being with a”\” sign.

Data Type Format Convention Character
int Integer
Long integer
Unsigned int %i, %p, %hd, %hi
%li
%hu
Hexadecimal
Octal %x, %lx
%o, %lo
Float float (exponential)
double
%e, %E, %g, %G
%le, %lf, %lg,
%he, %lf, %lg

None % %
We can provide following optional specifies in the conversion specifications.

Specifier Description
Dd digits specifying field width
.dd
decimal point separating field width from precision[precision stands for the number of place after the decimal point]
digits specifying precision

- minus sign for left justifying the output in the specified filed width.
E.g. (1) printf(“\nWeight is %d kg”,63);
(2) printf(“\nWeight is %6d kg”,63);
printf(“\nWeight is %-6d kg”,63);

output:-

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
W e i g h t i s 6 3 k g
W e i g h t i s 6 3 k g
W e i g h t i s 6 3 k g
(ii) printf(“\n%10.2f%10.1f”, 305.6542,3000.956)
output:-

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
3 0 5 . 6 5 3 0 0 1 . 0
(iii) printf(“%20s”, “INDIA”)
output:-

0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
I N D I A
Escape Sequences:-
These are used to print the output on the screen where we want.

Esc. Sequence Purpose Esc. Sequence Purpose
\n new line \t tab space
\b back space

\f form feed
\` single quote
\\ back slash
\” double quote \a alert(beep sound)
Eg:- printf(“he said, \” lets do it !\” “);
Output:- he said, “let’s do it !”
printf(“welcome\t to\t the\n computer\t world”);
Output:- welcome to the
Computer world.
Note:- printf( ) uses the specification that we mention and attempts to perform. The specified conversion, and does its best to produce a proper result
Eg:- printf(“%c”, 65);
Output: A
scanf( ):- used to take values from keyboard.
Syntax:- scanf(“”, );
We are sending addresses of variables (addresses are detained by using `&` the `address of ` of operator) to scanf( ) functions this is necessary because the values corresponding to these addresses. The values that are supplied thought the keyboard must be separated by either blanks, tabs or new lines. Do not include these escape sequences in the format string.
Ex:- scanf(“%d%f”, &b, &c);
White space characters:
If scanf( ) encounters a white space characters in the format string, it reads, but doesn’t store consecutive white space characters till the next non-white space character in the input.
Ex:- scanf(“%d/%d/%d”, &day, &month, &year);
Input:- 01/02/2005
cprintf( ), cscanf( ):- these are used similarly printf( ), scanf( ) function.
sprintf( ):- Instead of sending the output to the screen, this function writes the output to an array of characters.
Syntax:- sprintf(, “”, );
sscanf( ):- Instead of taking the input from the keyboard, this function takes the input from an array of characters.
Syntax:- sscanf(, “”, &);
Unformatted functions:
There are several standard library functions available under this category. Those which can deal with a single character and those which can deal with a string of characters.
getche( ):- Used to read a single character, the instant it is typed without waiting for the enter key to do hit. This function return the character that has been most recently typed. The `e` in getche( ) function means it echoes (displays) the character that you typed to the screen.
Ex:- ch=getche( ); // ch is a character variable.
getch( ):- This is work like getche( ), but it returns the character that you typed without echoing it on the screen.
Ex:- ch=getch( );
getchar( ):- This is a macro, it works similarly and echoes the character that you typed on the screen, but it requires enter key to be typed following the character that you typed.
Ex:- ch=getchar( );
fgetchar( ):- This is a function, it works similarly getchar( );
Ex:- ch=fgetchar( );
putch( ), putchar( ), fputchar( ):- These can print only one character on the screen at a time. As fas as the working of these functions is concerned its exactly some.
Ex:- putch(ch); putch(`R`);
putchar(ch); putchar(`R`);
fputchar(ch); fputchar(`R`);
gets( ):- Is capable of receiving only one string at a time, the plus point with gets( ) is it can receive a multi-word string.
Ex:- gets(name);
puts ( ):- Is capable of used to display only string at a time unlike printf( ), puts( ) places the cursor on the next line.
Ex:- puts(“rahul dravid”);
puts(name);
getc( ):- getc( ) is a macro that gets one character from a stream.
Syntax:- getc();
Ex:- ch=getc(stdin);
putc( ):- putc( ) is a macro that outputs a character to a stream.
Syntax:- putc(, );
Ex:- putc(ch, stdout);

Standard File Pointer [Stream] Description
stdin Standard input device[key board]
stdout Standard output device [VDU]
stderr Standard error device[VDU]
stdaux standard auxiliary device[serial port]

stdprn
standard printing device [parallel
printer]

fflush( ):- It is designed to remove or flush out any data remaining in the buffer. The argument to fflush( ) must be the buffer which we want to flush out. Here we use “stdin”, which means buffer related with standard input device the keyboard.
Ex:- fflush(stdin);

D.M.A
(DYNAMIC MEMORY ALLOCATION)
Memory Allocation Functions:
These function are used to allocate memory space for variables dynamically, in terms of bytes.
malloc ( ): This is used to allocate given size of memory. It assigns to memory initially garbage values.
Syntax:- pointer variable=(return type*) malloc(size of memory);
Ex:- iptr=(int *) malloc(3* sizeof (int));
This is used to allocate 6 bytes memory for iptr.
calloc( ):- This is also used to allocate memory for given no.of items. It assigns to memory initially zero.
Syntax:- pointer variable=(return type *) calloc (no.of items, size);
Eg:- cptr=(char *) calloc(3, sizeof (char));
This is used to allocate 3 bytes memory for cptr.
realloc( ):- This is used to reallocate memory for previously allocated memory.
Syntax:- pointer variable=(return type*) realloc(block, size);
Here, block is a pointer previously allocated memory by malloc( ) or calloc( ). If block is NULL then the realloc is works like malloc( ).
Ex:- iptr=(int*)realloc(iptr, 3* sizeof (int));
free( ):- This is used to free the previously allocated memory.
Syntax:- free(pointer variable);
Ex:- free(iptr);
NOTE:- If the memory allocation is successfully created then these functions returns non-zero value otherwise it returns NULL.

FILES
Disk I/O Functions:-
Disk I/O Operations are performed on entities called files. There are a large number of standard library functions available for performing Disk or file I/O. These functions can be badly divided into two categories.
High level file I/O functions
[Standard I/O or stream I/O functions]
Low level file I/O functions
[System I/O function]
High level disk I/O functions are more commonly used in c programs, since they are easier to use than low level disk I/O functions. There is one basic difference between high low level disk I/O function high level disk I/O functions do their own buffer management. Where as in low level disk I/O functions, buffer management has to be done explicitly by the programmer.
Low level disk. I/O is harder to program than high level disk I/O. However, low level disk I/O is more efficient both in terms of operation and the amount of memory used by the program.

Before we can write in formation to a file on a discord read it, we must open the file opening a file establishes a link between the program and the operating system, about, which file we are going to access and how. We provide the operating system with the name of the file and whether we plan to read or write to it. The link between our program and the operating system is a structure called FILE which has been defined in the header file “stdio.h” Therefore, it is necessary to always include this file when we are doing high level disk I/O. When we request the operating system to open a file, what we get back, is a pointer to the structure FILE. We must declare the FILE pointer before opening the file.
Syntax:- FILE ;
Each file we open will have its own FILE structure. The FILE structure contains information about the file being used, such as its current size, its location in memory etc. More importantly it contains a character pointer which points to the character that is about to get read. Where pointer variable contains address of the structure FILE.
Ex:- FILE *fp;
Opening of a file:-
fopen( ) is used to open a file. If an fopen( ) statement is successfully open a file. The it will return the address of that file, otherwise it will returns a NULL.
Syntax:- =fopoen(“”,””);
File opening modes:- The high level disk I/O functions can be categorized as text and binary. This classification arises out of the mode in which a file is opened. The are three main areas where text and binary mode files are different these are:
Handling of new lines:-
In text mode, a new line character is converted into the carriage return line feed combination before being written to the disk. Likewise the carriage return line feed combination on the disk, is converted back into a new line when the file is read by a C program. However, if a file is opened in a binary mode as opposed to text mode, these convert ions will not take place.
Representation of end of file:-
In text mode a special character, whose ASCII value is 26, inserted after the last character in the file to mark the end of file. If this character is detected at any point in the file, the read function would return the EOF signal to the program. As against this, there is now such special symbol or character present in the binary mode files keep track of the end of file from the number of character present in the directory entry of the file.
Storage of numbers:-
Numbers are stored as strings of character in text mode (i.e., 1234 occupies two types in memory, when transferred to the disk, it would occupy four bytes, one byte per character). In binary mode numbers are stored as binary format. It means each number would occupy same number of bytes on disk as it occupies in memory.
Types Of Modes:-

Mode Opening Possible Operations
“r” (or) “rt”, “rb” Searches file. If the file exists, loads, it into memory and sets up a pointer which point to the 1st character in it. If the file doesn’t exists it returns NULL. Reading data from the file
“w” (or) “wt”, “wb” Searches files. If the file exists, its contents are overwritten otherwise a new file is created. Return NULL, if unable to create file. Writing data to the file
“a” (or) “at”, “ab” Searches files. If the file exists, loads it into memory and sets up a pointer which pointer to the 1st character in it, otherwise a new file is created. Returns NULL, if unable to open file. Appending New contents at the end of file.
“r+” (or) “r++”, “r+b”
Same as “r” Reading existing contents, writing new contents, modifying existing contents of the file.
“w+” (or) “w++”, “w+b” Same as “w” Same as “rt”
“a+” (or) “a++”, “a+b” Same as “a” Reading existing contents, appending new contents to end of file. Cannot modify existing contents.

Here, if represents text mode and “b” represents binary mode. Default mode is text mode.
Ex:- fp=open(“prime.c”, “r”);
Here, firstly it searches on the disk the file to be opened. If the file is present, it loads the file from the disk into memory. If the file is very big, then it loads the file part by part. [If the file is absent, fopen( ) returns a NULL. NULL is a macro, defined in “stdio.h” Which indicates that you failed to open the file.] It sets up a character pointer which is part of FILE structure which points to the1st character of the chunk of memory where the file has been loaded.
Closing of a file:- When we have finished reading from the file, we need to close it. This is done using the function fclose( ).
Syntax:- fclose();
Ex:- fclose(fp);
File Handling Functions:-
1.fgetc( ):- It reads the character from current pointer position, advances the pointer position so that it now points to the next character and returns the character that is read. If it reaches end of file, it will returns “EOF” character.
Syntax:- variable=fgetc(file pointer);
Ex :- ch=fgetc(fp);
The character EOF can also be generated from the keyboard by pressing “ctrl + z”.
2.fputc( ):- It writes a character to a file.
Syntax:- fputc(character , file pointer);
Ex :- fputc (ch,ft);
3.fgets( ):- It reads a string from a file. It it reaches end of file, it will return NULL.
Syntax:- fgets(string variable, length of string, file pointer);
Ex :- fgets(str,100,fp);
4.fputs( ):- It writes a string to a file.
Syntax:- fputs(string, file pointer);
Ex :- fputs(str, fp);
5. fprintf( ):- Which writes the values of variables to the file. This function is similar to printf( ), except that a FILE pointer is include as the 1st argument. As in printf( ), we can format the data in a variety of ways, by using fprintf( )
Syntax:- fprintf(file pointer,. “format string”, addresses of variables);
Ex :- fprints (fp ,“%d\t%s\t%f\n”, no,name,s);
6.fscanf( ):- used to read the data from the disk. This function is similar to scanf( ) except that a pointer to FILE included as the 1st argument. This function returns EOF at the end of the file.
Syntax:- fscanf(file pointer, “format string”, address of variables)
Ex:- fscanf(fp, “%d%s%f”, &no, name, &s);
7.fwrite( ):- This function is used to store entire record (structure) to the file.
Syntax:- fwrite(address of record, size of record no.of records, filepointer);
Ex :- fwrite(&emp, sizeof (emp),1 fp);
8.fread( ):- This function is used to retrieve the entire record from disk. This function returns “0” at the end of the file.
Syntax:- fread(address of record, size of record, no.of records, filepointer);
Ex :- fread(&emp, sizeof (emp)1, fp);
9.rewind( ):- Used to replace the cursor at the top left corner (1st position) of the file.
Syntax:- rewind (file pointer);
Ex :- rewind (fp);
10.fseek( ):- This function is used to move the pointer from one record to another.
Syntax:- fseek(file pointer, records size to move, position);


Position Meaning
SEEK_END Move the pointer from the end of file.
SEEK_CUR Move the pointer with reference to its current position.
SEEK_SET Move the pointer with reference to the beginning of the file.

Ex:- fseek(fp, sizeof (emp), SEEK_SET);
11. ftell( ):- It returns pointer position as a long int.
Syntax:- long int variable=ftell(file pointer);
Ex :- p=ftell(fp);
12. ferror( ):- Reports any error that might have occurred during a read/writer operation on a file. It returns a zero if read/writer is successful and a non-zero value in case of a failure.
13. perror( ):- Which prints the error message specified by the compiler.
Ex:- if (ferror( ))
{
perror(“error”)
break;
}
14. remove( ):- It is used to delete a file from disk.
Syntax:- remove (filename);
Ex :- remove(“simple.c”);
15. rename( ):- It is used to change the name of any existing file.
Syntax:- rename(old file name, new file name);
Ex :- rename(“simple.cf”, “sample.cpp”);
16. feof( ):- This function is used to check the file is end or not. If it is end of file then it returns a non-zero value otherwise it returns a zero.