Module-2

Character Set, Structure of a ‘C’ Program, Data Types, Operators, Expressions, Assignment Statement, Conditional
Statements, Looping Statements, Nested Looping Statements, Multi Branching Statement (Switch), Break and Continue,
Differences between Break and Continue, Unconditional Branching (Go to Statement)

STRUCTURE OF A C PROGRAM
The structure of a C program is a protocol (rules) to the programmer, which he has to follow while
writing a C program.
A C program basically consists of the following parts:
 Preprocessor Commands
 Functions
 Variables
 Statements & Expressions
 Comments

The general basic structure of C program is shown in the figure below.

Based on this structure, we can sketch a C program.

Let us look at a simple code that would print the words "Hello World": #include
<stdio.h>
int main()
{
/* my first program in C */
printf("Hello, World! \n");

return 0;
}
1. The first line of the program #include <stdio.h> is a preprocessor command, which tells a C compiler
to include stdio.h file before going to actual compilation.
2. The next line int main() is the main function where the program execution begins.
3. The next line /*...*/ will be ignored by the compiler and it has been put to add additionalcomments
in the program. So such lines are called comments in the program.
4. The next line printf(...) is another function available in C which causes the message "Hello, World!" to
be displayed on the screen.
 5. The next line return 0; terminates the main() function and returns the value 0.

Another Example:
/* This program accepts a number & displays it to the user*/
#include <stdio.h> void main(void)
{ int number;
printf( "Please enter a number: " );
scanf( "%d", &number );
printf( "You entered %d", number );
return 0;
}
Stepwise explanation:
#include
The part of the compiler which actually gets your program from the source file is called the
preprocessor.
#include <stdio.h>
#include is a pre-processor directive. It is not really part of our program, but instead it is an instruction
to the compiler to make it do something. It tells the C compiler to include the contents of a file (in
this case the system file called stdio.h).
The compiler knows it is a system file, and therefore must be looked for in a special place, by the fact
that the filename is enclosed in <> characters
<stdio.h>
stdio.h is the name of the standard library definition file for all Standard Input and Output functions.
Your program will almost certainly want to send information to the screen and read things from the
keyboard, and stdio.h is the name of the file in which the functions that we want to use are defined.
The function we want to use is called printf. The actual code of printf will be tied in later by the linker.
The ".h" portion of the filename is the language extension, which denotes an include file.
void
This literally means that this means nothing. In this case, it is referring to the function whose name
follows.Void tells to C compiler that a given entity has no meaning, and produces no error.
Main In this particular example, the only function in the program is called main. A C program is
typically made up of large number of functions. Each of these is given a name by the programmer
and they refer to each other as the program runs.C regards the name main as a special case and will
run this function first i.e. the program execution starts from main. A parameter to a function gives
the function something to work on.
{ (Brace)
This is a brace (or curly bracket). As the name implies, braces come in packs of two - for every open
brace there must be a matching close one. Braces allow us to group pieces of program together,
often called a block. A block can contain the declaration of variable used within it, followed by a
sequence of program statements. In this case the braces enclose the working parts of the function
main.
;( semicolon)
The semicolon marks the end of the list of variable names, and also the end of that declaration
statement.
All statements in C programs are separated by ";" (semicolon) characters. The ";" character is actually
very important. It tells the compiler where a given statement ends. If the compiler does not find one
of these characters where it expects to see one, then it will produce an error.
scanf
In other programming languages, the printing and reading functions are a part of the language. In C this
is not the case; instead they are defined as standard functions which are part of the language
specification, but are not a part of the language itself. The standard input/output library contains a
 number of functions for formatted data transfer; the two we are going to use are scanf (scan
formatted) and printf (print formatted).
printf
The printf function is the opposite of scanf. It takes text and values from within the program and sends
it out onto the screen. Just like scanf, it is common to all versions of C and just like scanf, it is
described in the system file stdio.h.The first parameter to a printf is the format string, which
contains text, value descriptions and formatting instructions.

FILES USED IN A C PROGRAM

Source File- This file contains the source code of the program. The file extension of any c file is .c.
The file contains C source code that defines the main function & maybe other functions.
Header File- A header file is a file with extension .h which contains the C function declarations and
macro definitions and to be shared between several source files.
Object File- An object file is a file containing object code, with an extension .o, meaning relocatable
format machine code that is usually not directly executable. Object files are produced by an
assembler, compiler, or other language translator, and used as input to the linker, which in turn
typically generates an executable or library by combining parts of object files.
Executable File- The binary executable file is generated by the linker. The linker links the various
object files to produce a binary file that can be directly executed.

Types of error
a) Syntax Errors: Errors in syntax (grammar) of the program.
b) Semantic Errors: Errors in the meaning of the program.
c) Logical Errors: Errors in logic of the program. Compiler cannot diagnose these kinds of
errors.
d) Runtime Errors: i) Insufficient memory ii)Floating exception
e) Compile Errors: i) parse error ii)implicit declaration iii) no matching function iv)Unsatisfied
symbols v)incomplete type vi)cannot call member function vii)bad argument viii)cannot
allocate an object

