Decision Making Statements, Arrays, Strings

ECE & EEE | I YEAR | II SEMESTER B1360 | COMPUTER PROGRAMMING | UNIT 3
1 |Prepared By : Mr. PRABU.U/AP |Dept. of Computer Science and Engineering | SKCET |
UNIT III
Decision making statements - Branching and Looping - Arrays - Multidimensional
Arrays - Functions - Recursion - Passing Array to Functions.
Storage classes - Strings - String library functions
2.1 DECISION MAKING STATEMENTS
Decision making structures require that the programmer specify one or more
conditions to be evaluated or tested by the program, along with a statement or
statements to be executed if the condition is determined to be true, and optionally,
other statements to be executed if the condition is determined to be false.
STATEMENT DESCRIPTION
if statement
An if statement consists of a Boolean expression
followed by one or more statements.
if...else statement
An if statement can be followed by an optional else
statement, which executes when the Boolean expression
is false.
nested if statements
You can use one if or else if statement inside another if
or else if statement(s).
switch statement
A switch statement allows a variable to be tested for
equality against a list of values.
nested switch statements
You can use one swicth statement inside another switch
statement(s).
 C programming language assumes any non-zero and non-null values as true
and if it is either zero or null then it is assumed as false value.
 C programming language provides following types of decision making
statements. Click the following links to check their detail.

1. Simple IF Statement
An if statement consists of a Boolean expression followed by one or more
statements.
Syntax
The syntax of an if statement in C programming language is:
if(boolean_expression)
{
/* statement(s) will execute if the boolean expression is true */
}
 If the boolean expression evaluates to true then the block of code inside the if
statement will be executed.
 If boolean expression evaluates to false then the first set of code after the end of
the if statement(after the closing curly brace) will be executed.
Example:
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 10;
/* check the boolean condition using if statement */
if( a < 20 )
{
/* if condition is true then print the following */
printf("a is less than 20n" );
}
printf("value of a is : %dn", a);
return 0;
}
When the above code is compiled and executed, it produces following result:
a is less than 20
value of a is : 10

2. IF ELSE Statement
An if statement can be followed by an optional else statement, which executes
when the boolean expression is false.
Syntax
The syntax of an if...else statement in C programming language is:
if(boolean_expression)
{
/* statement(s) will execute if the boolean expression is true */
}
else
{
/* statement(s) will execute if the boolean expression is false */
}
 If the boolean expression evaluates to true then the if block of code will be
executed otherwise else block of code will be executed.
Example:
#include <stdio.h>
int main ()
{
int a = 100;
/* check the boolean condition */
if( a < 20 )
{
printf("a is less than 20n" );
}
else
{
/* if condition is false then print the following */
printf("a is not less than 20n" );
}

printf("value of a is : %dn", a);
return 0;
}
a is not less than 20
value of a is : 100
3. Nested IF Statement
An if statement can be followed by an optional else if...else statement, which is
very useful to test various conditions using single if...else if statement.
When using if , else if , else statements there are few points to keep in mind.
 An if can have zero or one else's and it must come after any else if's.
 An if can have zero to many else if's and they must come before the else.
 Once an else if succeeds, none of the remaining else if's or else's will be tested.
Syntax:
The syntax of an if...else if...else statement in C programming language is:
if(boolean_expression 1)
{
/* Executes when the boolean expression 1 is true */
}
else if( boolean_expression 2)
{
}
else if( boolean_expression 3)
{
}
else
{
/* executes when the none of the above condition is true */
}
Example:
#include <stdio.h>
int main ()
{
int a = 100;
/* check the boolean condition */
if( a == 10 )
{
printf("Value of a is 10n" );
}

else if( a == 20 )
{
/* if else if condition is true */
}
else if( a == 30 )
{
/* if else if condition is true */
}
else
{
/* if none of the conditions is true */
printf("None of the values is matchingn" );
}
printf("Exact value of a is: %dn", a );
return 0;
}
None of the values is matching
Exact value of a is: 100
4. Switch Statements
A switch statement allows a variable to be tested for equality against a list of
values. Each value is called a case, and the variable being switched on is checked for
each switch case.
Syntax:
The syntax for a switch statement in C programming language is as follows:
switch(expression)
{
case constant-expression :
statement(s);
break; /* optional */
case constant-expression :
statement(s);
break; /* optional */
/* you can have any number of case statements */
default : /* Optional */
statement(s);
}
The following rules apply to a switch statement:
 The expression used in a switch statement must have an integral or
enumerated type, or be of a class type in which the class has a single conversion
function to an integral or enumerated type.

 You can have any number of case statements within a switch. Each case is
followed by the value to be compared to and a colon.
 The constant-expression for a case must be the same data type as the variable
in the switch, and it must be a constant or a literal.
 When the variable being switched on is equal to a case, the statements following
that case will execute until a break statement is reached.
 When a break statement is reached, the switch terminates, and the flow of
control jumps to the next line following the switch statement.
 Not every case needs to contain a break. If no break appears, the flow of control
