Introduction to C Program

•In 1960, at Cambridge University at USA, a

powerful and basic language was developed
known as B language.
•Original name of B-Language is Basic Combined
Programming Language (BCPL).
•Afterwards the BCPL was renamed as “C”
Language.
•Dennis Ritchie had developed C-Language in
1972 at “Bell-Laboratories” in USA.
There exist three important areas in typical C Program such as:
1. Include Block
2. Function Block
3. Main Block

# include  stdio.h  

# include  math.h   Include Block
# include  string.h  
main () 

{  Main Block
} 

Sample program: Printing a Message
main() Function name
{ start of the program
…………
………… Program statements
…………
} end of the program
 main()
{
/* ……. Printing begins……..*/
printf(“I see, I remember”);
printf(“I see,\n I remember !”);
/* ……. Printing ends……..*/
}
Output: I see, I remember
I see
I remember !
 Constants, Variables and Data Types
• The characters in C are grouped into the
following categories:
• Letters, Digits, Special characters and White
spaces.
Alphabets A,B,…….Y,Z
A,b,…….y,z
Digits 0,1,2,3,4,5,6,7,8,9

Special Symbols ~ ‘ ! @ # % ^ & * () _ - +

=|\ { } [ ] : ; “ ‘ <
> , . ? /
 Types of C Constants
C Constants

Primary Constants Secondary Constants

Array
Integer Constant
Pointer
Real Constant
Structure
Character Constant
Union
Enum etc.
 Rules for constructing Integer Constraints
• An integer constant must have at least one digit.
• It must not have a decimal point.
• It could 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 constant is
-32768 to +32767.
Rules for constructing Real Constraints
• A real constant must have at least one digit.
• It must have a decimal point.
• It could be either positive or negative.
• No commas or blanks are allowed within a real
constant.
• Default sign is positive.
Ex:
426.0
-32.76
-48.5792
 Rules for constructing Character Constraints
• 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
in positive.
• Range of real constants expresses in exponential
form is -3.4e38 to 3.4e38
Ex: +3.2e-5 4.1e8
 C Keywords

auto double if static break

struct case else int static
case enum long switch char
extern near typedef const float
register union continue far return
unsinged default for short void
do goto signed while
 C Data Types
C supports three classes of data types:
1. Primary data types.
2. Derived data types.
3. User defined data types.
Primary data types
1. Integer type:
signed : int, short int, long int.
unsigned: unsinged int, unsinged short int, unsinged long
int.
2. Character type: char, singed char, unsinged char.
3. Floating point type: float, double, long double.
 Size and Range of data types on a 16-bit
Type Size(bits) Range

Char or singed char 8 -128 to 127

Unsinged char 8 0 to 255

Int or singed int 16 -32,768 to 32,767

Unsinged int 16 0 to 65535

Short int or singed short int 8 -128 to 127

Unsinged short int 8 0 to 255

Long int or singed long int 32 -2,147,483,648 to 2,147,48

Unsinged long int 32 0 to 4,294,967,295

float 32 3.4E-38 to 3.4+38

double 64 1.7E-308 to 1.7E+308

Long double 80 3.4E -4932 to 1.1E+4932

 Declaration of Variables
• data-type v1,v2,….vn;
v1,v2……vn are the names of variables,
variables are separated by commas.
A declaration statement must end with a semicolon.
Example: int count;
int number, total; (multiple)
double ratio;
• Derived data types
such as arrays, functions, structures and pointers.
• User Defined type declaration
1. typedef type identifier;
where type refers to an existing data type and
identifier refers to the new name given to the data
type.
Example: typedef int units;
typedef float marks;
2. enum identifier {value1, value2, …..value n}
The identifier is a user defined enumerated data type
which can be used to declare variables that can have
one of the values enclosed with in the braces.
 Declaration of storage class