ELEMENTS OF C
Every language has some basic elements & grammatical rules. Before starting with
programming, we should be acquainted with the basic elements that build the language.
Character Set
Communicating with a computer involves speaking the language the computer understands. In
C, various characters have been given to communicate. Character set in C consists of;

Types Character Set

Lower case a-z

Upper case A-Z

Digits 0-9

Special Character !@#$%^&*

White space Tab or new lines or space

 Keywords
Keywords are the words whose meaning has already been explained to the C compiler. The
keywords cannot be used as variable names because if we do so we are trying to assign a
new meaning to the keyword, which is not allowed by the computer. There are only 32
keywords available in C. Below figure gives a list of these keywords for your ready
reference.

Identifier
In the programming language C, an identifier is a combination of alphanumeric characters, the
first being a letter of the alphabet or an underline, and the remaining being any letter of the
alphabet, any numeric digit, or the underline.
Two rules must be kept in mind when naming identifiers.
1. The case of alphabetic characters is significant. Using "INDEX" for a variable is not the
same as using "index" and neither of them is the same as using "InDeX" for a variable. All
three refer to different variables.
2. As C is defined, up to 32 significant characters can be used and will be considered
significant by most compilers. If more than 32 are used, they will be ignored by the
compiler.
Data Type
In the C programming language, data types refer to a domain of allowed values & the
operations that can be performed on those values. The type of a variable determines how
much space it occupies in storage and how the bit pattern stored is interpreted. There are 4
fundamental data types in C, which are- char, int, float &, double. Char is used to store any
single character; int is used to store any integer value, float is used to store any single
precision floating point number & double is used to store any double precision floating
point number.
We can use 2 qualifiers with these basic types to get more types.

There are 2 types of qualifiers-

Sign qualifier- signed & unsigned
Size qualifier- short & long
The data types in C can be classified as follows:

Type Storage size Value range

Char 1 byte -128 to 127

unsigned char 1 byte 0 to 255

Integrity 2 or 4 bytes 32,768 to 32,767 or -2,147,483,648 to 2,147,483,647

 nsigned integrity 2 or 4 bytes 0 to 65,535 or 0 to 4,294,967,295

Short 2 bytes -32,768 to 32,767

unsigned short 2 bytes 0 to 65,535

Long 4 bytes -2,147,483,648 to 2,147,483,64

unsigned long 4 bytes 0 to 4,294,967,295

Type Storage size Value range Precision

Float 4 bytes 1.2E-38 to 3.4E+38 6 decimal places

Double 8 bytes 2.3E-308 to 1.7E+308 15 decimal places

long double 10 bytes .4E-4932 to 1.1E+4932 19 decimal places

Constants
A constant is an entity that doesn‘t
change whereas a variable is an entity that
may change constantscan be divided into two
major categories: Primary Constants,
Secondary Constants

Rules for Constructing Integer Constants:

 An integer constant must have at least one digit.
 It must not have a decimal point.
 It can be either positive or negative.
 If no sign precedes an integer constant it is assumed to be positive.
 No commas or blanks are allowed within an integer constant
 The allowable range for integer constants is -32768to 32767.
Ex.: 426, +782,-8000, -7605

Rules for Constructing Real Constants:

 Real constants are often called Floating Point constants. The real constants could be written