will fall through to subsequent cases until a break is reached.
 A switch statement can have an optional default case, which must appear at the
end of the switch. The default case can be used for performing a task when none
of the cases is true. No break is needed in the default case.
Example:
#include <stdio.h>
int main ()
{
char grade = 'B';
switch(grade)
{
case 'A' :
printf("Excellent!n" );
break;
case 'B' :
case 'C' :
printf("Well donen" );
break;

case 'D' :
printf("You passedn" );
break;
case 'F' :
printf("Better try againn" );
break;
default :
printf("Invalid graden" );
}
printf("Your grade is %cn", grade );
return 0;
}
Well done
Your grade is B
2.2 BRANCHING AND LOOPING
 There may be a situation when you need to execute a block of code several
number of times.
 In general statements are executed sequentially: The first statement in a function
is executed first, followed by the second, and so on.
 Programming languages provide various control structures that allow for more
complicated execution paths.
C programming language provides following types of loop to handle looping
requirements.
LOOP TYPE DESCRIPTION
while loop
Repeats a statement or group of statements until a given
condition is true. It tests the condition before executing the
loop body.
for loop
Execute a sequence of statements multiple times and
abbreviates the code that manages the loop variable.
do...while loop
Like a while statement, except that it tests the condition at
the end of the loop body
nested loops
You can use one or more loop inside any another while, for
or do..while loop.
Loop Control Statements
 Loop control statements change execution from its normal sequence. When
execution leaves a scope, all automatic objects that were created in that scope
are destroyed.
 C supports the following control statements. Click the following links to check
their detail.

CONTROL STATEMENT DESCRIPTION
break statement
Terminates the loop or switch statement and transfers
execution to the statement immediately following the loop or
switch.
continue statement
Causes the loop to skip the remainder of its body and
immediately retest its condition prior to reiterating.
goto statement
Transfers control to the labelled statement. Though it is not
advised to use goto statement in your program.
1. The Infinite Loop
A loop becomes infinite loop if a condition never becomes false. The for loop is
traditionally used for this purpose. Since none of the three expressions that form the for
loop are required, you can make an endless loop by leaving the conditional expression
empty.
#include <stdio.h>
int main ()
{
for( ; ; )
{
printf("This loop will run forever.n");
}
return 0;
}
When the conditional expression is absent, it is assumed to be true. You may have an
initialization and increment expression, but C programmers more commonly use the
for(;;) construct to signify an infinite loop.
NOTE: You can terminate an infinite loop by pressing Ctrl + C keys.
2. While loop
A while loop statement in C programming language repeatedly executes a target
statement as long as a given condition is true.
Syntax:
The syntax of a while loop in C programming language is:
while(condition)
{
statement(s);
}
Here statement(s) may be a single statement or a block of statements. The
condition may be any expression, and true is any nonzero value. The loop iterates while
the condition is true.
When the condition becomes false, program control passes to the line
immediately following the loop.

Here key point of the while loop is that the loop might not ever run. When the
condition is tested and the result is false, the loop body will be skipped and the first
statement after the while loop will be executed.
Example:
#include <stdio.h>
int main ()
{
int a = 10;
/* while loop execution */
while( a < 20 )
{
printf("value of a: %dn", a);
a++;
}
return 0;
}
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19

3. do..while loop
Unlike for and while loops, which test the loop condition at the top of the loop,
the do...while loop in C programming language checks its condition at the bottom of the
loop.
A do...while loop is similar to a while loop, except that a do...while loop is
guaranteed to execute at least one time.
Syntax
The syntax of a do...while loop in C programming language is:
do
{
statement(s);
}while( condition );
Notice that the conditional expression appears at the end of the loop, so the
statement(s) in the loop execute once before the condition is tested.
If the condition is true, the flow of control jumps back up to do, and the
statement(s) in the loop execute again. This process repeats until the given condition
becomes false.
Example:
#include <stdio.h>
int main ()
{
int a = 10;
/* do loop execution */
do
{
a = a + 1;
}while( a < 20 );
return 0;
}

value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19
4. For LOOP
A for loop is a repetition control structure that allows you to efficiently write a
loop that needs to execute a specific number of times.
Syntax:
The syntax of a for loop in C programming language is:
for ( init; condition; increment )
{
statement(s);
}
Here is the flow of control in a for loop:
 The init step is executed first, and only once. This step allows you to declare and
initialize any loop control variables. You are not required to put a statement
here, as long as a semicolon appears.
 Next, the condition is evaluated. If it is true, the body of the loop is executed. If it
is false, the body of the loop does not execute and flow of control jumps to the
next statement just after the for loop.
 After the body of the for loop executes, the flow of control jumps back up to the
increment statement. This statement allows you to update any loop control
variables. This statement can be left blank, as long as a semicolon appears after
the condition.
 The condition is now evaluated again. If it is true, the loop executes and the
