Bt0067 c programming and data structures 1

1
C Programming and Data Structures
BT0067 Part-2
By Milan K Antony

2
 Differentiate string type and character type constants.
Individual character constants are represented by single-
quotes, e.g. 'A', and have type int (in C++ char). The
difference is that "A" represents a pointer to the first
element of a null-terminated array, whereas 'A' directly
represents the code value (65 if ASCII is used). The same
backslash-escapes are supported as for strings, except that
(of course) " can validly be used as a character without being
escaped, whereas ' must now be escaped. A character constant
cannot be empty (i.e. '' is invalid syntax), although a string
may be (it still has the null terminating character). Multi-
character constants (e.g. 'xy') are valid, although rarely
useful — they let one store several characters in an integer
(e.g. 4 ASCII characters can fit in a 32-bit integer, 8 in a
64-bit one). Since the order in which the characters are
packed into one int is not specified, portable use of multi-
character constants is difficult.
In C, string literals (constants) are surrounded by double
quotes ("), e.g. "Hello world!" and are compiled to an array
of the specified char values with an additional null terminating
character (0-valued) code to mark the end of the
string.String literals may not contain embedded newlines; this
proscription somewhat simplifies parsing of the language. To

3
include a newline in a string, the backslash escape n may be
used, as below.
2. Write an algorithm to find the bus fare based on distance
traveled as per the following rates:
a. Rs.5.00 for first 2 kms.
b. Rs.2.50 for every additional 2 kms.
Draw a flowchart to find the fare.
3. Explain different iterative statements.

4
A C Program is made up of statements. Statement is a
part of your program that can be executed. In other words
every statement in your program alone or in combination
specifies an action to performed by your program. C provides
variety of statements to help you attain any function with
maximum flexibility and efficency. One of the reason for
popularity of C is because of the extreme power provided to
programmer in C due to it rich and diverse set of statements
define in C. For becoming a top notch programmer you must
have clear understanding of the C statments and the situations
where staments in C are applicable.
1. Types Of Statements
Staments in C are categorized into following types- 1.
Selection/Conditional Statement - They decide the flow of
statements on based on evaluation of results of conditons. if
- else and switch statements come under this category. 2.
Iteration Statements - These are used to run a particluar
block statments repeatedly or in other words form a loop.
for, while and do-while statements come under this category.
3. Jump Statements - The are used to make the flow of your
statments from one point to another. break, continue, goto
and return come under this category. 4. Label Statements -
These are used as targets/waypoints for jump and selection
statements. case (discussed with switch) and label (discussed
with goto) come under this category 5. Expression Statements

5
- Any valid expression makes an expression statement. 6. Block
Statement - A group of staments which are binded together
to form a logic are called block statemetns. Block statement
begins with a { and ends with a }. Below we discuss each types
of statements in detail with all thier variant forms.
Block Statements
2. if - else Statement if - else statement is a selection
statement. It selects one piece of code for execution among
two on basis of a outcome of a conditonal logic. The piece
of code being refer here can be a s tament, a block
statement or even a empty statement depending upon the
logic of your program.
Conditon here evaluates to true or false ie. zero or non-zero
in c respectively.It can be any valid data type which can be
interpreted by C compiler as 1 or 0. If the code evaluates to
be true the one assosiated with if is executed otherwise one
associated with else is executed. Hence the if - else statment
helps the programmer in controlling the flow of statements in
his program. The important thing to note is code of if and
else block are inversely related in logic ie. either code of if
block or code of else block will be executed never both.
Also in a professionally written code if the variable alone is
able to control the condtion using a comparison is considered
a bad style. For example say i an integer variable can attain
any value then this value can be directly interpreted as zero

6
or non-zero and is sufficient to control the loop. In this case
conditons like (i == 0) or (i != 0) are considered bad
programming style and should be avoided.
Here is a code showing the if - else statement in action –
One property of if -else statement is that they can be
nested. This means that if statement can be target of another
if statement.
C89 specifies that compiler must support 15 levels of nesting
and C -99 increase that number to 127 but in reality most
compilers allow a large number of nesting much much greater
than defined in C.
In a nested else statement is assosiate with nearest if
statement. This association can be change by used of code
block. Also you should use proper indenting in your program
to make sure you remove any visual ambiguity/
Another popular variant of if-else statement is if-else ladder
in this we create a series of generally one level deep. It has
a special property that when any one of the condition
statement is found to be true only statement associate with
the if having that condition true is executed and all other
statements in the ladder are by-passed. If none of the
conditions evaluate to be true then the final statement
associated with else is executed if present. Also it is
recommended to use standard identation pattern.

7
Another option to if-else statement is ternary operator ?
(Question Mark) discussed under Expressions.
3. switch Statement
switch is a selection statement provided by C. It has a buil in
multiple - branch structure and work similar to if else ladder
generally. The input value to to the switch statemetnt
construct is a int or char variable. Note that no float or any
other data is allowed. This input variable is compared against a
group of integer constant. All the statments in and after the
case in which thier is a match is executed until a break
statement is encountered or end of switch is reached. We are
also allowed to give a default case which will be executed if
no other statement match is found. Also use of standard
indenting is recommended.
4. for Statement
for statement is one of the iteration statement provided by
C. It is the most popular of all iteration statments because it
provides unmatched flexiblity and power to the program.
Loops generated by for statement is are also called entry
controlled or close ended because the condition for iteration

8
of loop is check at the starting of the loop and loop will not
execute even once if the conditon will to satisfy even once.
for statement declaration as shown above can be divided into
3 parts -
1. Intialization - In this we intialize the loop control value to
a starting value. Also C99 like C++ permits the declaration of
loop control variable whose scope is only the for block.
2. Condition - In this evaluate the condition for the iteration
of the loop and loop repeat only when this is true.
3. Increment - In this we determine how the value of loop
control value changes with each iteration of the loop. It can
be increment, decrement or any mathematical expression.
Also statement in above form can be a single statement, block
statement or a blank statement.
There are many variations or mutant forms of for loop which
can be created enhancing the general for loops flexibility and
power.
Multiple loop control variable - In this form more than 1 loop
control variable is used to control the execution of loop. The
multiple statements are combined together using comma
operator. The possible use is shown in the following source

9
code in which we generate numbers from 0 to 50 using two
loop control Missing Parts - In a for statement declaration
any or all of the three parts of the statement are optional
and can be replaced by blank statements. Its show in the code
be#include <stdio.h>
3.Infinite loop - In this a non - ending infinte loop is
formed by removing all three parts of the for statement. This
loop can only be stopped if a break statement is encountered
inside the body of the loop. Infinite loop find use in many
algorithms such as game programming engin#include <stdio.h>
 No Body Loop - In this variation the body of the loop
does not exist. It maybe used in special circumstances
such as in which body of loop is not needed. For example
the code below shows a loop which moves the input string
pointer to a character in the same string removing the
unwanted intial white spaces.
Many new variations can be obtained by combining variations
above. For loop is most widely use loop statement and its
should be clear now why it is so.
5. while Statement
while is an iteration statement available in C. It is used to
create loops. While produce entry controlled loops ie. loops in
which condition check is performed at starting.

10
Above condition is any valid expression which evaluates to zero
or non - zero and statement can be a single statement, block
statement or empty statement. Also if you want to run loop
forever you can write condition 1 and if you want it to never
run you can write condition 0. While like for can be made
without any bodies for specific purposes. Also unlike for the
increment has to been inside the statement block and
initalization outside the while statement block.
6. do - while Statment
do - while is also iteration statement provided by C. It is
similar to while but has many diffrent properties. It is an exit
controlled loop which means that condition for next loop
iteration is checked at bottom of the loop. This makes sure
that the do-while loop will run atleast once.Curly brackets are
not required if statment is blank or single but they are
recommended in every case to avoid confusion. Conditional as
usual is vaild expression statement which evaluates to zero or
non-zero. The loop will continue to run till the conditions
evaluates to non - zero. As in while increment part should be
contained inside loop and intialization should be outside loop.
One the most important use of do-while is menus where you
want menu to run atleast once and also until user chooses a
valid choice.
7. return Statement

11
return is a jump statement in c. It is used to return from
the executing function to the function which called this
executing function. If encounter in main the program exits
and return to the operating system or the source from which
it was called from.
Return statement also has a special property that it can return
a value with it to the calling function if the fuunction is
declared non - void. Void functions are the one which are
explicitly declared not to return a value and hence a return
statement with value when encountered in such a function leads
to an error by compiler. Also a function declared non-void
should always return a value of the respective type. Some
compiler allow a relaxation which could lead to severe
problems, they return garbage value if a return statement
containing the value is not found in the function. You should
always make sure such a situation never happens.
8. goto Statement
goto statement is a jump staments and is perhaps the most
controversial feature in C. Goto in unstructured language such
as basic was indispensable and the soul of the programming
lanugage but in a structured language they are critcized
beyond limit. The critics say that due to other jump
statements in c goto is not all required and more over it
destoys the structure of your program and make it
unreadable. But on other hand goto statement of C provides

12
some very powerfull programming options in very compicated
situation. This tutorial will take an neutral stand in such an
argument and neither recommend nor discourage use of goto.
Goto is used for jumping from one point to another point in
your function. You can not jump from one function to
another. Jump points or way points for goto are marked by
label statements. Label statement can be anywhere in the
function above or below the goto statement. Special situation
in which goto find use is deeply nested loops or if - else
ladders.
9. break Statement
break statment is a jump statment in C and is generally used
for breaking from a loop or breaking from a case as discussed
in switch stament. Break statement when encountered within a
loop immediately terminates the loop by passing condition check
and execution transfer to the first statment after the loop.
In case of switch it terminates the flow of control from one
case to another.Also one important thing to remember about
break is that it terminates only the innermost switch or loop
construct in case of nested switch and loop variations.
10. continue Statement
continue is a jump statement provided by C. It is analogus to
break statement. Unlike break which breaks the loop, continue
stament forces the next execution of loop bypassing any code

13
in between.For for staments it causes the conditional check
and increment of loop variable, for while and do-while it
passes the control to the conditon check jumping all the
statements in between. Continue plays an important role in
efficiently applying certain algorithms.
4. What is a macro? Explain with examples.
A macro is a fragment of code which has been given a
name. Whenever the name is used, it is replaced by the
contents of the macro. There are two kinds of macros. They
differ mostly in what they look like when they are used.
Object-like macros resemble data objects when used,
function-like macros resemble function calls. You may define
any valid identifier as a macro, even if it is a C keyword. The
preprocessor does not know anything about keywords. This can
be useful if you wish to hide a keyword such as const from an
older compiler that does not understand it. An object-like
macro is a simple identifier which will be replaced by a code
fragment. It is called object-like because it looks like a data
object in code that uses it. They are most commonly used to
give symbolic names to numeric constants. You create macros
with the `#define' directive. `#define' is followed by the name
of the macro and then the token sequence it should be an
abbreviation for, which is variously referred to as the macro's
body, expansion or replacement list. For example,
#define BUFFER_SIZE 1024

14
defines a macro named BUFFER_SIZE as an abbreviation for the
token 1024. If somewhere after this `#define' directive there
comes a C statement of the form
foo = (char *) malloc (BUFFER_SIZE);
then the C preprocessor will recognize and expand the macro
BUFFER_SIZE. The C compiler will see the same tokens as it
would if you had written
foo = (char *) malloc (1024);
You can also define macros whose use looks like a function
call. These are called function-like macros. To define a
function-like macro, you use the same `#define' directive, but
you put a pair of parentheses immediately after the macro
name. For example,
#define lang_init() c_init()
lang_init()
==> c_init()
A function-like macro is only expanded if its name appears
with a pair of parentheses after it. If you write just the
name, it is left alone. This can be useful when you have a
function and a macro of the same name, and you wish to use
the function sometimes.
5. What is a function? Explain with examples.

15
A function in C language is a block of code that
performs a specific task. It has a name and it is reusable i.e.
it can be executed from as many different parts in a C
Program as required. It also optionally returns a value to the
calling programEvery function has a unique name. This name is
used to call function from “main()” function. A function can
be called from within another function. A function is
independent and it can perform its task without intervention
from or interfering with other parts of the program. A
function performs a specific task. A task is a distinct job that
your program must perform as a part of its overall operation,
such as adding two or more integer, sorting an array into
numerical order, or calculating a cube root etc. A function
returns a value to the calling program. This is optional and
depends upon the task your function is going to accomplish.
Suppose you want to just show few lines through function then
it is not necessary to return a value. But if you are
calculating area of rectangle and wanted to use result
somewhere in program then you have to send back (return)
value to the calling function.
Structure of a Function
A general form of a C function looks like this:
<return type> FunctionName (Argument1, Argument2,
Argument3……)
{
Statement1;

16
Statement2;
Statement3;
}
An example of function.
int sum (int x, int y)
{
int result;
result = x + y;
return (result);
}
6. Discuss bitwise operators.
There are three major bitwise operators that can be used
to combine two numbers: AND, OR, and XOR. When I say that
an operator is bitwise, it means that the operation is actually
applied separately to each bit of the two values being
combined. For example, if x = y AND z, that means that bit 0
of x is actually bit 0 of y ANDed with bit 0 of z. Make
sense? Let's look at each operator in turn and see how they
work. Once we've been through all of that, we'll be in a
position to come up with some practical applications of each.
The AND Operator

17
There are two kinds of AND operators in the C language: the
logical AND, and the bitwise AND. The former is represented
by the && operator, and the latter uses the & operator.
You've probably seen the first one numerous times, as it's
often used in if statements. Here's an example of the logical
AND in action:
if ((x == 5) && (y == 7))
DoSomething();
In this case, you would expect that the function will only be
called if x is 5 and y is 7. The bitwise AND works very much
the same way, except that it works with two bits instead of
two expressions. The bitwise AND operation returns 1 if and
only if both of its operands are equal to 1. In other words,
we have the following truth table for the bitwise AND:
0 AND 0
= 0
0 AND 1
= 0
x AND 0
= 0
1 AND 0
= 0
x AND 1
= x
1 AND 1
= 1
The first column shows the result of a bitwise AND when
combining explicitly defined bits. But it's the second column

18
that's interesting. It says that if you AND any bit with 0, the
result is 0; and if you AND any bit with 1, the result is the
original bit. This little piece of information will be the key to
making the bitwise AND work for us later, so keep it in mind.
To finish up, let's see an example of combining two words
using the bitwise AND operator:
0110 1011 1000 0101
& 0001 1111 1011 1001
---------------------
0000 1011 1000 0001
Do you see why we get the result we do? There is a 1 in the
result only in the positions where the corresponding bits in
both operands are also equal to 1. That's all there is to the
bitwise AND operation. Let's move on.
The OR Operator
Just as with the AND operation, there are two different types
of OR in the C language. The logical OR uses the || operator,
and the bitwise OR uses the | operator. A use of the logical
OR might look something like this:
if ((x == 5) || (y == 7))
DoSomething();
In this example, the function will be called if x is 5, if y is 7,
or both. The only way the function is not called is if both of

19
the conditions are false. The bitwise OR is very similar, in that
it returns 0 if and only if both of its operands are 0. To
illustrate this, we have the following truth table:
0 OR 0
= 0
0 OR 1
= 1
x OR 0
= x
1 OR 0
= 1
x OR 1
= 1
1 OR 1 =
1
Once again, the second column is the interesting one. Note
that whenever you OR a bit with 0, the result is the original
bit, and whenever you OR a bit with 1, the result will always be
1. This will be the key to using OR effectively a little later on.
For now, let's just look at an example of using the bitwise OR
operation on two words:
0110 1011 1000 0101
| 0001 1111 1011 1001
---------------------
0111 1111 1011 1101
Here you can see that the result contains a 0 only when the
corresponding bits in both of the operands are also 0. Now
we've got just one more combinational operator to look at,
and that's XOR.

20
The XOR Operator
The XOR is a little strange because there is no logical
equivalent for it in C, even though many languages include
one. The XOR operation is symbolized by the ^ character in C.
The term XOR stands for "exclusive OR," and means "one or
the other, but not both." In other words, XOR returns 1 if
and only if exactly one of its operands is 1. If both operands
are 0, or both are 1, then XOR returns 0. To see this, take a
look at the truth table for XOR:
0 XOR 0
= 0
0 XOR 1
= 1
x XOR 0
= x
1 XOR 0
= 1
x XOR 1 =
~x
1 XOR 1
= 0
The truth table here is interesting. Note from the first column
that anything XORed with itself returns 0. This fact will lead
to an interesting application of XOR later on. In the second
column, we see that any bit XORed with 0 yields the original
bit, and any bit XORed with 1 yields the complement of the
original bit. This is something you may not have seen before:
the bitwise NOT. It is a unary operator, meaning that it only
takes one operand, like a negative sign. A bitwise NOT simply

21
inverts all the bits in its operand, meaning that all 0s are
changed to 1s, and vice versa. Now, let's take a look at an
example of using XOR on two words:
0110 1011 1000 0101
^ 0001 1111 1011 1001
---------------------
0111 0100 0011 1100
So there you have it, the last of the combinational operators,
plus the only unary bitwise operator, the NOT. Before we can
look at any applications of these, there is one other class of
bitwise operator I need to show you, called shifts. Don't
worry, this will go pretty quickly, and then we can get on to
the interesting stuff.
7. Write an algorithm to find all numbers which are divisible by
3 but not divisible by 6 and draw a flowchart.
1) Get the minimum number
2) get the maximum number
3) start at the minimum number
4) is it divisible by three but not by six?
If yes, jump to step 5
If no, increment by 1 and repeat step 4