in two forms—Fractional form and Exponential form.
 A real constant must have at least one digit.
 It must have a decimal point.
 It could be either positive or negative.
 Default sign is positive.
 No commas or blanks are allowed within a real constant. Ex. +325.34, 426.0, -32.76, -
 48.5792

Rules for constructing real constants expressed in exponential form:

 The mantissa part and the exponential part should be separated by a letter e.
 The mantissa part may have a positive or negative sign.
 Default sign of mantissa part is positive.
 The exponent must have at least one digit, which must be a positive or negative integer.
Default sign is positive.
 Range of real constants expressed in exponential form is -3.4e38 to 3.4e38.
 Ex. +3.2e-5, 4.1e8, -0.2e+3, -3.2e-5

Rules for Constructing Character Constants:

A character constant is a single alphabet, a single digit or a single special symbol enclosed
withinsingle inverted commas.
The maximum length of a character constant can be 1
character. Ex.: ‗M‘, ‗6‘, ‗+‘

VARIABLES
Variables are names that are used to store values. It can take different values but one at a
time. A data type is associated with each variable & it decides what values the variable can
take. Variable declaration requires that you inform C of the variable's name and data type.
Syntax – data type variable name;
Eg:int page_no;
char grade;
float salary;
long y;
Declaring Variables:
There are two places where you can declare a variable:
After the opening brace of a block of code (usually at the top of a function)
Before a function name (such as before main() in the program) Consider various examples:

Initialization of Variables
When a variable is declared, it contains undefined value commonly known as garbage value. If
we want we can assign some initial value to the variables during the declaration itself. This
is called initialization of the variable.
Eg-int pageno=10;

Expressions
An expression consists of a combination of operators, operands, variables & function calls. An
expression can be arithmetic, logical or relational. Here are some expressions:
a+b – arithmetic operation
a>b- relational operation a
== b - logical operation
func (a,b) – function call

Statements
Statements are the primary building blocks of a program. A program is a series of statements
with some necessary punctuation. A statement is a complete instruction to the computer. In
C, statements are indicated by a semicolon at the end. a semicolon is needed to identify
instructions that truly are statements.
 INPUT-OUTPUT IN C

When we are saying Input that means we feed some data into program. This can be given in
the form of file or from command line. C programming language provides a set of built-in
functions to read given input and feed it to the program as per requirement.
When we are saying Output that means to display some data on screen, printer or in any file.
C programming language provides a set of built-in functions to output the data on the
computer screen.
Functions printf() and scanf() are the most commonly used to display out and take input
respectively. Let us consider an example:

#include <stdio.h> //This is needed to run printf() function.

int main()
{ printf("C Programming"); //displays the content inside quotation return 0;
}
Output:C Programming
Explanation:
Every program starts from main() function.
printf() is a library function to display output which only works if #include<stdio.h>is included
at the beginning.
Here, stdio.h is a header file (standard input output header file) and #include is command to
paste the code from the header file when necessary. When compiler encounters
printf()function and doesn't find stdio.h header file, compiler shows error.
return 0; indicates the successful execution of the program.

Input- Output of integers in C

#include<stdio.h>
int main()
{int c=5;
printf("Number=%d",c);
return 0;
}
Output:Number=5

Input - Output of characters

#include <stdio.h>
int main()
{char var1;
printf("Enter character: ");
scanf("%c",&var1);
printf("You entered %c.",var1);
return 0;
}
Output:Enter character: g You entered g.

FORMATTED INPUT-OUTPUT
Data can be entered & displayed in a particular format. Through format specifications, better
presentation of results can be obtained.

Variations in Output for integer & floats:

#include<stdio.h>
 int main()
{printf("Case 1:%6d\n",9876);
/* Prints the number right justified within 6 columns */
printf("Case 2:%3d\n",9876);
/* Prints the number to be right justified to 3 columns but, there are 4 digits so number is not
right justified */
printf("Case 3:%.2f\n",987.6543);
/* Prints the number rounded to two decimal places */
printf("Case 4:%.f\n",987.6543);
/* Prints the number rounded to 0 decimal place, i.e, rounded to integer */
printf("Case 5:%e\n",987.6543);
/* Prints the number in exponential notation (scientific notation) */
return 0;
}
Output
Case 1: 9876
Case 2:9876
Case 3:987.65
Case 4:988
Storage classes

 Generally there are two kinds of locations in a computer where such a value can be present, these