process repeats itself (body of loop, then increment step, and then again
condition). After the condition becomes false, the for loop terminates.
Example
#include <stdio.h>
int main ()
{
/* for loop execution */
for( int a = 10; a < 20; a = a + 1 )
{
}
return 0;
}

value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
value of a: 16
value of a: 17
value of a: 18
value of a: 19
5. Nested Loops
C programming language allows to use one loop inside another loop. Following
section shows few examples to illustrate the concept.
Syntax
The syntax for a nested for loop statement in C is as follows:
{
{
statement(s);
}
statement(s);
}

The syntax for a nested while loop statement in C programming language is as
follows:
while(condition)
{
while(condition)
{
statement(s);
}
statement(s);
}
The syntax for a nested do...while loop statement in C programming language is
as follows:
do
{
statement(s);
do
{
statement(s);
A final note on loop nesting is that you can put any type of loop inside of any
other type of loop. For example a for loop can be inside a while loop or vice versa.
Example
The following program uses a nested for loop to find the prime numbers from 2
to 100:
#include <stdio.h>
int main ()
{
int i, j;
for(i=2; i<100; i++) {
for(j=2; j <= (i/j); j++)
if(!(i%j)) break; // if factor found, not prime
if(j > (i/j)) printf("%d is primen", i);
}
return 0;
}
2 is prime
3 is prime
5 is prime
7 is prime
11 is prime
13 is prime

17 is prime
19 is prime
23 is prime
29 is prime
31 is prime
37 is prime
41 is prime
43 is prime
47 is prime
53 is prime
59 is prime
61 is prime
67 is prime
71 is prime
73 is prime
79 is prime
83 is prime
89 is prime
97 is prime
6. Break Statement
The break statement in C programming language has following two usage:
 When the break statement is encountered inside a loop, the loop is immediately
terminated and program control resumes at the next statement following the
loop.
 It can be used to terminate a case in the switch statement
 If you are using nested loops ( ie. one loop inside another loop), the break
statement will stop the execution of the innermost loop and start executing the
next line of code after the block.
Syntax
The syntax for a break statement in C is as follows:
break;

Example:
#include <stdio.h>
int main ()
{
int a = 10;
/* while loop execution */
while( a < 20 )
{
a++;
if( a > 15)
{
/* terminate the loop using break statement */
break;
}
}
return 0;
}
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
7. Continue Statement
The continue statement in C programming language works somewhat like the
break statement. Instead of forcing termination, however, continue forces the next
iteration of the loop to take place, skipping any code in between.
For the for loop, continue statement causes the conditional test and increment
portions of the loop to execute. For the while and do...while loops, continue statement
causes the program control passes to the conditional tests.
Syntax:
The syntax for a continue statement in C is as follows:
continue;
Example:
#include <stdio.h>
int main ()
{
int a = 10;

do
{
if( a == 15)
{
/* skip the iteration */
a = a + 1;
continue;
}
a++;
}while( a < 20 );
return 0;
}
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 16
value of a: 17
value of a: 18
value of a: 19
8.GOTO
A goto statement in C programming language provides an unconditional jump
from the goto to a labeled statement in the same function.
NOTE: Use of goto statement is highly discouraged in any programming language
because it makes difficult to trace the control flow of a program, making the program
hard to understand and hard to modify. Any program that uses a goto can be rewritten
so that it doesn't need the goto.

Syntax:
The syntax for a goto statement in C is as follows:
goto label;
..
.
label: statement;
Here label can be any plain text except C keyword and it can be set anywhere in
the C program above or below to goto statement.
Example:
#include <stdio.h>
int main ()
{
int a = 10;
LOOP:do
{
if( a == 15)
{
/* skip the iteration */
a = a + 1;
goto LOOP;
}
a++;
}while( a < 20 );
return 0;
}
value of a: 10
value of a: 11
value of a: 12
value of a: 13

value of a: 14
value of a: 16
value of a: 17
value of a: 18
value of a: 19
2.3 ARRAYS
1. Defining And Processing Arrays
Many applications require the processing of multiple data items that have
common characteristics. In such a situation it is convenient to place such data item in
an Array
An array is a collection of similar data items that are stored under a common
name. A value in an array is identified by index or subscript enclosed in square brackets
with array name.
The individual data items can be integers, floating point numbers, and characters
and so on, but they must be the same type and same storage class.
Each array element is referred by specifying the array name with subscripts
each subscripts enclosed in square brackets and each subscript must be a non-negative
integer.
Thus ‘n’ elements array ‘A’ and the elements are
A[0],A[1],A[2]…..A[N-1]
The value of each subscript can be expressed as an integer constant or an integer
variable or an integer expression.
The arrays can be used to represent not only simple list of value but also task of
data items in two and three or more dimensions.
Arrays can be classified into
 One-Dimensional arrays
 Two-Dimensional arrays
 Multi-Dimensional arrays
i) Array Declaration
Arrays are declared in the same manner as an ordinary variables except that
each array name must have the size of the array i.e., number of elements accommodate
in that array. Like variables, the array must be declared before they are used.
Syntax :
data_type array_variable [Size or Subscript of the array];
data type – Specifies the type of the data that will be contained in the array
array_variable- Specifies the name of the array
Size or Subscript – Specifies the maximum number of elements that the array
can hold
The subscript of an array can be integer constant, integer variable or an
expression that yields an integer value
Example: int a[5];
Where, ‘a’ is the name of the array with 5 subscripts of integer data types and
the computer reserves five storage location as shown below.

a
a[0]
a[1]
a[2]
a[3]
a[4]
ii) Processing an Array
The entire array cannot be accessed with single operation. So, the array elements
must be accessed on an element-by element basis.
This can be usually done with the help of the loop, when each pass of the loop is
used to access an array element, thus the number of passes through the loop will
therefore equal the number of array elements to be processed.
2. Array Initialisation
The values can be initialized to an array, when they are declared like ordinary
variable, otherwise they hold garbage values.
The array can be initialized in the following two ways:
i) At compile time
ii) At run time
i) At Compile Time
Syntax:
data_type array name [size]={List of values};
Where,
The list of values must be separated by commas.
Example:
int marks[3]={70,50,86};
This statement declares the variable marks as an array of 3 elements and will be
assigned to values specified in list as shown below
marks[0]
marks[1]
marks[2]
//Program to read marks using array initialization
#include<stdio.h>
void main()
{
int studmark[5]={99,97,87,89,92};int i;
printf(“mark of the student is:n”);
for(i=0;i<=4;++i)
{
printf(“%dt”,studmark[i]);
}
getch();
}
70
50
86