22
5) output the current number
6) increment the number by six
7)is it greater than or equal to our maximum number?
if yes, end the program
if no, jump to step 5
8. Differentiate switch statement and nested if statement.
At the code phase, the "switch" statement is used when you
need to "select" between one or more decisions according to
a "completely defined control signal". The "If, else" statement
is much more appropriate for logic and boolean comparisons
rather than equality.
At the compilation phase, the "if" statement is converted to
some sort of "load, compare, and jump" instructions, while the
"switch" statement is converted to a hash table, thus it should
be faster than the "if, else" statement for long list of
comparisons, since it will point and jump directly to the part
of code to get executed.
Nested if-else statements are used in the program's
logic where there isn't only one condition to evaluate. A
switch statement, on the other hand, evaluates only one
variable and starts to work there. You can think of a switch
statement as a simplified (and stripped-down) version of an

23
if-else block.
switch(x) {
case 1: // do this
case 2: // do this
case 3: // do this
// etc
}
The nested if-else statement's power comes from the fact
that it is able to evaluate more than one condition at once,
and/or use lots of different conditions in one logical
structure.
if(x == 0) {
// do this
} else if(y == 1) {
// do this
} else if(x == 1 && y == 0) {
// do this
}
If you're going to evaluate only one variable in the condition
statement, you're better off going with a switch statement,
since it looks a lot neater than nested ifs. However, like in
the case above, there are times where the only structure you