are Memory and CPU registers. The storage class of a particular variable determines in which of
the above two locations the variable‘s value is stored.
 There are four properties by which storage class of a variable can be recognized. These are scope,
default initial value, scope and life.
 A variable‘s storage class reveals the following things about a variable
(i) Where the variable is stored.
(ii) What is the initial value of the variable if the value of the variable is not specified?
(iii) What is the scope of the variable (To which function or block the variable is available).
(iv) What is the life of particular variable (Up to what extent the variable exists in a program).

 In c there are four types of storage class. They are: 1. Auto 2. Register 3.
Static 4. Extern
 Storage class is modifier or qualifier of data types which decides: In which area of memory
a particular variable will be stored? What is scope of variable? What is visibility of
variable?

Visibility of a variable in c: Visibility means accessibility. Up to witch part or area of a

program, we can access a variable, that area or part is known as visibility of that variable.
For example: In the following figure yellow color represents visibility of variable a.

Scope of a variable in c: Meaning of scope is to check either variable is alive or dead. Alive
means data of a variable has not destroyed from memory. Up to which part or area of the
program a variable is alive, that area or part is known as scope of a variable. There are
four type of scope in c:
1. Block scope.
2. Function scope.
3. File scope.
3. Program scope.
Automatic Storage Class
Syntax to declare automatic variable is:
auto datatype variablename;
Example:
auto int i;
Features of Automatic Storage Class are as follows
Storage: Memory
Default Initial Value: Garbage Value
Scope: Local to the block in which the variable is defined
Life: Till the control remains within the block in which the variable is defined
by default every variable is automatic variable
The following program illustrates the work of automatic variables.
void test();
void main()
{
test();
test();
test();
}
void test()
{
auto int k=10;
printf(―%d\n‖,k);
k++;
}
Output:
10
10
10
In the above program when the function test() is called for the first time ,variable k is created and
initialized to 10. When the control returns to main(), k is destroyed. When function test() is called
for the second time again k is created , initialized and destroyed after execution of the function.
Hence automatic variables came into existence each time the function is executed and destroyed
when execution of the function completes.

Register Storage Class