ii) At Run time
The array can be explicitly initialized at run time
Example :
int n[2];
scanf("%d%d",&n[0],&n[1]);
Like, the array can also be initialized by reading data items from the input
//Input n numbers and display n numbers
#include<stdio.h>
void main()
{
int a[100];
int i,n;
clrscr();
printf(“number of elements in arrayn”);
scanf(“%d”,&n);
printf(“enter the elementsn”);
for(i=0;i<n-1;++i)
{
scanf(“%d”,&a[i])
}
printf(“elements in arrayn”);
for(i=0;i<=n-1;++i)
{
printf(“%dt”,a[i]);
}
getch();
}
3. One-Dimensional Array
The collection of data items can be stored under a one variable name using only
one subscript, such a variable is the one-dimensional array.
//Add ten numbers and find sum and average
#include<stdio.h>
void main()
{
int i,num[10],sum=0; float avg=0.0;
printf(“enter ten numbers:n”);
for(i=0;i<10;i++)
{
scanf(“%”,&num[i]);
sum+=num[i];
}
avg=(float)sum/10.0;
printf(“n sum of 10 number is:%7.2d”,sum);
printf(“n average of 10 number is :%5.3f”,avg);
getch();
}

4. Two-Dimensional Array
Two dimensional arrays are used in situation where a table of values need to be
stored in an array.
These can be defined in the same fashion as in one dimensional arrays, except a
separate pair of square brackets are required for each subscript.
Two pairs of square brackets required for to dimensional array and three pairs
required for three dimensional arrays and so on.
Syntax: data_type array_name[row size] [column size];
data_type - specifies the type of the data that will be contained in the array.
array_name - specifies the name of the array
[row size] specifies the size of the row
[column size] specifies the size of the column
Example: int a[3][3];
Two dimensional arrays are stored in a row-column matrix, where the left index
indicates the row the right indicates the column.
Where 'a' is the array name and it reserves 3 row and 3 columns of memory as
shown below
i)Rules for Declaring Two-Dimensional Array
 For matrix addition and subtraction
 For matrix multiplication, first matrix column and second matrix must be equal.
/******* MATRIX ADDITION ****/
#include<stdio.h>
#include<conio.h>
void main()
{
int i,j,m,n;
int a[5][5],b[5][5],c[5][5];
clrscr();
printf("nttt MATRIX ADDITION nn");
printf("n Enter the Order of Matrix: n");
scanf("%d%d",&m,&n);
printf("nEnter the Elements of 1st Matris:n");
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
scanf("%d",&a[i][j]);
}
printf("n");
}
printf("n Enter the Elements of 2nd Matrix: n");
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)

{
scanf("%d",&b[i][j]);
}
printf("n");
}
printf("n The Resultant Matrix is: n");
for(i=0;i<m;i++)
{
for(j=0;j<n;j++)
{
c[i][j]=a[i][j]+b[i][j];
printf("%dt",&c[i][j]);
}
printf("nn");
}
getch();
}
ii) Initializing an Two-Dimensional Array.
A Two-Dimensional Array can be also initialized. For that the array values are
specified within a Compound statement. (i.e.,) { and }.
General form :-
Storage-class data-type array-name[r][c] = { value1, value2, .. .. .. , value n};
Here storage class may be static or extern by default. Storage-class is optional.
 Data-type refers to a valid C data type.
 Array-name refers to a valid array name.
 Here r stands for number of rows and c stands for number of columns.
 Each values in an array are separated by commas and terminated by semicolon.
