Loops
The versatility of the computer lies in its ability to perform a set of
instructions 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 instruction.
There are three methods by way of which we can repeat a part of a
program. They are:
(a) Using a for statement
(b) Using a while statement
(c) Using a do-while statement
The while Loop
It is often the case in programming that you want to do something
a fixed number of times.The while loop is ideally suited for such cases.
The general form of while is as shown below:
initialise loop counter ;
while ( test loop counter using a condition )
{
do this ;
and this ;
increment loop counter ;
}
here is example:-
int i = 1 ;
while ( i <= 10 )
{
printf ("%d\n", i ) ;
i = i + 1 ;
}
The for Loop
The for allows us to specify three things about a loop in a single line:
(a) Setting a loop counter to an initial value.
(b) Testing the loop counter to determine whether its value has
reached the number of repetitions desired.
(c)Increasing the value of loop counter each time the program
segment within the loop has been executed.
The general form of for statement is as under:
for ( initialise counter ; test counter ; increment counter )
{
do this ;
and this ;
and this ;
}
The do-while Loop
The do-while loop looks like this:
do
{
this ;
and this ;
and this ;
and this ;
} while ( this condition is true ) ;
This means that do-while would execute its statements at least
once, even if the condition fails for the first time. The while, on
the other hand will not execute its statements if the condition fails
for the first time. do while test condition at the end whereas
while test condition at the start.
Multiple Initialisations in the for Loop
The initialisation expression of the for loop can contain more than
one statement separated by a comma.
For example,
for ( i = 1, j = 2 ; j <= 10 ; j++ )
Multiple statements can also be used in the incrementation
expression of for loop.However, only one expression is allowed
in the test expression.
Nesting of Loops
The way if statements can be nested, similarly whiles and fors can
also be nested.
The Odd Loop
/* Execution of a loop an unknown number of times */
main( )
{
char another ;
int num ;
do
{
printf ( "Enter a number " ) ;
scanf ( "%d", &num ) ;
printf ( "square of %d is %d", num, num * num ) ;
printf ( "\nWant to enter another number y/n " ) ;
scanf ( " %c", &another ) ;
} while ( another == 'y' ) ;
}
/* odd loop using a for loop */
main( )
{
char another = 'y' ;
int num ;
for ( ; another == 'y' ; )
{
printf ( "Enter a number " ) ;
scanf ( "%d", &num ) ;
printf ( "square of %d is %d", num, num * num ) ;
printf ( "\nWant to enter another number y/n " ) ;
scanf ( " %c", &another ) ;
}
}
/* odd loop using a while loop */
main( )
{
char another = 'y' ;
int num ;
while ( another == 'y' )
{
printf ( "Enter a number " ) ;
scanf ( "%d", &num ) ;
printf ( "square of %d is %d", num, num * num ) ;
printf ( "\nWant to enter another number y/n " ) ;
scanf ( " %c", &another ) ;
}
}
The break Statement
When break is encountered inside any loop, control automatically passes to the
first statement after the loop. A break is usually associated with an
if.
The keyword break, breaks the control only from the while in
which it is placed.
The continue Statement
When continue is encountered inside any loop,
control automatically passes to the beginning of the loop.
A continue is usually associated with an if.
Decisions Using switch
The control statement that 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. They most often appear as follows:
switch ( integer expression )
{
case constant 1 :
do this ;
case constant 2 :
do this ;
case constant 3 :
do this ;
default :
do this ;
}
The integer expression following the keyword switch is any C
expression that will yield an integer value. It could be an integer
constant like 1, 2 or 3, or an expression that evaluates to an
integer. The keyword case is followed by an integer or a character
constant. Each constant in each case must be different from all the
others. The “do this” lines in the above form of switch represent
any valid C statement.
What happens when we run a program containing a switch? First,
the integer expression following the keyword switch is evaluated.
The value it gives is then matched, one by one, against the
constant values that follow the case statements. When a match is
found, the program executes the statements following that case,
and all subsequent case and default statements as well. If no
match is found with any of the case statements, only the
statements following the default are executed.
The goto Keyword
the general form of goto is:
goto label;
label:
Avoid goto keyword! They make a C programmer’s life miserable.
There is seldom a legitimate reason for using goto, and its use is
one of the reasons that programs become unreliable, unreadable,
and hard to debug. And yet many programmers find goto
seductive.
In a difficult programming situation it seems so easy to use a goto
to take the control where you want. However, almost always, there
is a more elegant way of writing the same program using if, for,
while and switch. These constructs are far more logical and easy
to understand.
Function
A function is a self-contained block of statements that perform a
coherent task of some kind. Every C program can be thought of as
a collection of these functions.
the general form of the function is
return-type function_name(type varname1,type varname2,..............,type varnameN)
{
body of the function
}
return type specifies the type of data that the function returns.
example of return type are int,float,double,void,char
Note on return type:-
if you specified void
then function return nothing.
if you specified int
then function return integer value
if you specified float
then function return float value
if you specified char
then function return char value
and so on like this.
that which specified it return that value.
Passing Values between Functions
/* Sending and receiving values between functions */
main( )
{
int a, b, c, sum ;
printf ( "\nEnter any three numbers " ) ;
scanf ( "%d %d %d", &a, &b, &c ) ;
sum = calsum ( a, b, c ) ;
printf ( "\nSum = %d", sum ) ;
}
calsum ( x, y, z )
int x, y, z ;
{
int d ;
d = x + y + z ;
return ( d ) ;
}
And here is the output...
Enter any three numbers 1 2 3
Sum = 6
the values of a, b and c are passed on to the function calsum( ),
by making a call to the function calsum( ) and mentioning a, b and c
in the parentheses:
sum = calsum ( a, b, c ) ;
In the calsum( ) function these values get collected in three
variables x, y and z:
calsum ( x, y, z )
int x, y, 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.
There are two methods of declaring the formal arguments.
The one that we have used in our program is known as
Kernighan and Ritchie (or just K & R) method.
calsum ( x, y, z )
int x, y, z ;
Another method is,
calsum ( int x, int y, int z )
This method is called ANSI method and is more commonly
used these days.
Return statement
The return statement serves two purposes:
(1) On executing the return statement it immediately
transfers the control back to the calling program.
(2) It returns the value present in the parentheses after
return, to th3e 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.
The following program illustrates these facts.
fun( )
{
char ch ;
printf ( "\nEnter any alphabet " ) ;
scanf ( "%c", &ch ) ;
if ( ch >= 65 && ch <= 90 )
return ( ch ) ;
else
return ( ch + 32 ) ;
}
In this function different return statements will be executed
depending on whether ch is capital or not.
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. For example,
sum = calsum ( a, b, c ) ;
All the following are valid return statements.
return ( a ) ;
return ( 23 ) ;
return ( 12.34 ) ;
return ;
Scope Rule of Functions
by default the scope of a variable is local to the
function in which it is defined.
Arrays
Array is a collection of same type elements under the same variable identifier referenced by index number. Arrays are widely used within programming for different purposes such as sorting, searching and etc. Arrays allow you to store a group of data of a single type. Arrays are efficient and useful for performing operations . You can use them to store a set of high scores in a video game, a 2 dimensional map layout, or store the coordinates of a multi-dimensional matrix for linear algebra calculations.
Arrays are of two types single dimension array and multi-dimension array. Each of these array type can be of either static array or dynamic array. Static arrays have their sizes declared from the start and the size cannot be changed after declaration. Dynamic arrays that allow you to dynamically change their size at runtime, but they require more advanced techniques such as pointers and memory allocation.
It helps to visualize an array as a spreadsheet. A single dimension array is represented be a single column, whereas a multiple dimensional array would span out n columns by n rows.
single dimensional array
Arrays can be declared using any of the data types available in C. Array size must be declared using constant value before initialization. A single dimensional array will be useful for simple grouping of data that is relatively small in size
datatype array_name
[size_of_array
]; .
example are
int x[4];
float z[5];
char c[6];
Note: In C language the end of string is marked by the null character '\0'. Hence to store a group of 3 possible string data. the array as char ch[4]; This applies for char type array.
ch[0]=s;
ch[1]=t;
ch[2]=d;
ch[3]='\0';
Array can be initialized in two ways, initializing on declaration or initialized by assignment.
initializing on declaration
If you know the values you want in the array at declaration time, you can initialize an array as follows:
datatype array_name[size]={element1,element2,....,elementN};
initialized by assignment
ch[0]=s;
ch[1]=t;
ch[2]=d;
ch[3]='\0';
Multidimensional arrays
Arrays can have more than one dimension. Two dimensional arrays are widely used for tables, neural networks and etc. You can have as many dimensions as you would like but you have to consider the complexity of the code as you add new dimension. Multidimensional arrays allow you to store data in a spreadsheet or matrix like format.
To declare a multidimensional array:
datatype array_name
[size_of_first_dimension
][size_of_second_dimension
] ...
example
int i[3][3];
To access elements in a multidimensional array, all you have to do is provide a combination of index values for each dimension to reach the desired element, just like a bunch of cells in a spreadsheet or coordinates in a n dimensional matrix or graph.
array_name
[index1]
[index2]
...
[
indexM]
;
Setting values in a multidimensional array is just as simple as in a basic array, you need to add another index per dimension.
array_name
[index1]
[index2]
...
[
indexM]
= value;
example
i[0][1]=43;
An Introduction to Pointers
A Pointer is a variable that holds memory address
.this address is the location of another object.
Pointer Operators:-
there are two special operator * and &.
The
unary or
monadic operator
& gives the ``address of a variable''.
The
indirection or dereference operator
* gives the ``contents of an
object
pointed to by a pointer''.
Declaration
Datatype *variable_name;
example
int *i,**j
here i is pointer to integer.j is pointer to pointer to integer.j is double pointer.
float *i;
here i is pointer to float;
consider statement
int *ptr,*p,a=56;
as you see in figure the value of a is stored at memory address 5000.
to access its address value.
ptr=&a;
ptr hold the memory address of a.
printf("%d",ptr);
it will print 5000
printf("%d",*ptr);
it will print 56
pointer can be assign to another pointer
p=ptr;
pointer arithmetic
We can basically add and subtract pointer variables.
If p1 and p2 are pointers to same data type then
p1- p2, p1+p2 , p1++ , p2-- , --p1 , p1+3 (multiplication, division not allowed)
p1<=p2, p1==p2 etc (and other relational operations)
assume integer are two bytes long.
ptr++;
it wll point to next integer.
similarly
ptr--;
it wll point to previos integer.
ptr=ptr+5;
it will point to 5th element of ptr.
to assign annother value to a structure through ptr
we use arrow operator.(<-)
ptr->a=57;
printf("%d",*ptr);
it will print 57
Structure
This program demonstrates two fundamental aspects of structures:
(a) declaration of a structure
(b) accessing of structure elements
The general form of a structure declaration statement is
given below:
struct <structure name>
{
structure element 1 ;
structure element 2 ;
structure element 3 ;
......
......
} ;
Once the new structure data type has been defined one or more
variables can be declared to be of that type. For example the
struct book
{
char name ;
float price ;
int pages ;
} ;
struct book b1, b2, *b3 ;
struct book
{
char name ;
float price ;
int pages ;
} b1, b2, *b3 ;
or even...
struct
{
char name ;
float price ;
int pages ;
} b1, b2, *b3 ;
struct book b1 = { "x", 13 } ;
struct book b2 = { "x", 31 } ;
Accessing Structure Elements
They use a dot (.) operator. So to refer to pages
of the structure defined in our sample program
we have to use,
b1.pages
b3=&b1;
b3->name="xx";
b3 a pointer to a structure
C provides an operator ->, called an arrow operator
to refer to the structure elements.
printf ( "\n%s ", b3->name) ;
WAP TO FIND LARGEST AND SECOND LARGEST AMONG N NUMBER.
#include<stdio.h>
#define SIZE 100
int main(void)
{
int a[SIZE];
int i,j,n;
printf("\nHOW MANY ELEMENTS TO BE ENTERED IN AN ARRAY : \n");
scanf("%d", &n);
printf("\nENTER THE ELEMENTS IN AN ARRAY : \n");
for(i = 0; i < n; i++)
{
scanf("\n%d",&a[i]);
}
printf("\nTHE GIVEN ARRAY IS : ");
for(i = 0; i < n; i++)
{
display(a[i]);
}
large(a, n);
}
display(int f)
{
printf("\n\n%d", f);
}
large(int w[], int x)
{
int i,j;
for(i = 0 ; i < x ; i++)
{
if(w[i] < w[i+1])
{
j = i+1;
}
}
printf("\n\nTHE LARGEST VALUE IN ARRAY IS\n%s%d", " ", w[j]);
printf("\n\nTHE SECOND LARGEST VALUE IN ARRAY IS\n%s%d", " ", w[j]);
}