Syntax to declare register variable is:
register datatype variablename;
Features of Register Storage Class are as follows:
Storage: CPU Registers
Default Initial Value: Garbage Value
Scope: Local to the block in which the variable is defined
Life: Till the control remains within the block in which the variable is defined
For example loop counters are declared as register variables, which are defined as follows:
int main()
{
register int a;
for(a=0;i<50000;i++)
printf(―%d\t‖,a);
return 0;

In the above program, variable a was used frequently as a loop counter so the variable a is defined as a
register variable. Register is a not a command but just a request to the compiler to allocate the
memory for the variable into the register. If free registers are available than memory will be
allocated in to the registers. And if there are no free registers then memory will be allocated in the
RAM only (Storage is in memory i.e. it will act as automatic variable).
Every type of variables can be stored in CPU registers. Suppose the microprocessor has 16 bit registers
then they can‘t hold a float or a double value which requires 4 and 8 bytes respectively.
But if you use register storage class for a float or double variable then you will not get any error
message rather the compiler will treat the float and double variable as be of automatic storage
class(i.e. Will treat them like automatic variables).

Static Storage Class

Syntax to declare static variable is:
static datatype variablename;
Example:
static int i;
Features of Static Storage Class are as follows
Storage: Memory
Default Initial Value: Zero
Scope: Local to the block in which the variable is defined
Life: Value of the variable continues to exist between different function calls
Now look at the previous program with k is declared as static instead of automatic.
void test();
void main()
{
test();
test();
test();
}
void test()
{
static int k=10;
printf(―%d\n‖,k);
k++;
}

Output:10 11 12
Here in the above program the output is 10, 11, 12, because if a variable is declared as static then it is
initialized only once and that variable will never be initialized again. Here variable k is declared as
static, so when test() is called for the first time k value is initialized to 10 and its value is
incremented by 1 and becomes 11. Because k is static its value persists. When test() is called for the
 second time k is not reinitialized to 10 instead its old value 11 is available. So now 11 is get printed
and it value is incremented by 1 to become 12. Similarly for the third time when test() is called
12(Old value) is printed and its value becomes 13 when executes the statement ‗k++;‘

So the main difference between automatic and static variables is that static variables are initialized to
zero if not initialized but automatic variables contain an unpredictable value(Garbage Value) if not
initialized and static variables does not disappear when the function is no longer active , their value
persists, i.e. if the control comes back to the same function again the static variables have the same
values they had last time.

General advice is avoid using static variables in a program unless you need them, because their values
are kept in memory when the variables are not active which means they occupies space in memory
that could otherwise be used by other variables.

External Storage Class

Syntax to declare static variable is:
extern datatype variablename;
Example:
extern int i;
Features of External Storage Class are as follows
Storage: Memory
Default Initial Value: Zero
Scope: Global
Life: Till the program‘s execution doesn‘t come to an end
External variables differ from automatic, register and static variables in the context of scope, external
variables are global on the contrary automatic, register and static variables are local. External
variables are declared outside all functions, therefore are available to all functions that want to use
them.
If the program size is very big then code may be distributed into several files and these files are
compiled and object codes are generated. These object codes linked together with the help of linker
and generate ―.exe‖ file. In the compilation process if one file is using global variable but it is
declared in some other file then it generate error called undefined symbol error. To overcome this
we need to specify global variables and global functions with the keyword extern before using them
into any file. If the global variable is declared in the middle of the program then we will get
undefined symbol error, so in that case we have to specify its prototype using the keyword extern.

So if a variable is to be used by many functions and in different files can be declared as external
variables. The value of an uninitialized external variable is zero. The declaration of an external
variable declares the type and name of the variable, while the definition reserves storage for the
variable as well as behaves as a declaration. The keyword extern is specified in declaration but not
in definition. Now look at the following four statements

1. auto int a;
2. register int b;
3. static int c;
4. extern int d;
Out of the above statements first three are definitions where as the last one is a declaration. Suppose
there are two files and their names are File1.c and File2.c respectively. Their contents are as
follows:
File1.c
int n=10;
void hello()
{
printf(―Hello‖);
}
File2.c
extern int n;
extern void hello();
void main()
{printf(―%d‖, n);
hello();}
In the above program File1.obj+ File2.obj=File2.exe and in File2.c value of n will be 10.

OPERATORS-An operator is a symbol that tells the compiler to perform specific mathematical or
logical manipulations. C language is rich in built-in operators and provides the following
types of operators: Arithmetic Operators, Relational Operators, Logical Operators, Bitwise
Operators, Assignment Operators, Increment and decrement operators, Conditional
operators, Misc Operators

Arithmetic operator: Assume variable A holds 10 and variable B holds 20 then:

Operator Description Example

+ Adds two operands A + B will give 30

- Subtracts second operand from the first A – B will give -10

* Multiplies both operands A * B will give 200

/ Divides numerator by de-numerator B / A will give 2

Modulus Operator and remainder of after an integer

% B % A will give 0
Division

++ Increments operator increases integer value by one A++ will give 11

-- Decrements operator decreases integer value by one A–will give 9

Relational Operators:
Assume variable A holds 10 and variable B holds 20, then:
Operator Description Example

== Checks if the values of two operands are equal or not, if yes (A == B) is not
then condition becomes true. true.

!= Checks if the values of two operands are equal or not, if (A != B) is true.

values are not equal then condition becomes true.

> Checks if the value of left operand is greater than the value (A > B) is not
of right operand, if yes then condition becomes true. true.

< Checks if the value of left operand is less than the value of (A < B) is true.
right operand, if yes then condition becomes true.

>= Checks if the value of left operand is greater than or equal to (A >= B) is not
the value of right operand, if yes then condition becomes true.
true.

<= Checks if the value of left operand is less than or equal to the (A <= B) is true.
value of right operand, if yes then condition becomes true.

Logical Operators:
Assume variable A holds 1 and variable B holds 0, then:
Operator Description Example

Called Logical AND operator. If both the operands are (A && B) is

&&
nonzero, then condition becomes true. false.

Called Logical OR Operator. If any of the two operands is

|| (A || B) is true.
non-zero, then condition becomes true.

Called Logical NOT Operator. Use to reverses the logical

!(A && B) is

! state of its operand. If a condition is true then Logical NOT

true.
operator will make false.
Bitwise Operators
Bitwise operator works on bits and performs bit-by-bit operation. These operators can operate upon int
and char but not on float and double..Bit wise operators in C language are; & (bitwise AND), |
(bitwise OR), ~ (bitwise OR), ^ (XOR), << (left shift) and >> (right shift).The truth tables for &, |,
and ^ are as follows:
P Q p&q p|q p^q

0 0 0 0 0

0 1 0 1 1

1 1 1 1 0

1 0 0 1 1

Assume variable A holds 60 (00111100) and variable B holds 13 (00001101), then:

Operator Description Example

& Binary AND Operator copies a bit to the result if it (A & B) will give 12,
exists in both operands. which is 0000 1100

| Binary OR Operator copies a bit if it exists in either (A | B) will give 61,

operand. which is 0011 1101

^ Binary XOR Operator copies the bit if it is set in (A ^ B) will give 49,
one operand but not both. which is 0011 0001

~ Binary Ones Complement Operator is unary and has (~A ) will give -61, which
the effect of ‗flipping‘ bits. is 1100 0011 in 2‘s
complement form.

<< Binary Left Shift Operator. The left operands value A << 2 will give 240
is moved left by the number of bits specified by the which is 1111 0000
right operand.

>> Binary Right Shift Operator. The left operands A >> 2 will give 15
value is moved right by the number of bits specified which is 0000 1111
by the right operand.
Assignment Operators:
In C programs, values for the variables are assigned using assignment operators.
There are following assignment operators supported by C language:
Operator Description Example

= mple assignment operator, Assigns values from right side C = A + B will

operands to left side operand assign value of A +
B into C

+= d AND assignment operator, It adds right operand to the C += A is

left operand and assign the result to left operand equivalent to C = C
+A

-= Subtract AND assignment operator, It subtracts right C -= A is

operand from the left operand and assign the result to left equivalent to C = C
Operand –A

*= Multiply AND assignment operator, It multiplies right C *= A is

operand with the left operand and assign the result to left equivalent to C = C
Operand *A

/= Divide AND assignment operator, It divides left operand C /= A is

ith the right operand and assign the result to left operand equivalent to C = C
/A

%= odulus AND assignment operator, It takes modulus using C %= A is

two operands and assign the result to left operand equivalent to C = C
%A

<<= Left shift AND assignment operator C <<= 2 is same as

C = C << 2

>>= Right shift AND assignment operator C >>= 2 is same as

C = C >> 2

&= Bitwise AND assignment operator C &= 2 is same as

C=C&2

^= bitwise exclusive OR and assignment operator C ^= 2 is same as C

=C^2

|= bitwise inclusive OR and assignment operator C |= 2 is same as C

=C|2
Increment/Decrement OPERATOR
In C, ++ and – are called increment and decrement operators respectively. Both of these operators are
unary operators, i.e, used on single operand. ++ adds 1 to operand and – subtracts 1 to operand
respectively. For example:
Let a=5 and b=10
a++; //a becomes 6
a--; //a becomes 5
++a; //a becomes 6
--a; //a becomes 5
When i++ is used as prefix(like: ++var), ++var will increment the value of var and then return it but, if
++ is used as postfix(like: var++), operator will return the value of operand first and then only
increment it. This can be demonstrated by an example:
#include <stdio.h>
int main()
{int c=2,d=2;
printf(―%d\n‖,c++); //this statement displays 2 then, only c incremented by 1 to 3.
Printf(―%d‖,++c); //this statement increments 1 to c then, only c is displayed.
Return 0;
}
Output:2 4

Conditional Operators (? :)
Conditional operators are used in decision making in C programming, i.e, executes different statements
according to test condition whether it is either true or false.
Syntax of conditional operators;
conditional_expression?expression1:expression2
If the test condition is true (that is, if its value is non-zero), expression1 is returned and if false
expression2 is returned.
y = ( x> 5 ? 3 : 4 ) ;this statement will store 3 in y if x is greater than 5, otherwise it will store 4 in y.

Misc Operators:
There are few other operators supported by c language.
Operator Description Example

sizeof() It is a unary operator which is used in sizeof(a), where a is integer, will

finding the size of data type, constant, return 4.
arrays, structure etc.

& Returns the address of a variable. &a; will give actual address of
the variable.

* Pointer to a variable. *a; will pointer to a variable.

Operators Precedence in C
Operator precedence determines the grouping of terms in an expression. This affects how an expression
is evaluated. Certain operators have higher precedence than others; for example, the multiplication
operator has higher precedence than the addition operator.
For example x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than
+, so it first gets multiplied with 3*2 and then adds into 7.
Here, operators with the highest precedence appear at the top of the table, those with the lowest appear
at the bottom. Within an expression, higher precedence operators will be evaluated first.
Category Operator Associativity

Postfix () [] -> . ++ - - Left to right

Unary + - ! ~ ++ - - (type)* &sizeof Right to left

Multiplicative */% Left to right

Additive +- Left to right

Shift <<>> Left to right

Relational <<= >>= Left to right

Equality == != Left to right

Bitwise AND & Left to right

Bitwise XOR ^ Left to right

Bitwise OR | Left to right

Logical AND && Left to right

Logical OR || Left to right

Conditional ?: Right to left

Assignment = += -= *= /= %=>>= <<= &= ^= |= Right to left

Comma , Left to right

Type casting

 Type casting /type conversion is a way to convert a variable from one data type to
another data type. For example, if you want to store a long value into a simple integer
then you can typecast long to int.
 You can convert values from one type to another explicitly using the cast operator. There
are two types of type casting in c languages that are implicit conversions and Explicit
Conversions.
 New data type should be mentioned before the variable name or value in brackets which
to be typecast.
C TYPE CASTING EXAMPLE PROGRAM:
In the below C program, 7/5 alone will produce integer value as 1.So, type cast is done
before division to retain float value (1.4).
#include <stdio.h>
int main ()
{
float x;
x = (float) 7/5;
printf(―%f‖,x);
}
Output:
1.400000
WHAT IS TYPE CASTING IN C LANGUAGE?
Converting an expression of a given type into another type is known as type casting. It is best
practice to convert lower data type to higher data type to avoid data loss.Data will be
truncated when the higher data type is converted to lower. For example, if a float is
converted to int, data which is present after the decimal point will be lost.
There are two types of type casting in c language.
TYPES OF TYPECASTING IN C
Types of type casting in C Programming
Implicit Conversion
Explicit Conversion
1. IMPLICIT CONVERSION
Implicit conversions do not require any operator for converted. They are automatically
performed when a value is copied to a compatible type in the program.

#include<stdio.h>
#include<conio.h>
void main()
{
int i=20;
double p;
clrscr();
p=i; // implicit conversion
printf(―implicit value is %d‖,p);
getch();}

Output:-
implicit value is 20.
2. EXPLICIT CONVERSION
In C language, Many conversions, especially those that imply a different interpretation of the
value, require an explicit conversion.
Example :-
#include<stdio.h>
#include<conio.h>
void main()
{
int i=20;
short p;
clrscr();
p = (short) i; // Explicit conversion
printf(―Explicit value is %d‖,p);
getch();
}
Output:-
Explicit value is 20.

Usual Arithmetic Conversion

The usual arithmetic conversions are implicitly performed to cast their values in a common
type, C uses the rule that in all expressions except assignments, any implicit type
conversions made from a lower size type to a higher size type as shown below:
Type Casting In C Language
DIFFERENCE BETWEEN TYPE CASTING AND TYPE CONVERSION
BASIS FOR TYPE CASTING TYPE CONVERSION
COMPARISO
N
Definition When a user can convert the one Type Conversion is that which
data type into other then it is automatically converts the one
called as the type casting. data type into another.
Implemented Implemented on two Implemented only when two data
‗incompatible‘ data types. types are ‗compatible‘.
Operator For casting a data type to another, No operator required.
a casting operator ‗()‘ is
required.
Implemented It is done during program It is done explicitly while
designing. compiling.
Conversion type Narrowing conversion. Widening conversion.
Example int x; int x=3;
byte y; float y;
…y= (byte) x; y=a; // value in y=3.000.

Inbuilt Typecast Functions In C:

There are many inbuilt type casting functions available in C language which performs data
type conversion from one type to another.

S.No Typecast Function Description

1 atof() Convert string to Float
2 atoi() Convert string to int
3 atol() Convert string to long
4 itoa() Convert int to string
5 ltoa() Convert long to string
CONTROL STATEMENTS
Control statements enable us to specify the order in which the various instructions in the program are to
be executed. They define how the control is transferred to other parts of the program. Control
statements are classified in the following ways:

If, if-else, Case switch statements

a) If statement
Syntax:
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 ()
{ int a = 10;
if( a < 20 )
{ Printf("a is less than 20\n" );
 }
Printf("value of a is : %d\n", a);
}
When the above code is compiled and executed, it produces following result:
a is less than 20;
value of a is : 10

