Beruflich Dokumente
Kultur Dokumente
C Language Introduction
Languages :
A set of statements is called a language.There are four types of languages according to their time.
I generation languages:
These languages are machine languages. To write programs in these languages the system technology
must be required. The data is Non-portable. That means a program written in a system does not work in another
systems.
II Generation Languages :
These are Assembly Languages. These are also system oriented that means to write any program in a
system that system’s technology must be required and data is non-portable. But they used MNEMONIC words in
programs. That means they used a single word instead of more words.
III Generation Languages :
In these languages programs are witten in general English language.There is no need to know the system
technology and the data can be transfered anywhere.
IV Generation languages :
These languages are defined in any one of the above languages.These are also called packages.
Here I & II Generation languages are called Low Level Languages and III & IV generation languages are called
High Level Languages.
For high level languages we have to use translaters to translate the source code written in general english language
into machine language. These translaters are two types.
1) Interpreters.
2) Compilers.
Interpreters :
These translators translate the source code step by step into machine language until any error. If there is
any error it stops and shows some message. After correction it can continue.
Ex: BASIC, DBase III+, ....
Compilers :
These translators translate the entire source code into machine language when it is error-free and creates
an object file in machine language. If there is any error it shows the list of error. After debugging it
creates the object file.
Ex: COBOL, C, C++, ...
2|Page
C LANGUAGE
The language ‘C’ was designed by Dennis Ritchie at AT & T Bell Laboratories. The standardised C was
released in 1979.
Character Set :
Constants : The unchangeable quantities are called Constants.The constants are generally two types.
1) Character constants :
a) Characters Ex: ‘a’, ‘5’, ‘+’, ‘ ‘, ...
b) Strings Ex: “abc”, “435”, ‘rama”, ...
2) Numeric Constants :
a) integers Ex: 435, -657, 65535, -32768,...
b) Real numbers
i) Fractional form Ex: 435.67, 345.00054, ...
ii) Exponential form Ex: 0.02e3, 1.17e-38, ...
Variables : The quantities which can be changed during the execution of program are called Variables. A variable
can be considered as the name of the cell which can hold the constants. To use any variable it must be declared
with its data type before the first executable statement and they can be initialised. Naming the variable is very
important.
1) The variable name must start with either alphabet or an underscore and may contain alphabet, digits,
hyphen or underscore.
2) The maximum length of a variable is 8 characters. But some compilers can accept upto 32 characters.
3) There must not be any blank spaces or special symbols in a variable name.
4) A variable name must not be a keyword.
Ex: valid invlid
eno emp name
empname emp(name
emp-name 45abc
3|Page
Keywords : These are predefined words. There are 32 keywords in C language. These keywords can not be used
as user-defined variables.
Operators : There are 42 operators in C language.
1) Arithmetic Operators : + - * / %
Ex: 100 + 40 ==> 140\
100 - 40 ==> 60
100 * 40 ==> 4000
100 / 40 ==> 2
100 % 40 ==> 20
40 % 100 ==> 40
2) Assigning Operators : =
(variable) = (constant) / (variable) / (expression) ;
Ex: a=5
b=a
c = a + b -2
3) Multiple operators : += -= *= /= %=
Ex: a = a + 3 ==> a += 3
a = a - 3 ==> a -= 3
a = a * 3 ==> a *= 3
a = a / 3 ==> a /= 3
a = a % 3 ==> a %= 3
4) Unary Operators : ++ --
Ex : a = a + 1 ==> a += 1 ==> a ++ ==> ++ a
a = a - 1 ==> a -= 1 ==> a -- ==> -- a
4|Page
The ‘C’ program has a free formated structure.
Every statement must be terminated with a semicolon ;
A program is a collection of functions. There may be a lot of functions but at least one function must be there
that is main(), where the execution starts.
C has case sensitivity. All the keywords are defined in lower case.
So better to write entire program in lower case.
Preprocessor commands :
The commands which start with a hash(#) symbol are called Preprocessor commands.
Ex : # include <stdio.h>
# include “conio.h”
# define PI 3.14159
Global declarations :
To use any variable it must be declared with its data type before the first executable statement. The
variables which declared in a block are available in that block only.
To use the variable in the entire program with same effect it must be declared as global.
Data Types :
Type Range occupied bytes format string
signed char -128 to 127 1 %c
unsigned char 0 to 255 1 %c
5|Page
Syntax : clrscr();
2) printf() :-
This function is used to display the text and the values of variables. This function’s prototype has defined
in the header file STDIO.H To display the variable’s value the format string must be used.
( STDIO ==> Standard Input Output )
Syntax : printf(“ format string “, variables) ;
Ex : printf(“ Hello \t World “);
printf(“ %d %c”, k, j);
printf(“The marks are %d, %d, %d”, m1, m2, m3 );
Note : The function printf() returns an integer value that is the number of arguments given to the statement.
Remarks :
To write any remarks or comments to the statements they must be enclosed with the symbols /* */
Ex : /*
sdfjkshadjfsdjkafkjsadjkfhkasdj
sdafhasdfhgasdhfgasdgfgasdfhasdfj
sdafjksadfjasdkhfjasdhkfjhksda
*/
Ex Programs :
1) /* My First ‘C’ Program */
# include <stdio.h>
# include <conio.h>
main()
{
clrscr() ;
printf(“Hello” );
printf(“CMC “) ;
printf(“Welcome “) ;
}
/*
Save this program (F2) as FIRST.C
After compilation(Alt-F9) it creates an object file, and an executable
file which can be executed at MS-DOS prompt.
By saving a modified file it creates a backup file.
FIRST.C
FIRST.BAK
FIRST.OBJ
FIRST.EXE
Output :
Hello CMC Welcome
*/
6|Page
TURBO C editor :
It is a compiler of C program and it can be also used as a general editor. To enter into editor first change into
the directory which contains the software and enter the command TC at the command prompt.
C:\> CD TC
C:\TC> tc
Then it opens the editor which contains a menu bar at the top, a status bar at the bottom and a main window to
write the programming statements and a sub window which shows the messages.
The menu bar contains some menu pads and they can be selected by pressing ALT and the highlighted character
in the required menu pad.
Then it shows the submenu which contains some bars and they can be selected using arrow keys.
The status bar shows online help and the keys information.
1) To write a new program select ‘New’ command from “File” menu.
2) To save the working program select ‘Save’ command from “File” menu
or press F2 and enter a name.
3) To compile the program select ‘Compile to OBJ’ command from “compile” menu or press Alt + F9.
Then it shows the list of errors or warnings. If the program is error-free then the compiler creates an
object file (.OBJ) and an executable file (.EXE).
4) To execute the program select ‘Run’ command from “Run” menu or press Ctrl + F9.
5) To see the output of the execution select ‘User Screen’ command from “Run” menu or press Alt + F5.
6) To close the editor select ‘Quit’ command from “File” menu or press Alt + X.
Escape Sequences :
Ex Programs :
2) /* Using Escape Sequences */
# include <stdio.h>
# include <conio.h>
main()
{
clrscr() ;
printf(“Hello \t “) ;
printf(“Jagdish \n”) ;
printf(“Welcome “) ;
}
7|Page
/* Output :
Hello Jagdish
Welcome
*/
3)
# include <stdio.h>
# include <conio.h>
main()
{
clrscr() ;
printf(“Hello \t JAgdish \n Welcome “) ;
}
/* Output :
Hello Jagdish
Welcome
*/
4)
/* Using Variables */
# include <stdio.h>
# include <conio.h>
main()
{
int k = 65 ;
char j = ‘*’ ;
clrscr() ;
printf(“\n The value of k is %i %d %c %o %x”, k, k, k, k, k ) ;
printf(“\n The value of j is %i %d %c %o %x”, j, j, j, j, j ) ;
}
/* Output :
The value of k is 65 65 A 101 42
The value of j is 42 42 * 52 2a */
# include <stdio.h>
# include <conio.h>
main()
{
int a, b, c ;
8|Page
clrscr() ;
a = 6 ; b = 23456; c = 678 ;
printf(“\n %05d \t %d”, a, a ) ;
printf(“\n %05d \t %d”, b, b ) ;
printf(“\n %5d \t %d”, c, c ) ;
}
/* Output :
000066
2345623456
678 678
*/
6) /* Arithmetic Operations */
# include <stdio.h>
# include <conio.h>
main()
{
int a, b, c, d, e, f ;
clrscr() ;
a = 100 ; b = 40 ;
c=a+b;
d=a-b;
e=a*b;
f=a/b;
printf(“The given values are %d, %d”, a, b ) ;
printf(“\n The addition is %d”, c) ;
printf(“\n The subtraction %d”, d) ;
printf(“\n The product is %d”, e) ;
printf(“\n The division %d”, f) ;
printf(“\n The reminder is %d”, a%b) ;
}
/* Output :
*/
9|Page
Notes : The Arithmetic operations are three types depending on the types of the operands in the expression.
Ex Programs :
7) /* Type casting */
# include <stdio.h>
# include <conio.h>
main()
{
int m1, m2, m3, tot;
float avg ;
clrscr() ;
m1 = 65; m2 = 66; m3 = 68;
tot = m1 + m2 + m3 ;
/*avg = tot / 3.0 ;*/
avg = (float) tot / 3 ;
printf(“The three subjects marks are %d, %d, %d”, m1, m2, m3 ) ;
printf(“\n The total %d \t Average %f”, tot, avg ) ;
}
/* Output :
The three subjects marks are 65, 66, 68
The total 199 Average 66.33 */
# include <stdio.h>
# include <conio.h>
main()
{
float bas, da, hra, pf, net ;
clrscr() ;
bas = 5000;
da = bas * 20 / 100 ;
hra = bas * 30 / 100 ;
pf = bas * 5 / 100 ;
net = bas + da + hra - pf ;
10 | P a g e
printf(“The Basic Salary %f”, bas) ;
printf(“\n Da %.1f \t Hra %010.3f \t Pf %5.0f”, da, hra, pf) ;
printf(“\n Net Salary %10.2f”, net) ;
}
/* Output :
*/
# include <stdio.h>
# include <conio.h>
main()
{
int k = 5 ;
clrscr() ; Output
printf(“\n %d”, k) ; 5
k ++ ;
printf(“\n %d”, ++k) ; 7
printf(“\n %d”, k++); 7
printf(“\n %d”, k) ; 8
k -- ;
printf(“\n %d”, k--) ; 7
printf(“\n %d”, --k) ; 5
k = ++k + ++k + ++k ;
printf(“\n %d”, k) ; 24
k=5;
k = k++ + ++k + ++k + k++ + k++ ;
printf(“\n %d”, k) ; 38
getch() ;
}
Note :
scanf() :
This function is used to accept the values for the variables while executing the program from keyboard.
This function’s prototype has defined in the header file STDIO.H
printf():
The function printf() returns an integer value that is the number of arguments given to the statement.
11 | P a g e
Syntax:
scanf(“formatstring” , &(variables) );
Note :
To accept two or more values with a single scanf() they can be separated by space or tab or enter key.
Ex :
i) int a;
scanf(“%d”, &a);
ii) int m1, m2, m3;
scanf(“%d%d%d”, &m1, &m2, &m3);
iii) char ch;
scanf(“%c”, &ch);
getch() :
This function is used to accept a single character for the variable while executing the program. But this
function does not display the entered character. This function’s prototype has defined in the header file
CONIO.H
Note : To see the entered character the function getche() can be Used.
Syntax:
(variable) = getch() ;
Ex :
char c;
c = getch();
Ex Programs :
# include <stdio.h>
# include <conio.h>
main()
{
char k ;
clrscr();
12 | P a g e
/* Output :
Enter any character abcdef
You entered the chracter a
10) /* Write a program to calculate the total, average of a student’s three subjects marks */
# include <stdio.h>
# include <conio.h>
main()
{
int m1, m2, m3, tot;
float avg ;
clrscr() ;
printf(“Enter three subjects marks \n”) ;
scanf(“%d%d%d”, &m1, &m2, &m3 ) ;
tot = m1 + m2 + m3 ;
/* avg = tot / 3.0 ; */
avg = (float) tot / 3 ;
printf(“The three subjects marks are %d, %d, %d”, m1, m2, m3 ) ; printf(“\n The total %d \t Average
%f”, tot, avg ) ;
}
/* Output :
Enter three subjects marks
65 66 68
11) /* Write a program to accept an employee’s basic salary, calculate da, hra, pf, net salary and print all
*/
Notes :
Conditional Statements :
In C language the conditional statement returns zero when the condition is false. Otherwise it returns a
non-zero(1) value when the condition is true.
13 | P a g e
Ex Program :
12)
# include <stdio.h>
# include <conio.h>
main()
{ output
int k = 5 ;
clrscr() ;
printf(“\n %d”, k ); 5
printf(“\n %d”, k<10) ; 1
printf(“\n %d”, k>10) ; 0
printf(“\n %d”, k+(k==5) ); 6
printf(“\n %d”, k=10) ; 10
getch() ;
}
Notes :
There are three types of conditional statements in ‘C’.
1) if
2) switch
3) conditional operators
1) if ... else :
Syntax :
if (condition) if (condition)
{ {
(statements); (statements);
} }
else
{
(statements) ;
}
Ex Program :
13)/* Write a program to check whether the given number is zero or not */
# include <stdio.h>
# include <conio.h>
main()
{
int k;
clrscr() ;
printf(“Enter any number “) ;
14 | P a g e
scanf(“%d”, &k) ;
getch() ;
}
# include <stdio.h>
# include <conio.h>
main()
{
int k ;
clrscr() ;
15) /* Write a program to find the big number in the given two numbers */
# include <stdio.h>
# include <conio.h>
main()
{
int a, b ;
clrscr() ;
15 | P a g e
else printf(“%d”, b) ;
}
getch() ;
}
16) /* Write a program to find the biggest number in the given three numbers */
# include <stdio.h>
# include <conio.h>
main()
{
int a, b, c ;
clrscr() ;
17) /* Write a program to find the smallest number in the given five numbers */
# include <stdio.h>
# include <conio.h>
main() {
int a, b, c, d, e, t ;
clrscr() ;
16 | P a g e
else
{
t=a;
if(t>b) t = b;
if(t>c) t = c ;
if(t>d) t = d ;
if(t>e) t = e ;
printf(“\n The biggest is %d”, t) ;
}
getch( );
}
18) /* Write a program to find the biggest and smallest numbers in the given five numbers */
# include <stdio.h>
# include <conio.h>
main()
{
int a, b, c, d, e, x, y ;
clrscr() ;
19) /* Write a program to accept three subjects marks of a student, calculate total, average find the result,
division and print all details */
17 | P a g e
# include <stdio.h>
# include <conio.h>
main()
{
int m1, m2, m3, tot ;
float avg ;
clrscr() ;
20) /* Write a program to accept an employee’s basic salary, calculate da, hra, pf, net salary using the
following conditions and print all details
Notes :
switch... case :
Syntax:
switch(variable)
{
case (value) : (statements) ;
case (value) : (statements) ;
default : (statements) ;
18 | P a g e
}
break :
This keyword stops the execution in the given block and come out. Generally this is used in switch..case
statements and looping Statements.
Ex Programs :
21)
# include <stdio.h>
# include <conio.h>
main()
{
int k ;
clrscr() ;
switch(k)
{
case 0 : printf(“\n Number is zero “ );
case 1 :
case 2 :
case 3 :
case 4 : printf(“\n Number is less than five “) ;
break ;
case 5 : printf(“\n Number is five “ );
break ;
default : printf(“\n Number is greater than five “) ;
}
getch() ;
}
22)
# include <stdio.h>
# include <conio.h>
main()
{
char k;
19 | P a g e
clrscr() ;
getch() ;
}
23)
# include <stdio.h>
# include <conio.h>
main()
{
int a, b, k ;
clrscr() ;
20 | P a g e
}
Notes :
Conditional Expressions : ( ? : ; )
Syntax :
(condition) ? (statement1) : (statement2) ;
Ex Programs :
24) /* Write a program to check whether the given number is zero or not */
# include <stdio.h>
# include <conio.h>
main()
{
int k;
clrscr() ;
25) /* Write a program to find the biggest number in the given three numbers */
# include <stdio.h>
# include <conio.h>
main()
{
int a, b, c, t ;
clrscr() ;
Notes :
gotoxy() :
This function locates the cursor position to the given place on the screen. This function’s prototype has
defined in the header file CONIO.H
Syntax: gotoxy(column, row) ;
Generally in MS-DOS mode the screen contains 80 columns and 25 rows.
21 | P a g e
Ex Programs :
26)
# include <stdio.h>
# include <conio.h>
main()
{
clrscr() ;
gotoxy(20, 3) ;
printf(“Hello “);
gotoxy(70, 5);
printf(“Jagdish “) ;
gotoxy(35,12);
printf(“Welcome “);
gotoxy(50,20);
printf(“To smile “);
getch() ;
}
Notes :
goto : This command changes the execution control to the given statement.
Syntax: goto (label) ;
(label) :
(statements) ;
Ex Programs :
27)
# include <stdio.h>
# include <conio.h>
main()
{
clrscr() ;
printf(“Hello “) ;
printf(“World “) ;
goto abc ;
printf(“Go out “) ;
xyz :
printf(“To smile “) ;
goto end ;
abc :
printf(“Welcome “) ;
goto xyz ;
end :
getch() ;
}
22 | P a g e
/* Output :
Hello World Welcome To smile */
Note :
Looping Statements : Repeating a block of statements number of times is called Looping. There are three types
of looping statements defined in C language.
1) do..while
2) while
3) for.
Note : The keyword ‘goto’ cn be also used to repeat a block of statements number of times.
Ex Programs :
28)
# include <stdio.h>
main()
{
abc :
printf(“Welcome “) ;
goto abc ;
}
k=1;
abc :
printf(“%d “, k) ;
k++ ;
if(k<=10) goto abc ;
getch() ;
}
Notes :
do ... while() :
Syntax : Do
23 | P a g e
{
(statements);
} while(condition) ;
Ex Programs :
30) /* Write a program to display the first 10 natural numbers */
# include <stdio.h>
# include <conio.h>
main()
{
int k ;
clrscr() ;
k=1;
do
{
printf(“%d “, k) ;
k++ ;
}while(k<=10) ;
getch() ;
}
31) /* Write a program to display the even numbers upto the given number and find the sum of them
*/
# include <stdio.h>
# include <conio.h>
main()
{
int k, n, s ;
clrscr() ;
24 | P a g e
getch() ;
}
Notes : There is a draw-back in do.. while() staement. It executes the conditional statement after executing the
statement.
while() :
Syntax: while(condition)
{
(statements);
}
Ex Programs :
32) /* Write a program to display the first 10 natural numbers */
# include <stdio.h>
# include <conio.h>
main()
{
int k ;
clrscr() ;
k=1;
while(k<=10)
{
printf(“%d “, k) ;
k++ ;
}
getch() ;
}
33)/* Write a program to display the even numbers upto the given number and find the sum of them */
# include <stdio.h>
# include <conio.h>
main()
{
int k, n, s ;
clrscr() ;
25 | P a g e
while (k<=10)
{
printf(“%d “, k) ;
s += k ;
k += 2 ;
}
34) /* Write a program to check whether the given number is Prime or not
Prime Number : A number which is divisible by 1 and itself. */
/* I method */
# include <stdio.h>
# include <conio.h>
main()
{
int n, k, s;
clrscr() ;
k = 1; s = 0;
while(k<=n)
{
if(n%k==0) s++;
k++ ;
}
if(s==2) printf(“\n Number is Prime “ );
else printf(“\n Number is not a Prime “)
getch( );
}
/* II method */
# include <stdio.h>
# include <conio.h>
main()
{
int n, k, s;
clrscr() ;
26 | P a g e
printf(“Enter any number “) ;
scanf(“%d”, &n) ;
k = 2; s = 0;
while(k<=n/2)
{
if(n%k==0) { s++; break ; }
k++ ;
}
if(s==0) printf(“\n Number is Prime “ );
else printf(“\n Number is not a Prime “)
getch( );
}
35) /* Write a program to find the number of digits, sum of digits, and reverse order of the given number
*/
# include <stdio.h>
# include <conio.h>
main()
{
long int a, b ;
int n, s, r ;
clrscr( );
printf(“Enter any big number “ ); scanf(“%ld”, &a) ;
n = 0; s = 0; b = 0;
while(a>0)
{
n ++ ;
r = a % 10 ;
s += r ;
b = (b*10) + r ;
a /= 10 ;
}
36) /* Write a program to check whether the given number is Armstrong or not
Armstrong Number : A number which is equal to the sum of the cubes of the digits is called Armstrong Number.
27 | P a g e
Ex: 1, 153, 370, 371, 407 */
# include <stdio.h>
# include <conio.h>
# include <math.h>
main()
{
int a, b, r, s ;
clrscr() ;
b = a ; s = 0;
while(a>0)
{
r = a % 10 ;
s = pow(r, 3); /* s += r * r * r ; */
a /= 10;
}
Notes :
for() :
Ex Programs :
37) /* Write a program to display the odd numbers upto the given number */
# include <stdio.h>
# include <conio.h>
main()
{
int n, a ;
clrscr() ;
28 | P a g e
/* n=1;
for ( ; a>=n ; )
{
printf(“%d “, n);
n += 2 ;
}
*/
getch() ;
}
38) /* Write a program to display the even numbers upto the given number and find the sum of them */
# include <stdio.h>
# include <conio.h>
main()
{
int a, n, s ;
clrscr() ;
printf(“Enter any number “) ;
scanf(“%d”, &a) ;
/* n=2;s=0;
for( ; n<=a ; )
{
printf(“%d “, n) ;
s += n ;
n += 2 ;
}
*/
/*
s=0;
for(n=2; n<=a; n+=2)
{
printf(“%d “ , n );
s += n;
}
*/
for(n=2, s=0 ; n<=a ; s+=n, n+=2 )
printf(“%d “, n) ;
printf(“\n The sum is %d”, s) ;
getch() ;
}
39)/* Write a program to find the sum of natural numbers, even numbers, odd numbers upto the given number
*/
29 | P a g e
# include <stdio.h>
# include <conio.h>
main()
{
int a, n, s, odd, even ;
clrscr() ;
40) /* Write a program to find the factorial value of the given number n! = n * (n-1) ! */
# include <stdio.h>
# include <conio.h>
main()
{
long int a, f ;
clrscr() ;
/* f=1;
for( ; a>1 ;)
{
f *= a ;
a -- ;
}
*/
41) /* Write a program to display the multiplication table of the given number using all types of loopings. */
# include <stdio.h>
# include <conio.h>
30 | P a g e
main()
{
int n, k;
clrscr() ;
getch() ;
}
# include <stdio.h>
# include <conio.h>
main()
{
int k ;
clrscr() ;
/* k=0;
do
{
printf(“\t %d %c”, k, k) ;
k ++ ;
if(k%50==0) getch() ;
} while(k<=255 ) ;
31 | P a g e
*/
/* k=0;
while(k<=255)
{
printf(“\t %d %c”, k, k) ;
k ++ ;
if(k%50==0) getch() ;
}
*/
for(k=0; k<=255; k++)
{
printf(“\t %d %c”, k, k) ;
if(k%50==0) getch() ;
}
getch() ;
}
43)/* Write a program to display the multiplication table of the given number using all types of Loopings. */
Notes :
Nested Loops :
Looping in a loop is called Nesting of Loops.
Ex Programs :
44)
# include <stdio.h>
# include <conio.h>
main()
{
int n, k, j ;
clrscr() ;
/* output :
Enter any number 5
1
12
32 | P a g e
123
1234
12345
*/
45)
# include <stdio.h>
# include <conio.h>
main()
{
int n, k, j ;
clrscr() ;
/* output :
46)
# include <stdio.h>
# include <conio.h>
main()
{
int n, k, j ;
clrscr() ;
33 | P a g e
printf(“ “) ;
for(j=1; j<=k; j++)
printf(“%d “, j) ;
}
getch() ;
}
/* output :
47)
# include <stdio.h>
# include <conio.h>
main()
{
int n,j,k,a;
clrscr();
/* Output :
Enter any number 5
ABCDEDCBA
ABCD DCBA
ABC CBA
AB BA
A A */
34 | P a g e
48) /* Write a program to display the multiplication tables upto the given number */
# include <stdio.h>
# include <conio.h>
main()
{
int a, n, k ;
clrscr() ;
49)/* Write a program to display the list of Prime numbers upto the given number */
# include <conio.h>
# include <stdio.h>
main()
{
int a, n, k, s ;
clrscr() ;
getch() ;
}
50)/* Write a program to display the list of Armstrong Numbers upto the given number */
51)/* Write a program to display the Fibonacci Series upto the given number
Fibonacci Series : 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ....
35 | P a g e
In this series every element is the sum of its previous two numbers */
52)/* Write a program to display a box with the given character, length and width using arrays*/
/* Output :
Enter box length 10
Enter box width 5
Enter any character *
* * * * * * * * * *
* *
* *
* *
* * * * * * * * * * */
Notes :
Arrays : An array is a collection of similar data type elements. It stores the elements in contiguous locations. To
use any array it must be declared with its size and they may be initialized. The size must be a constant.
The indexing is start from 0. The arrays are two types.
1) Single Dimensional arrays,
2) Multi Dimensional Arrays.
53)/* Write a program to create a 5 cells single dimensional array, store 7 in cells and print all */
# include <conio.h>
# include <stdio.h>
main()
{
int k, a[5] ;
clrscr() ;
36 | P a g e
getch() ;
}
/* Output: 77777 */
54) /* Write a program to accept 5 numbers and print all in reverse order */
# include <conio.h>
# include <stdio.h>
main()
{
int k, a[5] ;
clrscr() ;
55)/* Write a program to accept 5 numbers print all, and find the sum of them */
# include <conio.h>
# include <stdio.h>
main()
{
int k, s, a[5] ;
clrscr() ;
56) /* Write a program to create 10 cells single dimensional array, accept 9 cells values, assign the sum of them
to the last cell and print all */
# include <conio.h>
37 | P a g e
# include <stdio.h>
main()
{
int k, a[10] ;
clrscr() ;
Notes :
Multi Dimensional Arrays :
Ex:
int a[5][3], b[4][5][6][7], .....
char na[3][20] = { “abcdefgh”, “Srikanth”, “Naag” };
A multi dimensional array is a collection of another arrays. That means a double dimensional array is a collection
of single dimensional arrays.
Ex: The array a[5][3] is a collection of 5 single dimensional arrays with size 3.
Ex Programs :
57)/* Write a program to create a 5x5 double dimensional array, store 7 in all cells and print them as a matrix*/
# include <stdio.h>
# include <conio.h>
main()
{
int k, j, a[5][5] ;
clrscr() ; output:
38 | P a g e
}
getch() ;
}
58)
main()
{
(same as above)
for(k=0; k<5; k++)
for(j=0; j<5; j++)
a[k][j] = (k==j || k+j==4) ? 7 : 0;
(same as above)
}
/* Output :
70007
07070
00700
07070
70007 */
59)
main()
{
(same as above)
for(k=0; k<5; k++)
for(j=0; j<5; j++)
a[k][j] = (k==0 || k==4 || j==0 || j==4) ? 7 : 0;
(same as above)
}
/* Output :
77777
70007
70007
70007
77777 */
60) /* Write a program to display a box with the given character, length and width using arrays */
# include <stdio.h>
# include <conio.h>
39 | P a g e
main()
{
char ch, a[25][80] ;
int k, j, len, w ;
clrscr() ;
/* Output :
* * * * * * * * * *
* *
* *
* *
* * * * * * * * * * */
61)/* Write a program to find the addition matrix of two 3x3 matrices */
# include <stdio.h>
# include <conio.h>
40 | P a g e
main()
{
int a[3][3], b[3][3], c[3][3], k, j ;
clrscr();
printf(“Enter 9 numbers for firs array \n”) ;
for(k=0; k<3; k++)
for(j=0; j<3; j++)
scanf(“%d”, &a[k][j] );
getch();
}
62) /* Write a program to find the multiplication matrix of two 3x3 matrices */
# include <stdio.h>
# include <conio.h>
main()
{
int a[3][3], b[3][3], c[3][3], k, j, t ;
clrscr();
printf(“Enter 9 numbers for firs array \n”) ;
for(k=0; k<3; k++)
for(j=0; j<3; j++)
scanf(“%d”, &a[k][j] );
41 | P a g e
for(k=0; k<3; k++)
for(j=0; j<3; j++)
scanf(“%d”, &b[k][j] );
getch();
}
42 | P a g e
Notes:
STRINGS :
A string is an array of characters. It ends with a null character. ( ‘\0’ ==> Null character )
Ex :
char na1[6] = { ‘a’, ‘b’,’c’, ‘d’, ‘e’, ‘\0’ } ;
char na2[6] = “abcde” ;
char names[][] = { “Sree”, “kanth”, “abcd” } ;
char str1[20], str2[40] ;
Note :
The format string for a string variable is %s .
Ex programs :
63)
# include <stdio.h>
# include <conio.h>
main()
{
char str[80];
clrscr();
/* Output :
Enter any string AccountsSreekanth
You entered the string AccountsSreekanth
Notes :
scanf() function can accept the string values. But it does not allow spaces in the string. To avoid this problem
gets() can be used.
gets() : This function is used to accept the value for a string variable. This function’s prototype has defined in the
header file STDIO.H.
Syntax : gets(varaible) ;
Ex :
gets(str) ;
puts() :
This function is used to display the string value of the variable. This function’s prototype has defined in the
header file STDIO.H
Syntax : puts(string) ;
Ex :
puts(“The string is “);
puts(str) ;
43 | P a g e
Ex Programs :
64)
# include <stdio.h>
# include <conio.h>
main()
{
char str[80] ;
clrscr() ;
printf(“Enter any string “) ;
gets(str) ;
printf(“ You entered “);
puts(str);
getch() ;
}
/* Output :
Enter any string AccountsSreekanth
You entered the string AccountsSreekanth
*/
65) /* Write a program to find the length of a string */
# include <stdio.h>
# include <conio.h>
main()
{
char str[80]; int k;
clrscr() ;
66)/* Write a program to change the given string into upper case*/
# include <stdio.h>
# include <conio.h>
44 | P a g e
main()
{
char str[80] ; int k ;
clrscr() ;
67)/* Write a program to change the given string into lower case*/
68)/* Write a program to change the given string into Sentence case that means the first character into upper case
and the remaining into lower case */
# include <stdio.h>
# include <conio.h>
main()
{
char str[80] ; int k ;
clrscr() ;
69) /* Write a program to change the given string into Title Case */
/* Output :
45 | P a g e
Enter any string RAGHU
In upper case Raghu */
# include <stdio.h>
# include <conio.h>
main()
{
char s[80], t[80] ;
int k;
clrscr() ;
printf(“Enter the source string to copy “) ;
gets(s) ;
k=0;
while(s[k]!=’\0’)
{
t[k] = s[k] ;
k++ ;
}
t[k] = ‘\0’ ;
printf(“\n The new string is %s”, t) ;
getch() ;
}
main()
{
char a[80], b[80] ;
int k, j ;
clrscr() ;
main()
{
char a[80], b[80] ;
46 | P a g e
int k, j ;
clrscr() ;
printf(“Enter any string “) ;
gets(a) ;
b[j] = ‘\0’ ;
printf(“\n In reverse order %s”, b) ;
getch();
}
/* Output :
Enter any string Mental
In upper case latneM */
# include <stdio.h>
# include <conio.h>
# include <string.h>
main()
{
int k, r, c, DL;
char str[80];
clrscr();
puts(“Enter your name “); gets(str);
k = strlen(str);
DL = 10000;
while(!kbhit())
{
for(r=1; r<=23; r++)
{
gotoxy(1,r); printf(“%s”, str);
delay(DL); clrscr();
}
for(c=1; c<=80-k; c+=3)
{
gotoxy(c,23); printf(“%s”, str);
delay(DL); clrscr();
}
for(r=23;r>0; r--)
{
gotoxy(80-k,r); printf(“%s”, str);
delay(DL); clrscr();
}
47 | P a g e
for(c=80-k;c>0; c-=3)
{
gotoxy(c,1); printf(“%s”, str);
delay(DL); clrscr();
}
}
}
74)/* Program to fall and replace the given name character by character */
# include <stdio.h>
# include <conio.h>
# include <string.h>
# include <dos.h>
main()
{
char na[80];
int r, c, k, n, DL;
clrscr();
}
}
48 | P a g e
75)/* Program to display the given name as a box */
# include <stdio.h>
# include <conio.h>
main()
{
char str[20], a[25][20];
int k, j, n ;
clrscr( );
getch() ;
}
/* Output :
Enter Your name Bhanodaya
B h a n o d a y a
h y
a a
n d
o
d n
a a
y h
a y a d o n a h B
*/
49 | P a g e
Notes :
STRING.H functions : To manipulate the strings the C authors designed some functions in the header file
STRING.H
1) strlen(): This function returns an integer value that is the length of the string. length means the number
of characters.
Syntax: int strlen(string) ;
2) strupr() : This function changes the given string into uppercase characters.
Syntax : strupr(string) ;
3) strlwr() : This function changes the given string into lowercase characters.
Syntax : strlwr(string) ;
4) strcpy() : This function copies the string to another string.
Syntax : strcpy(target, source) ;
5) strcat() : This function adds two strings.
Syntax : strcat(destination, second) ;
6) strrev() : This function changes the given string into reverse order.
Syntax : strrev(string) ;
7) strcmp() : This function compares two strings and returns zero when both are same.
Syntax : int strcmp(first, second) ;
Ex Programs :
77) /* Program to demonstrate the library functions of STRING.H */
# include <stdio.h>
# include <conio.h>
# include <string.h>
main()
{
char a[80], b[80] ;
clrscr() ;
printf(“Enter a string “) ;
gets(a) ;
50 | P a g e
printf(“\n The new string is %s”, b) ;
strrev(b);
printf(“\n In reverse order %s”, b) ;
printf(“\n The difference is %d”, strcmp(a,b) );
getch();
}
/* Output :
Enter a string Biskeet
The given string is Biskeet
The length of string is 6
In Upper case BISKEET
In Lower case bhanodaya
The new string is biskeet
In reverse order Bisskeet
The difference is 1
*/
51 | P a g e
FUNCTIONS
The function is a piece of code. These functions are used to reduce the repetition of coding. The functions are two
types.
1) Derived functions,
2) User-defined functions.
The derived functions are provided by the C writers and they defined them in header files. To use these functions
the header file must be included at the top of the program. We can create our own functions. To write any
function there are three steps.
1) Functions declarations,
2) Functions calling,
3) Function definition.
or
1) Function definition,
2) Function calling.
In the function declaration and/or in the definition the name must be follow the return data type, and it should
be followed by parenthesis. In the parenthesis there may be arguments with their data types. If the function does
not return any value it must be declared as void. The default return type is int.
Syntax:
(datatype) (functionname) (argumentstype) ; /* Function declaration */
functionname(arguments) ; /* Function calling */
78)
# include <stdio.h>
# include <conio.h>
void first(void) ;
void second(void) ;
void third(void)
52 | P a g e
{
printf(“\n This is in third function “) ;
}
void fourth(void)
{
printf(“\n This is in fourth function “) ;
}
void main()
{
clrscr() ;
printf(“This is in Main “) ;
first() ;
second() ;
third() ;
fourth() ;
printf(“\n This is in main again “) ;
getch() ;
}
void first(void)
{
printf(“\n This is in first function “) ;
}
void second(void)
{
printf(“\n This is in second function “) ;
}
/* Output :
This is in Main
This is in first function
This is in second function
This is in third function
This is in fourth function
This is in mainagain */
79)
# include <stdio.h>
# include <conio.h>
void replicate(void)
{
53 | P a g e
int k;
for(k=1; k<=50; k++)
printf(“*”) ;
}
void main()
{
clrscr() ;
replicate() ;
printf(“\n Hello \n”) ;
replicate() ;
printf(“\n World \n”) ;
replicate() ;
printf(“\n Welcome \n”) ;
replicate() ;
getch();
}
/* Output :
Hello
World
Welcome
*/
void main()
{
clrscr() ;
replicate(30,’*’) ;
54 | P a g e
printf(“\n Hello \n”) ;
replicate(60,’#’) ;
printf(“\n Srikanth \n”) ;
replicate(50,’%’) ;
printf(“\n Welcome \n”) ;
replicate(40,’@’) ;
getch();
}
/* Output :
Hello
Srikanth
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Welcome
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
*/
81)
# include <stdio.h>
# include <conio.h>
void main()
{
int a, b ;
clrscr() ;
55 | P a g e
getch() ;
}
void subtr(p, q)
int p, q ;
{
int r ;
r=p-q;
printf(“\n The subtraction %d” , r) ;
}
int main()
{
int a, b, c ;
clrscr() ;
56 | P a g e
printf(“Enter any two numbers \n” );
scanf(“%d%d”, &a, &b) ;
c = add(a, b) ; printf(“\n The addition is %d”, c ); printf(“\n The subtraction %d”, subtr(a,b) ) ;
c = mult(a,b) ; printf(“\n The multiplication %d”, mult(a,b) ); printf(“\n The division %d”, div(a,b) );
getch() ;
return 0;
}
83) Important :
/* Program to demonstrate all types of functions*/
# include <stdio.h>
# include <conio.h>
int main()
{
looping() ;
return 0;
}
void looping()
{
char ch = ‘y’ ;
57 | P a g e
while(ch==’y’ || ch==’Y’)
{
clrscr() ;
condition() ;
gotoxy(45, 22) ;
printf(“ Do you want to cotinue (y/n) “) ;
ch = getche ();
}
}
void condition()
{
int a, b, k;
printf(“\n Enter any two numbers \n”) ;
scanf(“%d%d”, &a, &b) ;
gotoxy(30, 5) ; printf(“1. Addition “ );
gotoxy(30, 6) ; printf(“2. Subtraction “) ;
gotoxy(30, 7) ; printf(“3. Multiplication “) ;
gotoxy(30, 8) ; printf(“4. Division “) ;
gotoxy(30, 10 );
printf(“Enter Your choice “) ;
scanf(“%d”, &k) ;
gotoxy(10, 15);
switch(k)
{
case 1 : add(a, b) ; break ;
case 2 : printf(“ The subtraction %d”, subtr(a,b) );
break ;
case 3 : mult(a,b ); break ;
case 4 : printf(“ The division %d”, div(a,b) ) ;
break;
default : printf(“ Invalid choice “) ;
}
}
58 | P a g e
}
Notes :
PREPROCESSOR COMMANDS : The commands which start with hash (#) are called Preprocessor
Commands.
Ex :
# define PI 3.14159
# include <stdio.h>
# include “conio.h”
# define A 1.7
define : This command is used to define our own constants and macros.
Ex Programs :
84)
# include <stdio.h>
# include <conio.h>
# define MN main()
# define pf printf
# define cls clrscr()
# define wait getch()
# define sf scanf
# define PI 3.14159
# define msg “Enter the radius of circle “
# define area(g) PI*g*g
# define per(g) 2*PI*g
59 | P a g e
MN
{
float r ;
cls ;
pf(msg) ;
sf(“%f”, &r) ;
pf(“\n The area of circle is %f”, area®) ; pf(“\n The perameter of circle %f”, per® ) ; wait ;
}
Notes :
include : This command is used to include the files which contains the definition of functions. There are two
types to include the files.
1) # include < name > :
This type of command includes the file which is located in the specified directory. These
specifications are set by selecting the Directories command from Options menu.
2) # include “ name “:
This type of command includes the file which is located in the current directory and/or in
the specified directory.
60 | P a g e
Ex Programs :
85)
/* Save this progam as SUB.C */
# include <stdio.h>
# include <conio.h>
61 | P a g e
Notes :
STORAGE CLAUSES :
The declared variables are generally stored in memory devices. But by using the storage clauses they can
be stored either in memory devices or in CPU registers. These storage clauses are 4 types. The variables
initialization depends on this type.
1) auto,
2) register,
3) static,
4) extern
auto : This keyword is an option. It stores the variable in memory device. It assigns a junk(garbage) value to the
variable. The variable which declared in a block that is available in that block only. The default type is auto.
Ex Programs :
86)
# include <stdio.h>
# include <conio.h>
main()
{
auto int k;
{
int k = 5 ; output :
{
auto int k = 20 ;
clrscr() ;
printf(“\n %d”, k ); 20
} 5
}
printf(“\n %d”, k ); 456
getch() ;
}
87)
# include <stdio.h>
# include <conio.h>
main()
{
int k ;
clrscr() ;
printf(“%d \n”, k) ;
62 | P a g e
for(k=1; k<=5; k++)
display() ;
getch() ;
}
display()
{
auto int k = 20 ;
printf(“ %d “ , k);
k += 3 ;
}
/* Output :
4567
20 20 20 20 20 */
Notes :
register : This keyword stores the variable in CPU registers. It assigns a junk(garbage) value to the variable. In
CPU registers it can’t store more and big values like floats, doubles,..etc. It can store Only chars and integers.
These variables are also local that means the variables which declared in a block are available in that block only.
Generally these variables are used to generate the looping statements.
Ex Programs:
88)
# include <stdio.h>
# include <conio.h>
main()
{
register int k ;
clrscr() ;
printf(“%d \n”, k );
for(k=1; k<=100; k++)
printf(“%d “, k) ;
getch() ;
}
63 | P a g e
Notes :
static : This keyword stores the variable in memory device. It initialises the variable as 0. The scope of variable
is local that means the variables which declared in a block are available in that block only. But it does not destroy
the variable’s value when end that block. It takes the previous value when the controller entered into that block
again.
Ex Programs :
89)
# include <stdio.h>
# include <conio.h>
main()
{
static int k ;
clrscr() ;
printf(“%d \n”, k) ;
for(k=1; k<=5; k++)
display() ;
getch() ;
}
display()
{
static int k = 20 ;
printf(“ %d “ , k);
k += 3 ;
}
/* Output :
0
20 23 26 29 32 */
Notes :
extern : This keyword stores the variable in memory device. It initialises the variable as 0. The scope of variable
is global. This variable is declared before the main(). The variable’s value can be changed in the functions.
Ex Programs :
90)
# include <stdio.h>
# include <conio.h>
int k ;
main()
{
clrscr() ;
printf(“\n %d”, k) ;
k=5;
disp1() ;
64 | P a g e
disp2() ;
printf(“\n %d”, k) ;
getch() ;
}
disp1()
{
printf(“\n %d”, k );
k += 3 ;
}
disp2()
{
int k = 20 ;
printf(“\n %d”, k );
disp3() ;
}
disp3()
{
printf(“\n %d”, k );
}
/* Output
0 5 20 8 8 */
65 | P a g e
Notes :
STRUCTURES : A structure is a collection of variety of data type elements. This is created with the keyword struct.
1) struct (name)
{
(elements declaration);
};
2)
struct employee
{
int eno;
char ename[80];
float bas;
} emp = { 5, “rama”, 5600 } ;
3)
struct
{
int eno;
char ename[80];
float bas;
} emp = { 5, “rama”, 5600 } ;
66 | P a g e
Ex Programs :
91)
# include <stdio.h>
# include <conio.h>
main()
{
struct book
{
int pages;
char title[40] ;
float price ;
};
92)
# include <stdio.h>
# include <conio.h>
main()
{
struct book
{
int pages;
char title[40] ;
float price ;
};
struct book bk ;
clrscr() ;
67 | P a g e
93) /* Array of Structures */
# include <stdio.h>
# include <conio.h>
main()
{
struct book
{
int pages;
char title[40] ;
float price ;
};
int k ;
struct book bk[3] = { { 500, “Let us C”, 175 },
{ 350, “Graphics under C”, 235 } ,
{ 800, “Datastructures through C and C++ “, 350 }
};
clrscr() ;
for(k=0; k<3; k++)
{
printf(“\n\n The title of book %s” , bk[k].title );
printf(“\n The number of pages %d” , bk[k].pages ) ;
printf(“\n The price of book %.2f” , bk[k].price ) ;
getch( );
}
}
# include <stdio.h>
# include <conio.h>
struct book
{
int pages;
char title[40] ;
float price ;
};
main()
{
68 | P a g e
struct book bk = { 500, “Let us C”, 175 } ;
clrscr() ;
display(bk.pages, bk.title, bk.price );
dispstrct(bk) ;
getch( );
}
dispstrct(struct book b)
{
printf(“\n The title of book %s”, b.title);
printf(“\n The number of pages %d”, b.pages);
printf(“\n The price of book %f”, b.price );
}
struct book
{ int pages; char name[40]; float price ; } ;
struct pens
{ int qty; char name[40]; float price ; } ;
struct shop
{
char name[40], street[40] ;
struct book bk ;
struct pens pn ;
};
main()
{
struct shop sh = { “Udaya Book world “, “Chintal “,
{ 1200, “Test your skills in C”, 175 } ,
{ 50, “Reynolds”, 12 }
};
clrscr() ;
printf(“\n The shop name %s” , sh.name ) ;
69 | P a g e
printf(“\n The shop address %s “, sh.street);
printf(“\n\n The book title %s” , sh.bk.name ) ;
printf(“\n The number of pages in the book %d”,sh.bk.pages ) ;
printf(“\n The cost of each book %.2f” , sh.bk.price ) ;
printf(“\n\n The name of pen %s” , sh.pn.name ) ;
printf(“\n The quantity of pens %d” , sh.pn.qty ) ;
printf(“\n The cost of each pen %.2f” , sh.pn.price ) ;
getch() ;
}
70 | P a g e
Notes :
POINTERS: This topic is the most important in C. To use any variable it must be declared with its data type
before the first executable statement. By declaring a variable the compiler reserves the required space in memory
between 64 kb and 128 kb. Every cell has a unique address in memory. This address is a number,that is an
integer. The variables stored in the memory can be accessed with their addresses using pointers.To access with
pointers we have to use two new operators.
Ex :
int a = 5;
a ==> 5
&a ==> 65500
*(&a) ==> 5
These address value can be stored in another variable. But that must be a pointer variable of the same type to the
variable.
Ex Programs :
97)
# include <stdio.h>
# include <conio.h>
main()
{
int k, *p, **q ;
clrscr() ;
k = 7; p = &k; q = &p;
printf(“The value of k is %d”, k) ; printf(“\n The address of k is %u”, &k); printf(“\n The value at address
%u is %d”, &k, *(&k) ) ;
printf(“\n The value of P is %u”, p) ; printf(“\n The value at address %u is %u”, &p, *(&p) ) ;
printf(“\n The value at address %u is %d”, p, *p );
printf(“\n The value of q is %u”, q) ; printf(“\n The value at address of %u is %u”, &q, *(&q) ) ;
printf(“\n The value at address %u is %u”, q, *q);
printf(“\n The integer value is %d”, *(*q) ) ;
getch() ;
}
/* Output :
The value of k is 7
The address of k is 65524
The value at address 65524 is 7
71 | P a g e
The value of P is 65524
The value at address 65522 is 65524
The value at address 65524 is 7
The value of q is 65522
The value at address of 65520 is 65522
The value at address 65522 is 65524
The integer value is 7 */
98)
# include <stdio.h>
# include <conio.h>
main()
{
int a, *ap ;
float b, *bp ;
char c, *cp ;
clrscr() ;
printf(“\n The size of int is %d and pointer is %d”, sizeof(a), sizeof(ap) ) ;
printf(“\n The size of float is %d and Pointer is %d”, sizeof(b),sizeof(bp) ) ;
printf(“\n The size of char is %d and Pointer is %d”, sizeof©, sizeof(cp) ) ;
getch() ;
}
Notes :
Pointers in Functions : The functions can be send some arguments to the definition and may take a return value.
If the value of these variables changed in the functions that does not effected to the function calling. To change
the value after calling the function the values can be send by reference. That means the address of the variable can
be send to change the value.
Ex Programs :
98) /* Write a program to interchange the values of two variables using functions
A) CALL BY VALUE : */
# include <stdio.h>
# include <conio.h>
main()
{
int a=20, b=30 ;
clrscr() ;
72 | P a g e
printf(“The initial values are \n”) ;
printf(“a = %d \t b = %d”, a, b) ;
swap(a,b) ;
printf(“\n\n After swapping in main \n”) ;
printf(“ a = %d \t b = %d”, a, b) ;
getch() ;
}
swap(int x, int y)
{
int t ;
t = x; x = y ; y = t ;
printf(“\n\n After swapping \n”);
printf(“ x = %d, y = %d”, x, y);
}
/* Output :
a = 20 b = 30
x = 30 y = 20
a = 20 b = 30 */
B) CALL BY REFERENCE :
# include <stdio.h>
# include <conio.h>
main()
{
int a=20, b=30 ;
clrscr() ;
73 | P a g e
}
/* Output :
a = 20 b = 30
x = 30 b = 30
a = 30 b = 20
*/
Notes :
Arrays with Pointers :
An array is a collection of similar data type elements mentioning with a single variable. The address of first
element is considered the address of the array. The array elements can be accessed using the address of array and
the index value.
Ex Programs :
q)
# include <stdio.h>
# include <conio.h>
main()
{
int k, a[5] = { 10, 20, 30, 40, 50 } ;
clrscr() ;
for(k=0; k<5; k++)
{
printf(“\n the addres of %d element %u %u”, k, &a[k], a+k ) ;
printf(“the value is %d %d %d %d”, a[k], *(a+k), *(k+a), k[a] ) ;
}
getch () ;
}
q)
# include <stdio.h>
# include <conio.h>
main()
{
int *a, n ;
clrscr() ;
74 | P a g e
display(a, n) ;
getch() ;
}
q)
# include <stdio.h>
# include <conio.h>
# define M 5
main()
{
int a[M] ;
clrscr() ;
accept(a, M) ;
display(a, M) ;
getch() ;
}
75 | P a g e
for(n=0; n<k; n++)
printf(“%d “, d[n] ) ;
}
Notes :
malloc() : This function is used to allocate the required space in the memory while executing the program. This
function’s prototype was defined in the header file ALLOC.H There is another function to allocate memory. that
is calloc(). The malloc() assigns junk values the allocated space. But calloc() assigns 0 to the allocated space.
Syntax:
(pointer) = (pointertype) malloc( size * number) ;
(pointer) = (pointertype) calloc( size , number ) ;
Note : If the compiler failed to allocate the required space this function returns a NULL value.
Ex Programs :
q)
# include <stdio.h>
# include <conio.h>
# include <alloc.h>
main()
{
int *p, n, k, s;
clrscr() ;
76 | P a g e
q) /* Write a program to sort the given numbers using Linear Sort technique */
# include <stdio.h>
# include <conio.h>
# include <stdlib.h>
# include <alloc.h>
main()
{
int *p, n;
clrscr() ;
77 | P a g e
for(k=0; k<n; k++)
for(j=k; j<n; j++)
if(a[k]<a[j])
{
t = a[k] ; a[k] = a[j] ; a[j] = t ;
}
}
*/
linear(int *a, int n)
{
int k, j, t ;
for(k=0; k<n; k++)
for(j=k; j<n; j++)
if(*(a+k) < *(a+j) )
{
t = *(a+k) ;
*(a+k) = *(a+j) ;
*(a+j) = t ;
}
}
bubble(int a[], int n)
{
int t, k, j ;
for(k=0; k<n-1; k++)
for(j=0; j<n-1; j++)
if(a[j] < a[j+1] )
{
t = a[j] ;
a[j] = a[j+1] ;
a[j+1] = t ;
}
}
78 | P a g e
*(a+j+1) = t ;
}
}
*/
Notes :
String Pointers to Functions :
Ex Programs :
# include <stdio.h>
# include <conio.h>
# include <string.h>
# include <dos.h>
void main()
{
char *str = “ Bhanodaya is a super hero “;
clrscr();
while(!kbhit())
{
substr(str); delay(100);
gotoxy(20, 12); printf(“%s”,str);
}
getch();
}
/*
substr(char *str)
{
char *dst, c; int i=1, j=0;
c = *str;
while(*(str+i)!=’\0’)
{
*(dst+j) = *(str+i);
i++; j++;
}
*(dst+j) = c;
*(dst+j+1) = ‘\0’;
strcpy(str,dst);
} */
79 | P a g e
substr(char str[])
{
char dst[80], ch ;
int k, j ;
ch = str[0] ;
k=1; j=0;
while(str[k]!=’\0’)
{
dst[j] = str[k] ;
k++; j++;
}
dst[j++] = ch ;
dst[j] = ‘\0’ ;
strcpy(str, dst) ;
}
Notes :
Structures with Pointers : The elements of a structure variable can be accessed using a period operator between
the variable and the element. To access the elements using the address of the variable the ‘ -> ‘ operator must be
used.
(variablepoitner) -> (element)
Ex Programs :
q)
# include <conio.h>
# include <stdio.h>
struct book
{ int pages; char title[40]; float price ; } ;
main()
{
struct book bk = { 500, “Pointers in C”, 175.00 } ;
struct book *b ;
clrscr() ;
b = &bk ;
printf(“\n The book title %s” , bk.title ) ;
printf(“\n The number of pages %d” , bk.pages ) ;
printf(“\n The cost of book %.2f “ , bk.price ) ;
printf(“\n\n The book title %s” , b->title) ;
printf(“\n The number of pages %d”, b->pages ) ;
printf(“\n The cost of book %.2f “, b->price ) ;
printf(“\n\n The size of structure variable %d”,sizeof(bk) );
printf(“\n The size of structure pointer %d”, sizeof(b) ) ;
getch() ;
}
80 | P a g e
q) /* Structure Pointers to Functions */
# include <conio.h>
# include <stdio.h>
struct book
{ int pages; char title[40]; float price ; } ;
main()
{
struct book bk = { 500, “Pointers in C”, 175.00 } ;
clrscr() ;
dispvar(bk) ;
disppntr(&bk) ;
getch() ;
}
Notes :
FILE HANDLING IN C: Using C programs the data files and text files can be manipulated. To use any file it
must be loaded into memory. In C programs the file pointer where the file stored can be found.
fopen(): This function is used to open the required file in the required mode and returns the file pointer where the
file stored. If it is unable to open in the given mode it returns a constant value NULL.
Syntax :
FILE * (filepointer) ;
(filepointer) = fopen(“filename”, “mode” );
modes :
----
81 | P a g e
“w” ==> To create the file and store the data
“a” ==> To add the data to the file
“r” ==> To read the data from the file
Ex :
FILE *fp;
fp = fopen(“data.txt”, “w”);
fclose() :
The file, which opened in memory must be closed to avoid the data corruption. To close the file the
function fclose() must be used.
Syntax : fclose(filepointer);
Ex : fclose(fp) ;
fputc():
This function is used to store the characters in the data file opened in the filepointer.
Syntax : fputc(char, filepointer) ;
Ex : fputc(ch, fp) ;
fgetc() :
This function is used to read a character to the variable from the file pointer.
Syntax : char variable = fgetc(filepointer) ;
Ex : ch = fgetc(fp) ;
Ex Programs :
q) /* Write a program to create a text file DATA and store some data. */
# include <stdio.h>
# include <conio.h>
# include <stdlib.h>
main()
{
FILE *fp ;
char ch ;
fp = fopen(“DATA”, “w”) ;
if(fp==NULL)
{
printf(“\n Unable to open the given file “) ;
exit(0) ;
}
while(1)
{
ch = getchar();
if(ch==EOF) break ;
fputc(ch, fp) ;
}
fclose(fp) ;
}
82 | P a g e
q) /* Write a program to read the text from the file DATA */
# include <stdio.h>
# include <conio.h>
# include <stdlib.h>
main()
{
FILE *fp ;
char ch ;
clrscr() ;
fp = fopen(“DATA”, “r”) ;
if(fp==NULL)
{
printf(“\n File not found “) ;
exit(0) ;
}
while(1)
{
ch = fgetc(fp);
if(ch==EOF) break ;
putchar(ch) ;
}
fclose(fp) ;
getch() ;
}
q)/* Write a program to read the text from the file DATA display in Upper case characters */
# include <stdio.h>
# include <conio.h>
# include <stdlib.h>
main()
{
FILE *fp ;
char ch ;
clrscr() ;
fp = fopen(“data”, “r”) ;
if(fp==NULL)
{
printf(“\n File not found “) ;
exit(0) ;
}
while(1)
{
ch = fgetc(fp);
83 | P a g e
if(ch==EOF) break ;
if(ch>=97 && ch<=122) ch -= 32 ;
putchar(ch) ;
}
fclose(fp) ;
getch() ;
}
q)/* Write a program to read the text from the file DATA copy to another in file in upper case characters */
# include <stdio.h>
# include <conio.h>
# include <stdlib.h>
main()
{
FILE *fs, *ft ;
char ch, *src, *trg ;
clrscr() ;
printf(“Enter the source file to copy “) ;
scanf(“%s”, src) ;
fs = fopen(src, “r”) ;
if(fs==NULL)
{
printf(“\n Source File not found “) ;
exit(0) ;
}
printf(“\n Enter the target file to copy “) ;
scanf(“%s”, trg) ;
ft = fopen(trg, “w”) ;
if(ft==NULL)
{
printf(“\n Unable to open the target file “) ;
exit(1) ;
}
while(1)
{
ch = fgetc(fs);
if(ch==EOF) break ;
if(ch>=97 && ch<=122) ch -= 32 ;
putchar(ch) ;
fputc(ch, ft) ;
}
fclose(fs) ; fclose(ft) ;
getch() ; }
84 | P a g e
Notes :
fprintf() : This function stores the data in the file.
Syntax : fprintf(filepointer, “format string”, variables);
Ex : fprintf(fp, “%d %s %f”, eno, ena, bas);
Ex Programs :
q)/* Write a program to create a data file EMP.DAT, accept employee number, name, basic salary and store all
in the data file */
# include <conio.h>
# include <stdio.h>
# include <stdlib.h>
main()
{
FILE *fp ;
int eno; char ena[40]; float bas ;
char ans=’y’ ;
clrscr() ;
fp = fopen(“EMP.DAT”, “w”) ;
if(fp==NULL)
{
printf(“\n Unable to open in the required mode “) ;
exit(0) ;
}
while(ans==’y’ || ans==’Y’)
{
printf(“\n Enter Employee Number “) ;
scanf(“%d”, &eno) ;
printf(“ Enter Employee Name “) ;
scanf(“%s”, ena) ;
printf(“ Enter Basic Salary “) ;
scanf(“%f”, &bas) ;
fprintf(fp, “\n %d %s %f”, eno, ena, bas) ;
printf(“Do you want to continue “) ;
ans = getche() ;
}
getch();
}
85 | P a g e
q)/* Write a program to read the records from the data file EMP.DAT, calculate da, hra, pf, net salary and print
all */
# include <conio.h>
# include <stdio.h>
# include <stdlib.h>
main()
{
FILE *fp ;
int eno; char ena[40];
float bas, da, hra, pf, net ;
clrscr() ;
fp = fopen(“EMP.DAT”, “r”) ;
if(fp==NULL)
{
printf(“\n File not found “) ;
exit(0) ;
}
while( fscanf(fp, “%d%s%f”, &eno, ena, &bas) > 0)
{
da = bas * 20 / 100 ;
hra = bas * 30 / 100 ;
pf = bas * 10 / 100 ;
net = bas + da + hra - pf ;
Notes :
fwrite() : This function is used to store the structures in the file in binary mode.
86 | P a g e
Ex Programs :
q)
# include <stdio.h>
# include <conio.h>
struct employee
{ int eno; char ena[20]; float bas ; } ;
main()
{
struct employee emp ;
FILE *fp ;
char ans ;
clrscr() ;
fp = fopen(“empbn.dat”, “wb”) ;
if(fp==NULL)
{
printf(“Unable to open the data file “) ;
exit(0) ;
}
do
{
printf(“\n\n Enter employee Number “) ;
scanf(“%d”, &emp.eno) ;
printf(“Enter Employee Name “) ;
scanf(“%s”, emp.ena) ;
printf(“Enter Basic Salary “) ;
scanf(“%f”, &emp.bas) ;
fwrite(&emp, 1, sizeof(emp), fp) ; printf(“Do you want to add more “) ;
ans = getche() ;
} while(ans==’y’ || ans==’Y’) ;
}
q)
# include <stdio.h>
# include <conio.h>
struct employee
{ int eno; char ena[20]; float bas ; } ;
main()
{
struct employee emp ;
FILE *fp ;
clrscr() ;
87 | P a g e
fp = fopen(“empbn.dat”, “rb”) ;
if(fp==NULL)
{
printf(“Unable to open the data file “) ;
exit(0) ;
}
while( fread(&emp, 1, sizeof(emp), fp) > 0)
{
printf(“\n\n Employee Number %d”, emp.eno) ;
printf(“\n Employee Name %s”, emp.ena) ;
printf(“\n Basic Salary %.2f”, emp.bas) ;
getch() ;
}
}
q)
# include <stdio.h>
# include <conio.h>
struct employee
{ int eno; char ena[20]; float bas ; } ;
main()
{
struct employee emp ;
FILE *fs, *ft ;
clrscr() ;
fs = fopen(“empbn.dat”, “rb”) ;
if(fs==NULL)
{
printf(“Unable to open the data file “) ;
exit(0) ;
}
ft = fopen(“emp.dat”, “w”) ;
if(ft==NULL)
{
printf(“\n Unable to open the target file “) ;
exit(1);
}
while( fread(&emp, 1, sizeof(emp), fs) > 0)
{
printf(“\n\n Employee Number %d”, emp.eno) ;
printf(“\n Employee Name %s”, emp.ena) ;
printf(“\n Basic Salary %.2f”, emp.bas) ;
fprintf(ft, “\n %d %s %f”, emp.eno, emp.ena, emp.bas);
88 | P a g e
getch() ;
}
}
Notes :
Ex Programs :
q) /* This program demonstrates about the arguments passed to the function main() */
# include <stdio.h>
void main(int argv, char *args[])
{
int k ;
printf(“\n The number of arguments given %d”, argv) ;
printf(“\n The arguments are \n”) ;
for(k=0; k<argv; k++)
printf(“\n %s”, args[k] ) ;
# include <stdio.h>
# include <stdlib.h>
void main(int argv, char *args[])
{
char ch;
FILE *fp ;
89 | P a g e
if(argv!=2)
{
printf(“\n Invalid number of arguments “) ;
exit(0) ;
}
fp = fopen(args[1], “w”) ;
if(fp==NULL)
{
printf(“\n Unable to create the given file “) ;
exit(1) ;
}
while(1)
{
ch = getchar() ;
if(ch==EOF) break ;
fputc(ch, fp) ;
}
printf(“\n 1. file created \n”) ;
}
/*
Save this program as CREATE.C
After compilation it creates an executable file CREATE.EXE, which
can be executed at MS-DOS prompt.
[prompt] CREATE (filename) */
# include <stdio.h>
# include <stdlib.h>
void main(int argv, char *args[])
{
char ch;
FILE *fp ;
if(argv!=2)
{
printf(“\n Invalid number of arguments “) ;
exit(0) ;
}
fp = fopen(args[1], “r”) ;
if(fp==NULL)
{
printf(“\n File not found - %s”, args[1] ) ;
exit(1) ;
90 | P a g e
}
while(1)
{
ch = fgetc(fp) ;
if(ch==EOF) break ;
putchar(ch) ;
}
}
q)/* Program to create a file which can copy the text from a file to another */
# include <stdio.h>
# include <stdlib.h>
void main(int argv, char *args[])
{
FILE *fs, *ft ;
char ch ;
if(argv!=3)
{
printf(“Invalid number of arguments “);
exit(0) ;
}
fs = fopen(args[1], “r”) ;
if(fs==NULL)
{
printf(“\n Unable to open the source file “) ;
exit(1) ;
}
ft = fopen(args[2],”w”) ;
if(ft==NULL)
{
printf(“\n This target file %s not found “, args[2] ) ;
exit(2) ;
}
while( (ch=fgetc(fs)) != EOF)
fputc(ch, ft) ;
fclose(fs) ; fclose(ft) ;
printf(“\n 1. File copied “) ;
}
91 | P a g e
/* Save this file as FLCP.C
[prompt] FLCP (source) (target) */
Notes :
random() :
This function returns the value which is between 0 and 1 less than the given number. This function’s
prototype has defined in the header file STDLIB.H.
Syntax : random(n);
This function returns any number from 0 to n-1 .
textattr() & textbackground() : This function changes the text color to the given color.
92 | P a g e
GRAPHICS
Generally the screen is in text mode. It can be changed by the display adopters. There are a number of
adopters like VGA, CGA,EGA, ... The normal text mode has 25 rows and 80 columns. It can be changed using
the MODE command in MS-DOS.Using C programs we can design some graphics by changing the screen from
text mode to graphics mode.
initgraph() :
This function changes the screen from text mode to graphics mode. But here we have to mention the
display driver and mode. To use this command the file EGAVGA.BGI must be in the current directory. This
function’s prototype has defined in the header file GRAPHICS.H.
detectgraph() :
This function detects the using graphic driver and modes. It assigns the values to the variables.
Syntax : detectgraph( (address of graphic driver), (address of graphic mode) );
Ex : int gdr, gmd;
detectgraph(&gdr, &gmd);
closegraph() : This function closes the graphics mode and changes to text mode.
Syntax: closegraph();
setcolor() :
This function changes the displaying color of screen. In VGAHI we can use 16 colors. The color can be
mentioned as integer.
Syntax: setcolor(integer) ;
Ex : setcolor(RED) ;
setcolor(4) ;
putpixel(): This function highlights the pixel(picture element) at the given co-ordinates to the given color .
Syntax : putpixel(x-coordinate, y-coordinate, color) ;
Ex : putpixel(320, 240, 5) ;
line(): This function displays a line between the given coordinates.
Syntax : line(x1, y1, x2, y2 );
Ex : line(200,300, 240, 370 );
93 | P a g e
lineto(): This function displays a line to the given coordinates from the current coordinates.
Syntax : lineto(x2, y2) ;
Ex : lineto(400, 600) ;
circle() : This function displays a circle with the given center coordinates and the radius.
Syntax : circle(x, y, radius) ;
Ex :circle(320, 240, 100) ;
ellipse() :
Syntax : ellipse(x, y, st-angle, end-angle,x-radius, y-radius );
Ex : ellipse( 320, 240, 0, 360, 200, 100 );
arc() :
Syntax : arc(x, y, st-angle, end-angle, radius );
Ex : arc(320, 240, 45, 135, 200 ) ;
rectangle() :
Syntax : rectangle( x1, y1, x2, y2 );
Ex : rectangle( 200, 150, 440, 320 );
outtextxy() : This functions displays the given text at the given coordinates with the settled style.
Syntax : outtextxy(x, y, text) ;
94 | P a g e