• Variables in C can have not only data type but also storage class that
provides information about their location and visibility.
• The storage class decides the portion of the program within which
the variables are recognized.
Ex: int m;
main() function1()
{ {
int i; int i;
float balance; float sum;
………. ………..
function1(); }
}
the variable m which has been declared before main is called global
variable
• Global variable can be used in all the functions in the
program. It need not be declared in other functions.
• A global variable is also known as an external
variable.
• The variable i, balance and sum are called local
variables because they are declared inside function.
• Local variables are visible and meaningful only
inside the function in which they are declared. They
are not known to other functions.
Note: i has been declared in both the functions, any
change in the value of i in one function does not
effect its value in the other.
Storage classes:
• auto, register, static and extern.
Example: auto int count; register char ch;
static int x; extern long total;
• static and external (extern) variables are automatically
initialized to zero.
• Automatic (auto) variables contain undefined values
(known as garbage) unless they are initialized explicitly.
Storage class Meaning
auto Local variable known only to the function in which it is
declared. Default is auto.
static Local variable which exists and retains its value even after
the control is transferred to the calling function.
extern Global variable known to all function in the file.
register Local variable which is stored in the register.
 Assigning values to variables
• Variable_name = constant;
Ex: balance = 75.84;
• an assignment statement implies that the value of
the variable on the left of the equal sign is set equal
to the value of the quantity on the right.
Ex: year = year+1;
data_type variable_name = constsnt;
Ex: double balance = 75.84;
Initialization : the process of giving initial values to
variables is called initialization.
p = q = s =0; (multiple assignments)
Program: main()
{
float x, p;
double y, q;
Unsigned k;
int m=54321;
long int n= 1234567890;
x=1.234567890000;
y=9.87654321; output:
k=54321;
p=q=1.0; (garbage value)
Printf(“m=%d\n”,m); m= -11215 (16 bit, max store 32767)
Print(“n=%ld\n”,n); n= 1234567890
Printf(“x=%.12lf\n”,x); x= 1.234567880630
Printf(“x=%f\n”,x); x= 1.234568
Printf(“y=%.12lf\n”,y); y=9.876543210000
Printf(“x=%lf\n”,x); y=9.876543
Printf(“y=%u p=%f q=%.12lf\n”,k,p,q); } k=5432 p=1.000000
q=1.000000000000
 Reading Data from Keyboard
Syntax:
scanf(“control string”, &variable1,&variable2,……..);
Ex: scanf(“%d”, &number);
main()
{
int number;
printf(“enter an integer number\n”);
scanf(“%d”, &number);
if(number < 100)
printf(“your number is smaller than 100”);
else
printf(“your number contains more than two digits”);
}
Managing Input and Output Operations
Reading a character:
getchar: Reading a single character can be done by
using the function getchar.
syntax: variable_name = getchar();
Ex: char name;
name = getchar();
Will assign the character ‘H’ to the variable name when
we press the key H on the keyboard. Since getchar is a
function, it requires a set of parentheses as shown.
#include<stdio.h>
main()
{
char answer;
printf(“would you like to know my name?\n”)
printf(“Type Y for yes and N for No:”);
answer = getchar();
if(answer = = ‘Y’ || answer == ‘y’)
printf(“\n My name is BUSY BEE\n”);
else
printf(“\n you are good for nothing”);
}
 Character Test Function
Function Test

isalnum(c) Is c an alphanumeric character?

isalpha(c) Is c an alphabetic character?
isdigit(c) Is c a digit ?
islower(c) Is c lower case letter ?
isprint(c) Is c a printable character ?
ispunct(c) Is c a punctuation mark ?
isspace(c) Is c a white space character ?
isupper(c) Is c an upper case letter ?
 Writing a Character