#include<stdio.h>
void main()
{
int i,j;
float a[4][2]={{12.3,34,5},{23.4,45.6},{34.5,56.7},{45.6,67.8}};
printf(“Element value Address”);
for(i=0;i<4;i++)
{
for(j=0;j<2;j++)
{
printf(“n a[%d] [%d] %0.2f %p”,i,j,a[i][j],&a[i][j]);
}
}
getch();
}

5. Multi-Dimensional Array
Multi-dimensional Array consists of (or) requires more than two square brackets
and it may contain any number of values specified within square brackets. It may be
three, four, five, six and so on.
A Multi dimensional Array in general takes the following form.
General form :-
Storage-class data-type array-name[s1][s2]……………[sn];
Here storage class may be static or extern by default. Here Storage-class is optional.
Data-type refers to a valid C data type. Array-name refers to a valid array name. s1,s2,s3,
……… are sub scripts.
SORTING AN ARRAY
Sorting is the process of Arranging the set of data items in an order. Sorting may
be carried out in Ascending or Descending order. Sorting helps to increase the efficiency
of a program.
//Sort number in ascending order
#include<stdio.h>
void main()
{
int i,j,k,num[5],temp;
clrscr();
printf(“Enter five numbers:n”);
for(i=0;i<5;i++)
{
scanf(“%d”,&num[i]);
}
printf(“n THE ORIGINAL LIST IS:n”);
for(i=0;i<5;i++)
printf(“%dt”,num[i]);
for(i=0;i<4;i++)
for(j=i+1;j<5;j++)
{
if num[i]>num[j]
{
temp=num[i];
num[i]=num[j];
num[j]=temp;
}
printf(“n the sorted numbers are:n”);
for(i=0;i<5;i++)
printf(“%dt”,num[i]);
getch();
}
Features of Arrays :
 An array is a derived data type. It is used to represent a collection of elements of
the same data type.

 The elements can be accessed with base address (index) and the subscripts
define the position of the element.
 In array the elements are stored in continuous memory location. The starting
memory location is represented by the array name and it is known as the base
address of the array.
 It is easier to refer the array elements by simply incrementing the value of the
subscript.
2.4 FUNCTIONS
Functions are self-contained blocks of programs that perform some specific,
well-defined task. It break large complicated computing tasks into smaller and simpler
ones.
It helps in maintenance and enhancement of programs. It also helps
programmers to build their own functions and tying them to the existing library.
1. Function Declaration / Prototype
Function declaration is also called as function prototype, since they provide
model or blueprint of the function.
Syntax:
return_type function_name(parameter list);
Example:
int cube(int);
2. Function Definition
It is the process of specifying and establishing the user defined function by
specifying all of its elements and characteristics.
A function that does not return any value, but only performs some operation, is
declared to be void.
Syntax:
return_type function_name(parameters declaration)
{
local variable declaration;
statements;
}
Example:
double area(double n, double d)
{
//function body
}
Functions
Pre-defined
Functions
User – defined
Functions

3. Function Call
Function Call invokes the function that is defined in the program. A function call
is an expression of the form:
function_name (argument-list);
Example:
addValue(index);
4. Return Statement
To return some values to calling function main(), return statement is required;
otherwise, it is optional. Format of a 'return' statement is:
return(expression);
The expression can be a constant, a variable, a user defined data structure, a
general expression or a function call.
If the datatype of the expression returned does not match the return type of the
function, it is converted to the return type of the function.
If there is no value in a return statement, the calling function will receive the
control, but no value. Such a type of function is known as a void function.
Example:
int factorial(int n)
{
int i, result;
if(n<0)
return -1;
if(n==0)
return 1;
for(i=1,result=1;i<=n;i++)
result*=i;
return result;
}
5. Function Parameters
Function parameters are the means of communication between the calling and
the called functions.
There is no limitation on the number of parameters passed to a function.
There are two types of parameters,
i) Actual parameters – These are the parameters transferred from the calling
program (main program) to the called program (function)
ii) Formal parameters- These are the parameters, transferred into the calling
function (main program) from the called program (function)
Example:
main()
{
……
fun1(a,b);
…………
…………
}

fun1(x,y)
{
……….
………
}
Where a,b are the Actual parameters
x,y are the Formal parameter
6. Function Arguments
If a function is to use arguments, it must declare variables that accept the values
of the arguments. These variables are called the formal parameters of the function.
The formal parameters behave like other local variables inside the function and
are created upon entry into the function and destroyed upon exit.
While calling a function, there are two ways that arguments can be passed to a
function:
Call Type Description
Call by value
This method copies the actual value of an argument into the
formal parameter of the function. In this case, changes made
to the parameter inside the function have no effect on the
argument.
Call by reference
This method copies the address of an argument into the
formal parameter. Inside the function, the address is used to
access the actual argument used in the call. This means that
changes made to the parameter affect the argument.
default, C uses call by value to pass arguments. In general, this means that code
within a function cannot alter the arguments used to call the function and above
mentioned example while calling max() function used the same method.
i) Call By Value
In the call by value method of passing arguments to a function copies the actual
value of an argument into the formal parameter of the function. In this case, changes
made to the parameter inside the function have no effect on the argument.
By default, C programming language uses call by value method to pass
arguments. In general, this means that code within a function cannot alter the
arguments used to call the function. Consider the function swap() definition as follows.
/* function definition to swap the values */
void swap(int x, int y)
{
int temp;
temp = x; /* save the value of x */
x = y; /* put y into x */
y = temp; /* put temp into y */
return;
}