(b) if –else statement

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 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>
main ()
{ int a = 100;
if( a < 20 )
{ Printf("a is less than 20\n" );
}
else
{ Printf("a is not less than 20\n" );
} Printf("value of a is : %d\n", a);}
When the above code is compiled and executed, it produces following result:
a is not less than 20;
value of a is : 100

(c) Nested if-else statement

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 */
}
}
Example:
#include <stdio.h>
main ()
{ int a = 100;
int b = 200;
if( a == 100 )
{ if( b == 200 )
{ printf("Value of a is 100 and b is 200\n" );
}
}
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 following result:
Value of a is 100 and b is 200
Exact value of a is : 100
Exact value of b is : 200

(d) 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:
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:
 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.
Flow Diagram:

Example:
main ()
{ 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 );
}
When the above code is compiled and executed, it produces following result:
Well done
Your grade is B
 Program Loops and Iteration A loop statement allows us to execute a statement or group of statements
multiple times and following is the general from of a loop statement in most of the programming
languages:

(a) Uses of while loop

A while loop statement in C programming language repeatedly executes a target statement as long as a
given condition is true.
Syntax:
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:

Example:
#include <stdio.h> main ()
{ int a = 10;
while( a < 20 )
{
printf("value of a: %d\n", a);
a++;
}
}
When the above code is compiled and executed, it produces 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

