Unit 3
Unit 3
Unit 3
D ecision 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.
Following is the general form of a typical decision making structure found in most of the programming
languages:
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.
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.
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.
Flow Diagram
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 20\n" );
}
printf("value of a is : %d\n", a);
return 0;
}
When the above code is compiled and executed, it produces the following result:
if...else statement
An if statement can be followed by an optional else statement, which executes when theboolean
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.
C programming language assumes any non-zero and non-null values as true and if it iseither zero or null
then it is assumed as false value.
Flow Diagram
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 100;
return 0;
}
When the above code is compiled and executed, it produces the following result:
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)
{
/* Executes when the boolean expression 2 is true */
}
else if( boolean_expression 3)
{
/* Executes when the boolean expression 3 is true */
}
else
{
/* executes when the none of the above condition is true */
}
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 100;
return 0;
}
When the above code is compiled and executed, it produces the following result:
Nested if statements
It is always legal in C programming to nest if-else statements, which means you can useone if or else if
statement inside another if or else if statement(s).
Syntax
The syntax for a nested if statement is as follows:
if( boolean_expression 1)
{
/* Executes when the boolean expression 1 is true */
if(boolean_expression 2)
{
/* Executes when the boolean expression 2 is true */
}
}
You can nest else if...else in the similar way as you have nested if statement.
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
return 0;
}
When the above code is compiled and executed, it produces the following result:
switch statement
A switch statement allows a variable to be tested for equality against a list of values. Eachvalue 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 */
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
jumpsto 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.
Flow Diagram
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
char grade = 'B';
switch(grade)
{
case 'A' :
printf("Excellent!\n" );
break;
case 'B' :
case 'C' :
printf("Well done\n" );
break;
case 'D' :
printf("You passed\n" );
break;
case 'F' :
printf("Better try again\n" );
break;
default :
printf("Invalid grade\n" );
}
printf("Your grade is %c\n", grade );
return 0;
}
When the above code is compiled and executed, it produces the following result:
Well done
Your grade is B
Syntax
The syntax for a nested switch statement is as follows:
switch(ch1) {
case 'A':
printf("This A is part of outer switch" );
switch(ch2) {
case 'A':
printf("This A is part of inner switch" );
break;
case 'B': /* case code */
}
break;
case 'B': /* case code */
}
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
switch(a) {
case 100:
printf("This is part of outer switch\n", a );
switch(b) {
case 200:
printf("This is part of inner switch\n", a );
}
}
printf("Exact value of a is : %d\n", a );
printf("Exact value of b is : %d\n", b );
return 0;
}
When the above code is compiled and executed, it produces the following result:
The ? : Operator
We have covered conditional operator ? : in previous chapter which can be used toreplace if...else
statements. It has the following general form:
Where Exp1, Exp2, and Exp3 are expressions. Notice the use and placement of the colon.
The value of a ? expression is determined like this: Exp1 is evaluated. If it is true, then Exp2 is evaluated
and becomes the value of the entire ? expression. If Exp1 is false, then Exp3 is evaluated and its value becomes
the value of the expression.
C Loops
T here 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.
A loop statement allows us to execute a statement or group of statements multiple times and following is the
general form of a loop statement in most of the programminglanguages
C programming language provides the following types of loops to handle looping requirements.
while loop in C
A while loop statement in C programming language repeatedly executes a targetstatement 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.
Flow Diagram
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 ()
{
/* local variable definition */
int a = 10;
return 0;
}
When the above code is compiled and executed, it produces the following result:
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
for loop in C
A for loop is a repetition control structure that allows you to efficiently write a loop thatneeds to execute
a specific number of times.
Syntax
The syntax of a for loop in C programming language is:
1. 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 longas a
semicolon appears.
2. 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.
3. 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.
4. 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.
Flow Diagram
Example
#include <stdio.h>
int main ()
{
/* for loop execution */
for( int a = 10; a < 20; a = a + 1 )
{
printf("value of a: %d\n", a);
}
return 0;
}
When the above code is compiled and executed, it produces the following result:
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
do...while loop in C
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) inthe loop execute
again. This process repeats until the given condition becomes false.
Flow Diagram
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 10;
/* do loop execution */
do
{
printf("value of a: %d\n", a);
a = a + 1;
}while( a < 20 );
return 0;
}
When the above code is compiled and executed, it produces the following result:
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
nested loops in C
C programming language allows to use one loop inside another loop. Following sectionshows few
examples to illustrate the concept.
Syntax
The syntax for a nested for loop statement in C is as follows:
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 asfollows:
do
{
statement(s);
do
{
statement(s);
}while( condition );
}while( condition );
A final note on loop nesting is that you can put any type of loop inside of any other type ofloop. 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 ()
{
/* local variable definition */
int i, j;
return 0;
}
When the above code is compiled and executed, it produces the following result:
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
break statement in C
The break statement in C programming language has the following two usages:
1. 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.
2. It can be used to terminate a case in the switch statement (covered in the next chapter).
If you are using nested loops (i.e., 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;
Flow Diagram
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 10;
return 0;
}
When the above code is compiled and executed, it produces the following result:
value of a: 10
value of a: 11
value of a: 12
value of a: 13
value of a: 14
value of a: 15
continue statement in C
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;
Flow Diagram
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 10;
/* do loop execution */
do
{
if( a == 15)
{
/* skip the iteration */
a = a + 1;
continue;
}
printf("value of a: %d\n", a);
a++;
}while( a < 20 );
return 0;
}
When the above code is compiled and executed, it produces the following result:
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
goto statement in C
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 Cprogram above or below
to goto statement.
Flow Diagram
Example
#include <stdio.h>
int main ()
{
/* local variable definition */
int a = 10;
/* do loop execution */
LOOP:do
{
if( a == 15)
{
/* skip the iteration */
a = a + 1;
goto LOOP;
}
printf("value of a: %d\n", a);
a++;
}while( a < 20 );
return 0;
}
When the above code is compiled and executed, it produces the following result:
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
#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.
F unction is a group of statements that together perform a task. Every C program has at
least one function, which is main(), and all the most trivial programs can define additional functions.
You can divide up your code into separate functions. How you divide up your code among different functions
is up to you, but logically the division usually is so each functionperforms a specific task.
A function declaration tells the compiler about a function's name, return type, and parameters. A function
definition provides the actual body of the function.
The C standard library provides numerous built-in functions that your program can call. For example, function
strcat() to concatenate two strings, function memcpy() to copy one memory location to another location and
many more functions.
A function is known with various names like a method or a sub-routine or a procedure, etc.
Defining a Function
The general form of a function definition in C programming language is as follows:
Return Type: A function may return a value. The return_type is the data type of the
value the function returns. Some functions perform the desired operations without
returning a value. In this case, the return_type is the keyword void.
Function Name: This is the actual name of the function. The function name and the
parameter list together constitute the function signature.
Parameters: A parameter is like a placeholder. When a function is invoked, you pass a
value to the parameter. This value is referred to as actual parameter or argument. The
parameter list refers to the type, order, and number of the parameters of a function.
Parameters are optional; that is, a function may contain no parameters.
Function Body: The function body contains a collection of statements that define
whatthe function does.
Example
Following is the source code for a function called max(). This function takes two parametersnum1 and num2
and returns the maximum between the two:
return result;
}
Function Declarations
A function declaration tells the compiler about a function name and how to call thefunction. The actual body
of the function can be defined separately.
For the above defined function max(), following is the function declaration:
Parameter names are not important in function declaration only their type is required, sofollowing is also valid
declaration:
Function declaration is required when you define a function in one source file and you call that function in
another file. In such case you should declare the function at the top of the file calling the function.
Calling a Function
While creating a C function, you give a definition of what the function has to do. To use a function, you will
have to call that function to perform the defined task.
When a program calls a function, program control is transferred to the called function. A called function
performs defined task, and when its return statement is executed or when its function-ending closing brace
is reached, it returns program control back to the main program.
To call a function, you simply need to pass the required parameters along with function name, and if function
returns a value, then you can store returned value. For example:
#include <stdio.h>
/* function declaration */
int max(int num1, int num2);
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
int ret;
return 0;
}
return result;
}
I kept max() function along with main() function and compiled the source code. Whilerunning final
executable, it would produce the following result:
Function Arguments
If a function is to use arguments, it must declare variables that accept the values of thearguments. These
variables are called the formal parameters of the function.
The formal parameters behave like other local variables inside the function and are createdupon entry into
the function and destroyed upon exit.
While calling a function, there are two ways that arguments can be passed to a function:
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.
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 ()
{
/* local variable definition */
int a = 100;
int b = 200;
return 0;
}
Let us put above code in a single C file, compile and execute it, it will produce the followingresult:
Which shows that there is no change in the values though they had been changed insidethe function.
To pass the value by reference, argument pointers are passed to the functions just like any other value. So
accordingly you need to declare the function parameters as pointer types as in the following function swap(),
which exchanges the values of the two integer variables pointed to by its arguments.
return;
}
Let us call the function swap() by passing values by reference as in the following example:
#include <stdio.h>
/* function declaration */
void swap(int *x, int *y);
int main ()
{
/* local variable definition */
int a = 100;
int b = 200;
Let us put above code in a single C file, compile and execute it, it will produce the followingresult:
Which shows that there is no change in the values though they had been changed insidethe function.
C Scope Rules
A scope in any programming is a region of the program where a defined variable can
have its existence and beyond that variable cannot be accessed. There are three places where
variables can be declared in C programming language:
Let us explain what are local and global variables and formal parameters.
Local Variables
Variables that are declared inside a function or block are called local variables. They can be used only by
statements that are inside that function or block of code. Local variables are not known to functions outside
their own. Following is the example using local variables. Here all the variables a, b and c are local to main()
function.
#include <stdio.h>
int main ()
{
/* local variable declaration */
int a, b;
int c;
/* actual initialization */
a = 10;
b = 20;
c = a + b;
return 0;
}
Global Variables
Global variables are defined outside of a function, usually on top of the program. The global variables will
hold their value throughout the lifetime of your program and they can be accessed inside any of the functions
defined for the program.
A global variable can be accessed by any function. That is, a global variable is available for use throughout
your entire program after its declaration. Following is the example usingglobal and local variables:
#include <stdio.h>
int main ()
{
/* local variable declaration */
int a, b;
/* actual initialization */
a = 10;
b = 20;
g = a + b;
return 0;
}
A program can have same name for local and global variables but value of local variableinside a function will
take preference. Following is an example:
#include <stdio.h>
int main ()
{
/* local variable declaration */
int g = 10;
return 0;
}
When the above code is compiled and executed, it produces the following result:
value of g = 10
Formal Parameters
Function parameters, so called formal parameters, are treated as local variables within that function and
they will take preference over the global variables. Following is an example:
#include <stdio.h>
int main ()
{
/* local variable declaration in main function */
int a = 10;
int b = 20;
int c = 0;
return 0;
}
return a + b;
}
When the above code is compiled and executed, it produces the following result:
value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30
It is a good programming practice to initialize variables properly otherwise, your program may produce
unexpected results because uninitialized variables will take some garbage value already available at its memory
location.
C Recursion
A function that calls itself is known as a recursive function. And, this technique is known as recursion.
int main()
{
... .. ...
recurse();
... .. ...
}
Working of Recursion
The recursion continues until some condition is met to prevent it.
To prevent infinite recursion, if...else statement (or similar approach) can be used where one branch makes the recursive call,
and other doesn't.
int main() {
int number, result;
result = sum(number);
int sum(int n) {
if (n != 0)
// sum() function calls itself
return n + sum(n-1);
else
return n;
}
Output
Enter a positive integer:3
sum = 6
Initially, the sum() is called from the main() function with number passed as an argument.
Suppose, the value of n inside sum() is 3 initially. During the next function call, 2 is passed to the sum() function. This
process continues until n is equal to 0.
When n is equal to 0, the if condition fails and the else part is executed returning the sum of integers ultimately to
the main() function.