Now let us call the function swap() by passing actual values as in the following example:
#include <stdio.h>
/* function declaration */
void swap(int x, int y);
int main ()
{
int a = 100;
int b = 200;
printf("Before swap, value of a : %dn", a );
printf("Before swap, value of b : %dn", b );
/* calling a function to swap the values */
swap(a, b);
printf("After swap, value of a : %dn", a );
printf("After swap, value of b : %dn", b );
return 0;
}
Let us put above code in a single C file, compile and execute it, it will produce following
result:
Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :100
After swap, value of b :200
Which shows that there is no change in the values though they had been changed inside
the function.
ii) Call By Reference
The call by reference method of passing arguments to a function copies the
address of an argument into the formal parameter. Inside the function, the address is
used to access the actual argument used in the call. This means that changes made to the
parameter affect the passed argument.
/* function definition to swap the values */
void swap(int *x, int *y)
{
int temp;
temp = *x; /* save the value at address x */
*x = *y; /* put y into x */
*y = temp; /* put temp into y */
return;
}

For now, let us call the function swap() by passing values by reference as in the
following example:
#include <stdio.h>
void swap(int *x, int *y);
int main ()
{
int a = 100;
int b = 200;
printf("Before swap, value of a : %dn", a );
printf("Before swap, value of b : %dn", b );
/* calling a function to swap the values.
* &a indicates pointer to a ie. address of variable a and
* &b indicates pointer to b ie. address of variable b.
*/
swap(&a, &b);
printf("After swap, value of a : %dn", a );
printf("After swap, value of b : %dn", b );
return 0;
}
Let us put above code in a single C file, compile and execute it, it will produce following
result:
Before swap, value of a :100
Before swap, value of b :200
After swap, value of a :200
After swap, value of b :100
Which shows that there is no change in the values though they had been changed inside
the function.
7. Scope of Variables
 The part of the program within which variable/constant can be accessed is called
as its scope.
 By default, the scope of a variable is local to the function in which it is defined.
 Local variables can only be accessed in the function in which they are defined.
 A variable defined outside any function is called as External Variable.
 Scope of an external variable will be the whole program, and hence such
variables are referred to as Global variables.

2.5 RECURSION
Recursion is the process of calling the same function itself again and again until
some condition is satisfied. This process is used for repetitive computation in which
each action is satisfied in terms of a previous result.
Example:
#include <stdio.h>
int factorial(unsigned int i)
{
if(i <= 1)
{
return 1;
}
return i * factorial(i - 1);
}
int main()
{
int i = 15;
printf("Factorial of %d is %dn", i, factorial(i));
return 0;
}
When the above code is compiled and executed, it produces the following result:
Factorial of 15 is 2004310016
2.6 PASSING ARRAYS TO FUNCTIONS
If you want to pass a single-dimension array as an argument in a function, you
would have to declare function formal parameter in one of following three ways and all
three declaration methods produce similar results because each tells the compiler that
an integer pointer is going to be received. Similar way you can pass multi-dimensional
array as formal parameters.
Way-1
Formal parameters as a pointer as follows. You will study what is pointer in next
chapter.
void myFunction(int *param)
{
.
.
.
}
Way-2
Formal parameters as a sized array as follows:
void myFunction(int param[10])
{
.
.
.
}

Way-3
Formal parameters as an unsized array as follows:
void myFunction(int param[])
{
.
.
.
}
Example
Now consider the following function which will take an array as an argument
along with another argument and based on the passed arguments, it will return average
of the numbers passed through the array as follows:
double getAverage(int arr[], int size)
{
int i;
double avg;
double sum;
for (i = 0; i < size; ++i)
{
sum += arr[i];
}
avg = sum / size;
return avg;
}
Now let us call the above function as follows:
#include <stdio.h>
double getAverage(int arr[], int size);
int main ()
{
/* an int array with 5 elements */
int balance[5] = {1000, 2, 3, 17, 50};
double avg;
/* pass pointer to the array as an argument */
avg = getAverage( balance, 5 ) ;
/* output the returned value */
printf( "Average value is: %f ", avg );
return 0;
}
When the above code is compiled together and executed, it produces following result:
Average value is: 214.400000
As you can see, the length of the array doesn't matter as far as the function is concerned
because C performs no bounds checking for the formal parameters.