24
could use is an if-else block, so you don't have much of a
choice.
9. What is an array? Explain with examples.
The C language provides a capability that enables the
user to define a set of ordered data items known as an
array.Suppose we had a set of grades that we wished to read
into the computer and suppose we wished to perform some
operations on these grades, we will quickly realize that we
cannot perform such an operation until each and every grade
has been entered since it would be quite a tedious task to
declare each and every student grade as a variable especially
since there may be a very large number.
In C we can define variable called grades, which represents
not a single value of grade but a entire set of grades. Each
element of the set can then be referenced by means of a
number called as index number or subscript.
/* Program to count the no of positive and negative
numbers*/
#include< stdio.h >
void main( )
{
int a[50],n,count_neg=0,count_pos=0,I;
printf(“Enter the size of the arrayn”);
scanf(“%d”,&n);

25
printf(“Enter the elements of the arrayn”);
for I=0;I < n;I++)
scanf(“%d”,&a[I]);
for(I=0;I < n;I++)
{
if(a[I] < 0)
count_neg++;
else
count_pos++;
}
printf(“There are %d negative numbers in the
arrayn”,count_neg);
printf(“There are %d positive numbers in the
arrayn”,count_pos);
}
10. Differentiate iteration and recursion
In Iteration, we specifically run a loop, such that, the
second run of the loop makes use of the computation/result
from the first run, the third run (or iteration) makes use of
the result from the second run and so on. Hence, in
Iteration, the n th run of the loop makes use of the result
from the n-1 th run.
Consider the following example for calculating the
summation, which we will denote as sum(n), meaning n + n-1 +

26
n-2 + n-3 + ... + 2 + 1 + 0. Hence, sum(5) = 5+4+3+2+1+0 =
15.
# When a recursive call is made, the method/process copies
or clones itself, making new copy of:
* the code
* the local variables (with their
initial values),
* the parameters
# Each copy of the code includes a marker indicating
the current position. When a recursive call is made, the marker
in the old copy of the code is just after the call; the marker
in the "cloned" copy is at the beginning of the method.
# When the method returns, that clone goes away,
but the previous ones are still there, and know what to
execute next because their current position in the code was
saved
Now this involves a great overhead in terms of space and as
well as in time also as each function call takes extra time.
2. Iteration : there is no recursive call involved that saves a
lot of time and space too as no extra space is needed to
store each copy generated in recursion.

27
Iterative codes usually refers to codes that contain explicit
iteration processes, that is, loops.
A loop must have some sort of stopping criterion. Usually it
is of one of two type:
1. predetermined number of iterations through the loop;
2. an error tolerance that is achieved.

Bt0067 c programming and data structures 1

More Related Content

What's hot

Viewers also liked

Similar to Bt0067 c programming and data structures 1

More from Techglyphs

Recently uploaded

Bt0067 c programming and data structures 1