Syntax: putchar (variable_name);
Where variable_name is a type char variable containing a
character. This statement displays the character contained in
the variable_name at the terminal.
Ex: answer =‘Y’;
putchar (answer);
#include<stdio.h>
#include<ctype.h>
main()
{
char alphabet;
printf(“enter an alphabet”);
putchar(‘\n’); /* move to next line */
alphabet = getchar();
if(islower(alphabet))
putchar(toupper(alphabet)); /* Reverse and display */
else
putchar(tolower(alphabet)); /* Reverse and display */
Output: 1. Enter an alphabet 2. Enter an alphabet
a Q
A q
 Commonly used scanf Format codes
Code Meaning

%c read a single character

%d read a decimal integer
%e read a floating point value
%f read a floating point value
%h read a shot integer
%i read a decimal, hexadecimal or octal integer
%o read an octal integer
%s read a string
%u read an unsigned decimal integer
%x read a hexadecimal integer
%[….] read a string of word(s)
 Formatted output
Printf(“control string”, arg1, arg2,……….,argn);
Output of Integer Numbers:
Format Output
printf(“%d”, 9876) 9 8 7 6

printf(“%6d”, 9876) 9 8 7 6

printf(“%-6d”, 9876) 9 8 7 6

printf(“%06d”, 9876) 0 0 9 8 7 6
Output of Real Numbers:
y=98.7654
Format Output
printf(“%7.4f”, y) 9 8 . 7 6 5 4

printf(“%7.2f”, y) 9 8 . 7 7

printf(“%-7.2f”, y) 9 8 . 7 7

printf(“%f”, y) 9 8 . 7 6 5 4

Printf(“%10.2e”,y) 9 . 8 8 e + 0 1

Printf(“%-10.2e”,y) 9 . 8 8 e + 0 1
Printing of a Single Character:
for character print %c is used.
for string print %s is used.
main()
{
char x = ‘A’;
char name[20] = “ANIL KUMAR GUPTA”;
printf(“output of characters”);
printf(“%c\n%3c\n%5c\n”, x,x,x);
printf(“output of strings”);
printf(“%s\n”, name);
printf(“%20s\n”, name);
printf(“%20.10s\n”, name);
printf(“%.5s\n”, name);
printf(“%-20.10s\n”, name);
}
 Operators and Expressions
C operators can be classified into a number of categories.
They include:
1. Arithmetic operators
2. Relational operators
3. Logical operators
4. Assignment operators
5. Increment and decrement operators
6. Conditional operators
7. Bitwise operators
8. Special operators
 Arithmetic operators
Operator Meaning

+ Addition or unary plus

- Subtraction or unary minus
* Multiplication
/ Division
% Modulo division
Integer Arithmetic:
if a=14 and b=4
a-b = 10 a+b = 18 a*b = 16 a/b = 3 a%b = 2
During integer division, if both the operands are of the same
sign, the result is truncated towards zero. If one of them is
negative, the direction of truncation is implementation
dependent. 6/7 =0 and -6/-7=0
but -6/7 may be zero or -1 (Machine dependent)
Similarly, during modulo division, the sign of the result is
always the sign of the first operand.
-14%3 = -2 -14% -3 = -2 14%-3 = 2
Real Arithmetic:
if x, y and z are floats,
x=6.0/7.0 = 0.857143
y=1.0/3.0 = 0.333333
z= -2.0/3.0 = -0.666667
Mixed-mode Arithmetic :
When one of the operands is real and the other is integer, the
expression is called a mixed mode arithmetic expression.
If either operand is of the real type, then only the real
operation is performed and the result is always a real number.
15/10.0 = 1.5 15/10 = 1
 Relational operators
Operator Meaning
< Is less than
<= Is less than or equal to
> Is greater than
>= Is greater than or equal to
== Is equal to
!= Is not equal to

Logical operators
&& Meaning logical AND
|| Meaning logical OR
! Meaning logical NOT

Ex: a>b && x==10

Relative precedence of the relational and logical
operators is as follows:
Highest !
>, >= , < , <=
== , !=
&&
Lowest ||
 Assignment Operators
Assignment operators are used to assign the result
of an expression to a variable.
Statement with simple Statement with
assignment operator shorthand operator
a=a+1 a+=1
a=a-1 a-=1
a=a*(n+1) a*=n+1
a=a/(n+1) a/=n+1
a=a%b a%=b
#define N 100
#define A 2
main()
{
int a; output:
a= A;2
while(a<N) 4
{ 16
printf(“%d”,a);
a * = a;
}
}
 Increment and Decrement operators
C allows two very useful operators. ++ and –
The operator ++ ads 1 to the operand, while – subtracts 1.
++m; is equivalent to m=m+1;
--m; is equivalent to m=m-1;
Ex: m=5; y=++m;
the value of y and m would be 6.
m=5; y=m++
the value of y would be 5 and m would be 6.
A prefix operator first adds 1 to the operand and then the result
is assigned to the variable on left.

A postfix operator first assigns the value to the variable on left

and then increments the operand.
 Conditional operators
Syntax: exp1? exp2 : exp3
exp1 is evaluated first.
•If it is nonzero(true), then the expression exp2 is
evaluated and becomes the value of the expression .
•If exp1 is false, exp3 is evaluated and its value becomes
the value of the expression
Ex: a=10; b=15;
x=(a>b)?a:b;
In this example, x will be assigned the value of b.
 Bitwise operators
• These operators are used for testing the bits, or
shifting them right or left.
• Bitwise operators may not be applied to float or
double .
Operator Meaning
& Bitwise AND
| Bitwise OR
^ Bitwise exclusive OR
<< Shift left
>> Shift right
 Special operators

The comma operator:

The comma operator can be used to link the related
expressions together.
Ex: value =(x=10, y=5, x+y);

The sizeof operator:

The sizeof is a compile time operator and, when used with an
operand, it returns the number of bytes the operand occupies.
Ex: m=sizeof(sum);
 Operator Precedence
Preceden
Tokens Operator Class Associates
ce

(type) casts unary 14 right-to-left

* / % multiplicative binary 13 left-to-right
+ - additive binary 12 left-to-right
<< >> left, right shift binary 11 left-to-right
< <= > >= relational binary 10 left-to-right
== != equality/ineq. binary 9 left-to-right
& bitwise and binary 8 left-to-right
^ bitwise xor binary 7 left-to-right
| bitwise or binary 6 left-to-right
&& logical and binary 5 left-to-right
|| logical or binary 4 left-to-right
?: conditional ternary 3 right-to-left

= += -=
*= /= %=
assignment binary 2 right-to-left
&= ^= |=
<<= >>=

, sequential eval. binary 1 left-to-right

 Operator precedence

Preced
Tokens Operator Class Associates
ence

names,
literals simple tokens primary n/a

a[k] subscripting postfix left-to-right

f(...) function call postfix left-to-right

16
. direct selection postfix left-to-right

-> indirect selection postfix left to right

++ -- increment, decrement postfix left-to-right

(type){init} compound literal postfix left-to-right

++ -- increment, decrement prefix right-to-left

sizeof size unary right-to-left

~ bitwise not unary right-to-left

! logical not unary right-to-left

15
- + negation, plus unary right-to-left

& address of unary right-to-left

indirection
* unary right-to-left
(dereference)
 Casting Operator
Convert from one data type to another data type.
Ex: main()
{
int i=10;
float g=50.56;
i=g; /* i=(int)g here float value convert to integer*/
printf(“%d”, i);
}
Output: 50
(int), (float), (char), (double)
 The Decision Control structure
The if statement :
If(this condition is true)
execute this statement;
Ex:
main()
{
int num;
printf(“ enter a number less than 10”);
scanf(“%d”, &num);
if(num <=10 )
printf(“ less than 10”); (single statement with in
if)
}
 Multiple statements within if
/* Calculation of bonus*/
main()
{
int bonus, cy, yoj, yr_of_ser;
printf(“Enter current year and year of joining”);
scanf(“%d%d”, &cy, %yoj);
yr_of_ser = cy-yoj;
If(yr_of_ser > 3)
{
bonus = 2500; Multiple statements
printf(“ bonus = RS. %d”, bonus); within if
}
}
 If –else statement
/* calculation of gross salary*/
main()
{
float bs, gs, da, hra;
printf(“Enter basic salary”);
scanf(“%f”, &bs);
if(bs<1500)
{
hra = bs * 10/100;
da = bs * 90/100;
}
else
{
hra = 500;
da = bs*98/100;
}
gs = bs+hra+da;
printf(“gross salary=Rs.%f”, gs);
}
/*Nested if elses */
main()
{
int i;
printf(“enter either 1 or 2”);
scanf(“%d”, &i);
if(i==1)
printf(“enter 1”);
else
{
if(i==2)
printf(“enter 2”);
else
printf(“HI”);
}
}
 Forms of if
a. if (condition)
do this;
b. if(condition)
{
do this;
and this;
}
c. if(condition)
do this;
else
do this;
d. if(condition)
{
do this;
and this;
}
else
{
do this;
and this;
}
e.
if(condition)
do this;
else
{
if(condition)
do this;
else
{
do this;
and this;
}
}
Write a program to calculate the division obtained by the student.
main()
{
int m1,m2,m3,m4,m5,per;
printf(“enter marks in five subjects”);
scanf(“%d%d%d%d%d”, &m1,&m2,&m3,&m4,&m5);
per=(m1+m2+m3+m4+m5)/5;
if(per > = 60)
printf(“ first division”);
else
{
if(per >=50)
printf(“ second division”);
else
{
if(per >=40)
printf(“ third division”);
else
printf(“Fail”);
}
}
}
Using Logical operators
main()
{
int m1,m2,m3,m4,m5,per;
printf(“enter marks in five subjects”);
scanf(“%d%d%d%d%d”, &m1,&m2,&m3,&m4,&m5);
per=(m1+m2+m3+m4+m5)/5;
if(per > = 60)
printf(“ first division”);
if((per > = 50) && (per < 60) )
printf(“ second division”);
if((per > = 40) && (per < 50) )
printf(“ third division”);
if(per < 40)
printf(“Fail”);
}
 The Loop Control Structure
1. While Loop
2. Do-While Loop
3. For Loop
4. Nested for Loop

• Loops involves repeating some portion of the

program either a specified number of times or until
a particular condition is being satisfied
1.While statement
• The While loop assists in the program where you
want to carry out an activity for a certain number of
times.
Example:- calculating gross salaries of ten people or
converting temperatures from centigrade to
Fahrenheit for 15 different cities
Syntax:
While (condition)
{
Statement;
}
PROGRAM EXAMPLE:
#include <stdio.h>
main()
{
int p,n,count;
float r,si;
count = 1;
while (count <=3)
{
printf("The values of p, n and r“);
scanf(“%d%d%f”, &p,&n,&r);
si = p * n* r/100;
printf( "Simple interest= %f “ , si);
count = count+1;
}
}
 The condition to be tested may use the relational
operators:
Example:-
1. While (I <= 10)
2. While (I <=10 && j <=15)
3. While (j >10 && (b <15 || c<20)
While(i<=10)
i=i+1;
is same as
While(i<=10)
{
i=i+1;
}
 The Loop Control Structure
Example B:
main()
{
int i=0;
while (++i <=10)
printf(“%d”, i);
}

In the statement while( ++i <= 10),

first incrementation of I takes place, then the
comparison of value of I with 10 is performed .
The do-While Loop
Syntax:
do
{
this;
and this;
and this;
and this;
}while (this condition is true);

The do-While loop execute its statements at least once

even if the condition fails for the first time.
Program Example 1:
#include<stdio.h>
main()
{
while (4<1)
printf(”Here there”);
}

• If the condition fails the printf will not be

executed even once.
Program Example 2:
#include<stdio.h>
main()
{
do
{
printf(”Hello there”);
}while(4<1);
}
• In this program the printf would be executed once,
since first the body of the loop is executed and then
the condition is tested.
 For Loop
• The for loop specifies three elements about the loop in one
single line.
• Setting a loop counter to an initial value.
• Testing the loop counter to determine whether its value has
reached the number of repetitions desired.
• Increasing the value of loop counter each time the program
segment within the loop has been executed.
Syntax:
for (initialize counter; test counter; increment counter)
{
do this;
and this;
}
Program example: Calculate the simple interest:
#include <stdio.h>
main()
{
int p,n,count;
float r,si;
for (count = 1; count <=3; count = count + 1)
{
printf("The values of p, n and r“);
scanf(“%d%d%f”, &p,&n,&r);
si = p * n* r/100;
printf( "Simple interest= %f “ , si);

}
}
a. main()
{
int i;
for(i=1; i<=10;)
{
printf(“%d”, i);
i=i+1;
}
}
• Here, the incrementation is done within the body of the
for loop and not in the for statement.
b. main()
{
int i = 1;
for(; i<=10; i=i+1)
{
printf(“%d”, i);
}
}
• Here, the initialisation is done in the declaration
statement itself, but still the semicolon before the
condition necessary.
c. main()
{
int i = 1;
for(; i<=10; )
{
printf(“%d”, i);
i=i+1;
}
}
• Here, neither the initialisation, nor the incrementation is
done in the for statement, but still the semicolon before
the condition necessary.
d. main()
{
int i;
for(i=0; i++<10; )
{
printf(“%d”, i);
}
}
• Here, the comparison as well as the incrementation
is done through the same statement, i++ < 10.
 Nested for Loop
Program Example:
#include<stdio.h> output:
main()R=1 c=1 sum =2
{ R=1 c=2 sum =3
int r,c,sum; R=2 c=1 sum =3
for (r =1; r<=3; r++) R=2 c=1 sum =4
{ R=3 c=1 sum =4
for (c=1; c<=2; c++) R=3 c=2 sum =5
{
sum = r + c;
printf(“r=%d c=%d sum=%d”, r, c, sum);
}
}
}
• Multiple initialisations in the for loop

for( i=1, j=2; j<=10; j++)

The Odd Loop :
/* Execution of a loop an unknown number of times*/
#include <stdio.h>
main()
{
char another =’y’;
int num;
while(another == ‘y’)
{
printf(”Enter a number”);
scanf(“%d”, &num;
printf(“Square of %d is %d“, num , num * num);
printf(”Do you want to enter another number y/n”);
scanf(“%c”, &another);
}
}
• In this program the while loop would keep getting executing till the user
continuous to answer y.
 The break Statement
• We want to jump out of a loop instantly, without
waiting to get back to the conditional test. The
keyword break allows us to do this.

• A break is usually associated with an if.

main()
{
int i=1, j=1;
while(i++<=100)
{
while(j++<=200)
{
if(j==150)
break;
else
printf(“%d\n %d\n",i,j);
}
}
}
• In this program when j equals 150, break takes the control outside the
inner while only, since it is placed inside the inner while.
 The continue Statement
• In some programming situations we want to take
the control to the beginning of the loop, bypassing
the statements inside the loop which have not yet
been executed.

• A continue is usually associated with an if.

main() output:
{ 1 2
int i, j; 2 1
for (i =1; i<=2; i++)
{
for (j =1; j<=2; j++)
{
if(i==j)
continue;
printf(“%d%d”, i,j);
}
}
}
when the value of i equals that of j, the continue statement takes the
control to the for loop(inner) bypassing rest of the statements pending
ececution in the for loop(inner)
 The switch Multiple-Selection Structure
• switch
– Useful when variable or expression is tested for multiple
values
– Consists of a series of case labels and an optional default
case
– break is (almost always) necessary
switch ( integer expression )
{
case constant1 :
statement(s)
break ;
case constant2 :
statement(s)
break ;
...
default :
statement(s)
break ;
}
• The last statement of each case in the switch should
almost always be a break.
• The break causes program control to jump to the
closing brace of the switch structure.
• Without the break, the code flows into the next
case. This is almost never what you want.
• A switch statement will compile without a default
case, but always consider using one.
switch ( day )
{
case 0: printf (“Sunday\n”) ;
break ;
case 1: printf (“Monday\n”) ;
break ;
case 2: printf (“Tuesday\n”) ;
break ;
case 3: printf (“Wednesday\n”) ;
break ;
case 4: printf (“Thursday\n”) ;
break ;
case 5: printf (“Friday\n”) ;
break ;
case 6: printf (“Saturday\n”) ;
break ;
default: printf (“Error -- invalid day.\n”) ;
break ;
}
/* This program associates a letter grade with a
message appropriate to the score. */
#include <stdio.h>
int main ( )
{
char grade ;
printf ("Enter your current letter grade\n") ;
grade = getchar ( ) ;
switch (grade)
{
case ('a') :
case ('A') :
printf ("Good Job!\n") ;

case ('b') :
case ('B') :
printf ("Pretty good.\n") ;
case ('c') :
case ('C') :
printf ("Better get to work.\n") ;
case ('d') :
case ('D') :
printf ("You are in trouble.\n") ;
default :
printf ("You are failing!!\n") ;
} /* End of switch-case structure */
} /* End of main program
/* The following results are produced when the user
enters an "A" as input to the program prompt. */

Good Job!
Pretty good.
Better get to work.
You are in trouble.
You are failing!
• The problems with the previous program can be
corrected by use of the break statement.
• It can be used in either a repetition structure or a
selection structure to break out of (that is, to exit
from) the structure.
• The syntax is:
break ;
• The following program is the previous one with the
addition of the break statements.
#include <stdio.h>
main ( )
{
int i=2;
switch(i)
{
case 1:
printf(“I am in case 1”);
break;
case 2:
printf(“I am in case 2”);
break;
case 3:
printf(“I am in case 3”);
break;
default:
printf(“I am in default”);
}
}
Output : I am in case 2
 Functions
What is a Function?
•Function is a self contained block of statements that
perform a coherent task of some kind.
•Every C program can be a thought of the collection of
functions.
• main( ) is also a function.
• Any c program contains at least one function.
• If a program contains only one function, it must be
main().
• There is no limit on the number of functions that might be
present in a c program.
• Each function in a program is called in the sequence
specified by the function call in main().
 Types of Functions
• Library functions.
• These are the in -built functions of ‘C’ library.
• These are already defined in header files.
e.g. printf( ); is a function which is used to print at
output. It is defined in ‘stdio.h’ file .
•User defined functions.
• Programmer can create their own function in C to
perform specific task.
 User defined functions
#include<stdio.h>
main()
{
message();
printf(“cry, and you stop the monotony”);
}
message()
{
printf(“smile, and the world smiles with you”);
}
Output: smile, and the world smiles with you
cry, and you stop the monotony
 Declaration of many functions
main( )
{ engg()
printf(“I am in main”); {
poly( ); printf( “I am in engineering ”);
engg( ); }
agri( ); agri()
} {
poly( ) printf( “I am inagri ”);
{ }
printf(“I am in polytechnic”);
}
main()
{
printf(“I am in main”);
italy();
printf(“ iam finally back in main”); output:
} I am In main
Italy() I am in italy
{ I am in brazil
printf(“I am in italy”); I am in argentina
brazil(); I am back in italy
printf(“I am back in italy”); iam finally back in main
}
brazil()
{
printf(“I am in brazil”);
argentina();
}
argentina()
{
printf(“I am in argentina ”);
}
 Summarization
• C Program is a collection of one or more functions.
• A function gets called when its name is followed by a
semicolon.
e.g. main( )
{
fun( );
}
fun( )
{
Statement1; statement2; statement3;
}
• A function is defined when function name is
followed by a pair of braces in which one or more
statements present.

fun( )
{
statement1;
statement2;
statement3;
}
• Any function can be called by any other function.
main( )
{
printf(“II am in main”);
fun( );
}
fun( )
{
Printf(“I am in fun”);
main( );
}
This will run in infinity.
A function can be called by number of times.
e.g.
main( )
{
printf(“I am in main”);
fun( );
fun( );
fun( );
}
fun( )
{
printf(“I am in fun”);
}
A function can call itself, it is called as a ‘‘recursion”
e.g.
main ( )
{
printf(“I am in main”);
main( );
}
• A function can be called from another function but
can not be defined in another function. It should be
defined outside of the main.
• The order in which the functions are defined in a program and the
order in which they get called need not necessarily be same.
main()
{
message1();
message2();
}
message2()
{
printf(“smile, and the world smiles with you”);
}
message1();
{
printf(“cry, and you stop the monotony”);
}
 Why use functions?
• Writing functions avoids rewriting of the same code
again and again in the program.
• Using a function it becomes easier to write program
to keep track of what they are doing.
 Passing values between functions
The values that we pass to the function called as function arguments.
e.g.
main( )
{
int i=10, j=12, k=20;
calsum(i,j,k);
}

calsum(int x, int y, int z)

{
Printf(“Sum is : % d”, (x+y+z));
}
Output: 42
i, j, k are actual arguments
x, y, z are formal arguments
 Returning a value
• The keyword ‘‘return’’ to used to return value from function which is present
in the parenthesis of return.
• executing return statement it immediately transfers control back to the main
program.
main( ) {
int a = 30, j = 14;
int k;
k =addin(a, j);
Printf(“%d”, k);
}
int addin(int x, int y) output: 45
{
int z;
z = (x + y) +1;
return(z);
}
• There is no restriction on the number of return statements that may be
present in a function.
• Also, the return statement need not always be present at the end of the
called function.
Ex:
fun()
{
char ch;
printf(“enter any alphabet”);
scanf(“%c”,&ch);
if(ch>=65 && ch<=90)
return (ch);
else
return (ch+32);
}
• In this function different return statements will be executed depending on
whether ch is capital or not.
• Whenever the control returns from the function some
value is definitely returned. It should be accepted in the
calling program.
e.g. int sum;
sum = calsum(a,b,c);
here the value returned by calsum must be of type int.
Some valid return statements.
return a; /*a is a variable name */
return (23);
return (15.32);
return (‘‘v’’);
return;
• If you are not returning any value from a function they it should
be declared as void. (void is a keyword).
e.g. void display( ) display is not returning any value.
• A function can return only one value at a time. Thus,
the following statements are invalid.
return(a,b);
return(x,12);

• Any C function by default returns an integer value.

More specifically, whenever a call is made to a
function, the compiler assumes that this function
would return value of type int.
 Declaring Functions
• Requires prototype & function itself
a. Prototype (before function itself)
– Tells compiler
1. number & type of arguments passed in
2. Type of value returned
E.g.,
int maximum (int, int);
or
int maximum (int a, int b);
/* a & b are ignored by the compiler */
• Function itself
Format: type function_name (parameter list);
Parameter list –> type and name
Must return a value of specified type unless
type is void.
Must be declared before it is used
• Function call
Must include appropriate arguments
#include <stdio.h>
int maximum (int, int); Function prototype.
int maximum (int a, int b)
{
if (a > b)
return a;
else
return b;
}
void main () {
int x, y, z;
printf (“Enter 2 intergers: “);
scanf (“%d %d”, &x, &y);
z = maximum(x,y);
printf(“\nThe maximum is %d\n”,z);
}
 Call by value and call by Reference
An introduction to Pointers:
Ex: int i = 3;
This declaration tells the c compiler to:
1. Reserve space in memory to hold the integer value.
2. Associate the name I with this memory location.
3. Store the value 3 at this location.
i location name
value at location
3

6485 location number

• The computer has selected memory location 6485 as the
place to store the value 3. the location number 6485 is
not fixed for value 3.
We can print this address number through the following
program:
main()
{
int i = 3;
Printf(“address of i=%u”, &i);
printf(“value of i= %d”, i);
}

Output: address of i = 6485

value of i = 3;
‘&’ used in this statement is C’s ‘address of’ operator. The
expression &i returns the address of the variable i.
• The other pointer operator available in C is ‘*’ called
‘value at address’ operator. It gives the value stored at a
particular address.
• The ‘value at address’ operator is also called
‘indirection’ operator.
Ex: main() {
int i=3;
Printf(“address of i=%u”, &i);
printf(“value of i= %d”, i);
printf(“value of i= %d”,*(& i)); }
Output: address of i = 6485
value of i = 3;
value of i = 3;
• the printing the value of *(&i) is same as printing
the value of i.
• the expression &i gives the address of the variable i.
this address can be collected in a variable, by
saying,
j=&i;
• j is not an ordinary variable like any other integer
variable. It is a variable which contains the address
of other variable.
i j (j value is i‘s address)
3 6485

6485 3276
Ex: main()
{
int i=3; output:
int *j; address of i = 6485
j=&i; address of i = 6485
printf(“address of i=%u”, &i); address of j = 3276
printf(“address of i=%u”, j); value of j = 6485
printf(“address of j=%u”, &j); value of i = 3
printf(“value of j= %u”, j); value of i = 3
printf(“value of i= %d”, i); value of i = 3
printf(“value of i= %d”, *(&i));
printf(“value of i= %d”, *j);
}
Back to Function calls
• Arguments can generally be passed to function in
one of the two ways:
1. sending the values of the arguments
2. sending the addresses of the arguments
• In the first method the value of each of actual
arguments in the calling function is copied into
corresponding formal arguments of the called
function.
• With this method the changes made to the formal
arguments in the called function have no effect on
the values of actual arguments in the calling
function
/* interchange the values */
main()
{
int x=50, y=70;
interchange(x,y);
printf(“x=%d y=%d”,x,y);
}

interchange(x1,y1) output:
int x1,y1; x1 = 70 y1= 50
{ x = 50 y =70
int z1;
z1=x1;
x1=y1;
y1=z1;
printf(“x1=%d y1=%d”,x1,y1);
}
• In second method (call by reference) the address of
actual arguments in the calling function are copied
into formal arguments of the called function.
• This means that using these addresses we would
have an access to the actual arguments and here we
would be able to manipulate them.
main()
{
int x=50, y=70;
interchange(&x,&y);
printf(“x=%d y=%d”,x,y);
}
output:
interchange(x1,y1) *x=70 *y=50
int *x1,*y1; x=70 y=50
{
int z1;
z1=*x1;
*x1=*y1;
*y1=z1;
printf(“*x=%d *y=%d”,x1,y1);
}
 Recursion
• A function is called ‘recursive’ if a statement with in the body of a
function calls the same function.
• Sometimes called circular definition, recursion is thus the process of
defining something in terms of itself.
• int fact(int n) { output :
int x,y; Enter the integer whose factorial value you want
if(n==0) 3
return 1;
x=n-1; The factorial value is 6
y=fact(x);
return n*y; }

void main() {
int x;
printf(“\nEnter the integer whose factorial value you want “);
scanf(“%d”,&x);
printf(“\nThe factorial value is:-%d”,fact(x)); }