2.7 STORAGE CLASSES
 All variables have a datatype, they also have a 'Storage Class'.
 The storage class determines the lifetime of the storage associated with the
variable.
 If we don't specify the storage class of a variable in its declaration, the compiler
will assume a storage class dependent on the context in which variable is used.
A variable's storage class gives the following information
 Where the variable would be stored.
 What will be the default initial value.
 What is the scope of the variable.
 What is the life of the variable that is, how long would the variable exist.
Following four types of storage classes are provided in C:
 Automatic Storage Class
 Static Storage Class
 External Storage Class
 Register Storage Class
i) Automatic Variables
 Variables declared inside a block and local to block in which declared are said to be
Automatic variables. These variables can be accessed by block in which they are
declared. Another block cannot access its value.
 These variables created as new variable each time when function is called and
destroyed automatically when the function is exited.
 Compiler treat variable declared inside block as automatic variable by default.
Automatic variables are stored in memory. All variables declared inside the function
is auto by default.
 Auto variables are safe that is, they cannot be accessed directly by other functions.
Example
main()
{
int number;
-----------;
-----------;
}
We may also use the keyword auto to declare automatic variables explicitly.
main()
{
auto int number;
------------;
------------;
}

One important feature of automatic variables is that their value cannot be
changed accidentally by what happens in some other function in the program.
This assures that we may declare and use the same variable name in different
functions in the same program without causing any confusion to the compiler.
Example: Program to illustrate how automatic variables work
#include<stdio.h>
#include<conio.h>
void function1(void);
void function2(void);
main()
{
int m=2000;
function2();
printf(“%dn”,m);
}
void function1(void)
{
int m=10;
}
void function2(void)
{
int m=100;
function1();
}
Output:
10
100
2000
ii) Static Variables
 Static variable may be either an internal type or an external type depending on
the place of declaration.
 Static variables declared within individual block. They are local to the block in
which declared. It exists until the end of the program.
 Variable can be declared using the keyword static.
 Global and Local variable can be declared static. Static variables are initialized
only once when they are compiled in a program.
 When the program is closed the function associated with that program is also
excited and whenever it is visited again the same value exists.
 Internal static variable is declared inside a function.
 External static variable is declared outside a function. It is made available to all
functions in a C program.

Example: Program to illustrate how static variables work
#include<stdio.h>
#include<conio.h>
void start(void);
void main()
{
int i;
clrscr();
for(i=1;i<3;i++)
stat();
getch();
}
void stat(void)
{
static int x=0;
x=x+1;
printf(“x=%dn”,x);
}
OUTPUT
x=1
x=2
x=3
iii) External variables
 Variables that are active throughout the entire program are called as external
variables (global variables).
 External variables are declared outside the function body. This storage class is
created when variable is declared global.
 No memory is reserved for the variable. Variable retain the value throughout the
execution of a program.
 This storage class can be accessed by any function in same or different program
file and change its value.
For example , the external declaration of integer number and float length might appear
as
int number;
float length=6.2;
main()
{
-------;
}
function1()
{
-------;
}
function2()
{
---------;
---------;
}

Example: Program to illustrate how External variables work
#include<stdio.h>
#include<conio.h>
int fun1(void);
int fun2(void);
int fun3(void);
int x; /*GLOBAL*/
main()
{
x=10; /*GLOBAL */
printf(“x=%dn”, x);
printf(“x=%dn”, fun1());
}
fun1(void)
{
x=x+10; /*GLOBAL*/
}
int fun2(void)
{
int x ; /*LOCAL*/
x=1 ;
return(x) ;
}
fun3(void)
{
x=x+10; /* GLOBAL*/
}
OUTPUT:
x=10
x=20
x=1
x=30
External Declaration
In the above program, the main cannot access the variable y as it has been
declared after the main function. This problem can be solved by declaring the variable
with the storage class named as “extern”.
main()
{
extern int y; /*External declaration*/
--------;
}
func1() /*External declaration*/
{
extern int y;
}
int y; /*Definition*/

iv) Register Variables
 Register is a special storage area in a Central Processing Unit (CPU). There are 8
registers available inside a Computer.
 Register variable can be accessed only by block in which it is declared. It cannot
be accessed by any other function.
 Register variable declared using keyword register. Both Local variable and
formal parameter can be declared as a register.
 Register is used to increase the execution speed. Only integer or char variables
are declared as register in most of the compilers but ANSI C supports all the data
types.
Example: Program to illustrate how Register variables work
#include<stdio.h>
#include<conio.h>
void main()
{
register int x;
clrscr();
for(x=1;x<=10;x++)
printf(“%d”,x);
getch();
}