(b) 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:
do
{ Statement;
} while ( condition );
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. Flow Diagram:

Example:
#include <stdio.h>
main ()
{ int a = 10;
do
{ printf("value of a: %d\n", a);
a = a + 1;
} while ( a < 20 );
}
When the above code is compiled and executed, it produces 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

(c) For loops

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:
for ( initialization ; condition; increment )
{ statement(s);
}
Flow Diagram:

Example:
#include <stdio.h>
main ()
{ for( int a = 10; a < 20; a = a + 1 )
{ printf("value of a: %d\n", a);
}
}
When the above code is compiled and executed, it produces 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
 Jump statements

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.
(i) Break statement: Terminates the loop or switch statement and transfers execution to the
statement immediately following the loop or switch. The break statement in C
programming language has following two usage:
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.

Syntax:
Break;
Flow Diagram:

Example:
#include <stdio.h>
main ()
{ int a = 10;
while( a < 20 )
{ printf("value of a: %d\n", a);
a++;
if( a > 15)
{ break;
}
}
}
When the above code is compiled and executed, it produces 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
 (ii) Continue statement: Causes the loop to skip the remainder of its body and immediately
retest its condition prior to reiterating. 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. Syntax: continue;

Flow Diagram:

Example:
#include <stdio.h>
main ()
{ int a = 10;
do
{ if( a == 15)
{ a = a + 1;
continue;
}
printf("value of a: %d\n", a);
a++;
} while( a < 20 );
}
When the above code is compiled and executed, it produces 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

(iii) Goto Statement: Transfers control to the labeled statement. Though it is not advised to
use goto statement in your program A goto statement in C programming language
provides an unconditional jump from the goto to a labeled statement in the same function.
Syntax:
goto label;
 label: statement;
Flow Diagram:

Example:
#include <stdio.h>
main ()
{ int a = 10;
LOOP: do
{ if( a == 15)
{ a = a + 1;
goto LOOP;
}
printf("value of a: %d\n", a);
a++;
}while( a < 20 );
}
When the above code is compiled and executed, it produces 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