2.8 STRINGS
1.String Manipulation
In 'C' language the group of character, digits and symbols enclosed within
quotation marks are called as string otherwise string are array of characters. Null
character('/0') is used to mark the end of the string.
Example: char name[]={'S','T','R','I','N','G','/0'}
Each character is stored in one byte of memory and successive characters of the string
are stored in successive byte
2. Reading and Writing String
The '%s' control string can be used in scanf() statement to read a string from the
terminal and the same may be used to write string to the terminal in printf() statement.
Example: char name[10];
scanf("%s",name);
printf("%s",name);
** there is no address (&) operator used in scanf() statement
3. Character Array
Character Array is specified within single quotes and ended with semicolon. It is
used to define a single character for the array.
// Input 10 characters and print 10 characters
#include<stdio.h>
void main()
{
char character[10];
int cnt;
clrscr();
/*read character one by one*/
printf(“enter 10 charactern”);
for(cnt=0;cnt<10;cnt++)
character[cnt]=getchar();
/*display character one by one*/
printf(“nentered characters are :n”);
for(cnt=0;cnt<10;cnt++)
putchar(character[cnt]);
}
4. Strings Standard Function
The commonly used string manipulation functions are follows
1. The strlen() function
This function is used to count and return the number of character present in a
string
Syntax: var =strlen(string);
where, var - Is the integer variable, which accepts the length of the string
string - Is the string constant or string variable in which the length is going to be
found

Example: Program using strlen() function
#include<stdio.h>
#include<string.h>
main()
{
char name[100];
int length;
printf(“Enter the string”);
gets(name);
length=strlen(name);
printf(“nNumber of characters in the string is=%d”,length);
}
2. The strcpy() function
This function is used to copy the contents of one string to another and it almost
works like string assignment operator.
Syntax: strcpy(string1,string2);
string1 is the destination string
string2 is the source string
i.e., The contents of string2 is assigned to the contents of string1. where string2 may be
character array variable or string constant.
Example: Program using strcpy() function
#include<stdio.h>
#include<string.h>
main()
{
char source = “Welcome”;
char target[10];
strcpy(target,source);
printf(“n Source string is %s”,source);
printf(“n Target string is %s”,target);
}
3.The strcat() function
The strcat() function is used to concatenate or combine, two strings together and
forms a new concatenated string.
Syntax : strcat(string1,string2);
where, string1 and string2 are character type arrays or string constants. When
the above strcat function is executed, string2 is combined with string1 and it removes
the null character(/0) of string1 and places string2.

Example: Program using strcat() function
#include<stdio.h>
#include<string.h>
main()
{
char source[10]=”Ramesh”;
char target[10]=”Babu”;
strcat(source,target);
printf(“n Source string is %s”,source);
printf(n Target string is %s”,target);
}
OUTPUT
Source string is RameshBabu
Target string is Babu
4. The strcmp() function
This is a function which compares two strings to find out whether they are same
or different. The two strings are comparedcharacter by character until the end of one
of the string is reached. If the two strings are identical strcmp() returns a value zero. If
they are not equal, it returns the numeric difference between the first non-matching
characters
Syntax: strcmp(string1,string2);
string1 and string2 are character type arrays or string constants
Example: Program using strcmp() function
#include<stdio.h>
#include<string.h>
main()
{
char s1[20],s2[20];
int x;
printf(“Enter the strings”);
scanf(“%s%s”,s1,s2);
x=strcmp(s1,s2);
if(x!=0)
{
printf(“nStrings are not equaln”);
else
printf(“nStrings are equal”);
}
}
5. The strrev() function
The strrev function is used to reverse a string. This function takes only one
argument and return one argument. The general form of strrev() function is
Syntax: strrev(string);
string are characters type arrays ofr string constants

Example: Program using strrev() function
#include<stdio.h>
#include<string.h>
main()
{
char a[30];
printf(“Enter the string:”);
gets(a);
printf(“The string reversed is : %s”, strrev(a));
}
OUTPUT
Enter the string : array
The string reversed is : yarra
2.9 STRING LIBRARY FUNCTIONS
The header file related to string functions is <string.h>
FUNCTIONS MEANING
strcmp(s1,s2) Compares two strings. Return negative value if s1<s2. 0 if s1 and s2
are identical. Return positive value if s1>s2.
strcpy(s1,s2) Copies a string s2 to another string s1.
strcat(s1,s2) Combines the string s1 at the end of string s2.
strchr(s1,c) Finds first occurrence of a given character in a string. Compare
characters of string s1 with character starting from head of string s1.
strlen(s) Find length of a string s.
strlwr(s) Converts string s to lowercase
strrev(s) Reverse the string s.
strupr(s) Converts the string s to uppercase
strdup(s) Duplicate string s.
strncpy(s1,s2,n) Copies portion of string s2 to string s1 upto position n.
strncmp(s1,s2,n) Compares portion of string s2 to string s1 upto position n.
strrchr() Find last occurrence of a given character in a string.
strstr() Find first occurrence of a given string in another string.
strcmpi() Compares two strings without regard to case (“i” denotes that this
function ignores case ).

Decision Making Statements, Arrays, Strings

Recommended

More Related Content

What's hot (20)

Similar to Decision Making Statements, Arrays, Strings (20)

More from Prabu U (20)

Recently uploaded (20)

Decision Making Statements, Arrays, Strings