C and Data Structures Balaguruswamy

{\rtf\ansi\deff0\ansicpg1252
{\fonttbl
{\f0\froman times new roman;}}
{\colortbl\red0\green0\blue0;}
\jexpand\viewkind1\viewscale100
{\shp{\*\shpinst\shpleft1586\shptop4826\shpright10226\shpbottom4826\shpfhdr0\shp
wr3\shpwrk0\shpfblwtxt1\shplid2028\shpz0\shpbxpage\shpbypage
{\sp{\sn shapeType}{\sv 0}}
{\sp{\sn fFlipH}{\sv 0}}
{\sp{\sn fFlipV}{\sv 0}}
{\sp{\sn rotation}{\sv 0}}
{\sp{\sn geoRight}{\sv 8640}}
{\sp{\sn geoBottom}{\sv 0}}
{\sp{\sn shapePath}{\sv 4}}
{\sp{\sn pVerticies}{\sv 8;2;(0,0);(8640,0);}}
{\sp{\sn pSegmentInfo}{\sv 2;5;16384;45824;1;45824;32768}}
{\sp{\sn fFillOK}{\sv 1}}
{\sp{\sn fFilled}{\sv 0}}
{\sp{\sn lineWidth}{\sv 50792}}
{\sp{\sn lineColor}{\sv 13421772}}
{\sp{\sn lineDashing}{\sv 0}}
{\sp{\sn fLine}{\sv 1}}{\sp{\sn lineColor}{\sv 13421772}}
{\sp{\sn lineType}{\sv 0}}
{\sp{\sn fArrowheadsOK}{\sv 0}}
{\sp{\sn fBehindDocument}{\sv 1}}
{\sp{\sn fLayoutInCell}{\sv 1}}}}
{\shp{\*\shpinst\shpleft1586\shptop4680\shpright3986\shpbottom4880\shpfhdr0\shpw
r3\shpwrk0\shpfblwtxt1\shplid2029\shpz1\shpbxpage\shpbypage
{\sp{\sn pVerticies}{\sv 8;5;(0,0);(0,200);(2400,200);(2400,0);(0,0);}}
{\sp{\sn pSegmentInfo}{\sv 2;12;16384;45824;1;45824;1;45824;1;45824;1;45824;2457
7;32768}}
{\sp{\sn fillColor}{\sv 11711154}}
{\sp{\sn pVerticies}{\sv 8;2;(0,0);(8640,0);}}
{\sp{\sn pSegmentInfo}{\sv 2;5;16384;45824;1;45824;32768}}

7;32768}}
{\sp{\sn fLayoutInCell}{\sv 1}}}}\paperw11893\paperh16840\margl666\margr133\marg
t666\margb666
\pard\li1066\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1066\ri0\sl-213\slmult0 \fs
18\cf0\par\pard\li1066\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1066\ri0\sl-213\s
lmult0 \fs18\cf0\par\pard\li1066\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1066\ri
0\sl-213\slmult0 \fs18\cf0\par\pard\li1066\ri0\sl-213\slmult0 \fs18\cf0\par\pard
\li1066\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1066\ri0\sl-213\slmult0 \fs18\cf
0\par\pard\li1066\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1066\ri0\sl-213\slmult
0 \fs18\cf0\par\pard\li1066\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1066\ri0\sl213\slmult0 \fs18\cf0\par\pard\li1066\ri0\sl-1146\slmult0 \fs90\cf0\f0\charscale
x100 {C and Data Structures}\par\pard\li4373\ri0\sl-213\slmult0 \fs18\cf0\par\pa
rd\li4373\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li4373\ri0\sl-213\slmult0 \fs18\
cf0\par\pard\li4373\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li4373\ri0\sl-213\slmu
lt0 \fs18\cf0\par\pard\li4373\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li4373\ri0\s
l-213\slmult0 \fs18\cf0\par\pard\li4373\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li
4373\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li4373\ri0\sl-213\slmult0 \fs18\cf0\p
ar\pard\li4373\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li4373\ri0\sl-213\slmult0 \
fs18\cf0\par\pard\li4373\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li4373\ri0\sl-440
\slmult0 \fs24\cf0\f0\charscalex100 {E Balagurusamy}\par\pard\li4506\ri0\sl-333\
slmult0 \fs22\cf0\f0\charscalex100 {Vice Chancellor}\par\pard\li4066\ri0\sl-280\
slmult0 \fs22\cf0\f0\charscalex100 {Anna University, Chennai}\par\pard\sect\sect
d\sbkpage
{\sp{\sn pVerticies}{\sv 8;85;(0,266);(0,1306);(0,1333);(0,1346);(13,1373);(13,1
386);(26,1413);(26,1426);(40,1440);(53,1466);(66,1480);(80,1493);(93,1506);(106,
1520);(120,1533);(146,1546);(160,1546);(186,1560);(200,1560);(226,1560);(240,157
3);(266,1573);(8360,1573);(8386,1573);(8413,1560);(8426,1560);(8453,1560);(8466,
1546);(8493,1546);(8506,1533);(8520,1520);(8533,1506);(8546,1493);(8573,1480);(8
573,1466);(8586,1440);(8600,1426);(8613,1413);(8613,1386);(8626,1373);(8626,1346
);(8626,1333);(8626,1306);(8626,266);(8626,240);(8626,226);(8626,200);(8613,186)
;(8613,160);(8600,146);(8586,120);(8573,106);(8573,93);(8546,80);(8533,66);(8520
,53);(8506,40);(8493,26);(8466,26);(8453,13);(8426,13);(8413,0);(8386,0);(8360,0
);(266,0);(240,0);(226,0);(200,13);(186,13);(160,26);(146,26);(120,40);(106,53);
(93,66);(80,80);(66,93);(53,106);(40,120);(26,146);(26,160);(13,186);(13,200);(0
,226);(0,240);(0,266);}}
{\sp{\sn pSegmentInfo}{\sv 2;172;16384;45824;1;45824;1;45824;1;45824;1;45824;1;4
5824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;4
5824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;4
5824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;4
5824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;4
5824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;4
5824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;4
5824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;4
5824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;1;45824;245
77;32768}}
{\sp{\sn fLayoutInCell}{\sv 1}}}}\pgwsxn11893\pghsxn16840\marglsxn666\margrsxn13
3\margtsxn666\margbsxn666\pard\li3666\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li36
66\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li3666\ri0\sl-213\slmult0 \fs18\cf0\par
0 \fs18\cf0\par\pard\li3666\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li3666\ri0\sl213\slmult0 \fs18\cf0\par\pard\li3666\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li36
0 \fs18\cf0\par\pard\li3666\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li3666\ri0\sl213\slmult0 \fs18\cf0\par\pard\li3666\ri0\sl-360\slmult0 \fs22\cf0\f0\charscalex
100 {NOTE TO THE USER}\par\pard\li1040\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1
040\ri0\sl-280\slmult0 \fs22\cf0\f0\charscalex100 {This CD-ROM contains chapterwise program examples with source code. These are in addition to}\par\pard\li104
0\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {those given in the text. We hop
e the user finds them useful in enhancing his understanding of the text}\par\par
d\li1040\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {and also in developing h
is programming skills using C.}\par\pard\sect\sectd\sbkpage

7;32768}}
7;32768}}
{\shp{\*\shpinst\shpleft3026\shptop11266\shpright9760\shpbottom14173\shpfhdr0\sh
pwr3\shpwrk0\shpfblwtxt1\shplid2035\shpz2\shpbxpage\shpbypage
7;32768}}

0\f0\charscalex100 {INTRODUCTION}\par\pard\li920\ri0\sl-213\slmult0 \fs18\cf0\pa
r\pard\li920\ri0\sl-280\slmult0 \fs22\cf0\f0\charscalex100 {This is an example f
or a simple substitution macro.}\par\pard\li2533\ri0\sl-413\slmult0 \fs12\cf0\f0
\charscalex100 {/************************************************************/}\
par\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* simple macro s
ubstitution */}\par\pard\li2533\ri0\sl-213\slmult0 \fs10\cf0\f0\charscalex100 {/
************************************************************/}\par\pard\li2533\r
i0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {#define AND &&}\par\pard\li2533\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2533\ri0\sl-213\
slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2533\ri0\sl-213\slmult0 \fs16
\cf0\f0\charscalex100 { char a,b;}\par\pard\li2533\ri0\sl-360\slmult0 \fs16\cf0
\f0\charscalex100 { a = 'A';}\par\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\c
harscalex100 { b = 'A';}\par\pard\li2533\ri0\sl-386\slmult0 \fs16\cf0\f0\charsc
alex100 { if (a AND b) printf("\\nSame");}\par\pard\li2533\ri0\sl-213\slmult0 \
fs14\cf0\f0\charscalex100 {\}}\par\pard\li920\ri0\sl-213\slmult0 \fs18\cf0\par\p
ard\li920\ri0\sl-293\slmult0 \fs22\cf0\f0\charscalex100 {This is an example for
a simple substitution macro. This macro has a C function printf() in its body.}\
par\pard\li2533\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2533\ri0\sl-226\slmult0
\fs12\cf0\f0\charscalex100 {/***************************************************
*********/}\par\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* si
mple macro substitution with function */}\par\pard\li2533\ri0\sl-213\slmult0 \fs
12\cf0\f0\charscalex100 {/******************************************************
******/}\par\pard\li2533\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {#define
AND &&}\par\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {#define M
ESSAGE printf("\\nSame...")}\par\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\cha
rscalex100 {main()}\par\pard\li2533\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex10
0 {\{}\par\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char a,b
;}\par\pard\li2533\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100 { a = 'A';}\pa
r\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { b = 'A';}\par\par
d\li2533\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { if (a AND b) MESSAGE;}
\par\pard\li2533\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li9
20\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li920\ri0\sl-293\slmult0 \fs22\cf0\f0\c
harscalex100 {This is an example for a macro with argument. It calculates the ar
ea of a circle.}\par\pard\li2653\ri0\sl-413\slmult0 \fs12\cf0\f0\charscalex100 {
/************************************************************/}\par\pard\li2653\
ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* macro with arguments */}\par\p
ard\li2653\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/*********************
***************************************/}\par\pard\li2653\ri0\sl-333\slmult0 \fs
16\cf0\f0\charscalex100 {#define AREA(r) (3.14 * r * r)}\par\pard\li2653\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2653\ri0\sl-213\slmul
t0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2653\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 { float r;}\par\pard\li2653\ri0\sl-320\slmult0 \fs16\cf0\f0\ch
arscalex100 { printf("\\nEnter radius : ");}\par\pard\li2653\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { scanf("%f",&r);}\par\pard\li2653\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { printf("\\nArea is : %f",AREA(r));}\par\pard\li
2653\ri0\sl-320\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li5186\ri0\sl-2
13\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-346\slmult0 \fs18\cf0\f0\charscalex1
00 {3}\par\pard\sect\sectd\sbkpage

7;32768}}
\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li920\ri0\sl-213\slmult0 \fs18\cf0\par\pa
rd\li920\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li920\ri0\sl-213\slmult0 \fs18\cf
0\par\pard\li920\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li920\ri0\sl-213\slmult0
\fs18\cf0\par\pard\li920\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li920\ri0\sl-213\
slmult0 \fs18\cf0\par\pard\li920\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li920\ri0
\sl-213\slmult0 \fs18\cf0\par\pard\li920\ri0\sl-360\slmult0 \fs22\cf0\f0\charsca
lex100 {This is an example for a macro with arguments containing relational oper
ators and nesting of macro. It}\par\pard\li920\ri0\sl-266\slmult0 \fs22\cf0\f0\c
harscalex100 {checks whether the input value is a number or alphabet.}\par\pard\
li2533\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2533\ri0\sl-320\slmult0 \fs12\cf0
\f0\charscalex100 {/************************************************************
/}\par\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* macro with
arguments - relational operators and nesting */}\par\pard\li2533\ri0\sl-213\slmu
lt0 \fs12\cf0\f0\charscalex100 {/***********************************************
*************/}\par\pard\li2533\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {#
define AND &&}\par\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {#d
efine ISDIGIT(a) (a >= 48 AND a <= 57)}\par\pard\li2533\ri0\sl-213\slmult0 \fs16
\cf0\f0\charscalex100 {main()}\par\pard\li2533\ri0\sl-213\slmult0 \fs14\cf0\f0\c
harscalex100 {\{}\par\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{ char r;}\par\pard\li2533\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100 { pri
ntf("\\nEnter a single character or number: ");}\par\pard\li2533\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 { r = getchar();}\par\pard\li2533\ri0\sl-213\slm
ult0 \fs16\cf0\f0\charscalex100 { if ISDIGIT(r)}\par\pard\li2533\ri0\sl-213\slm
ult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2533\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("\\nYou entered a
number");}\par\pard\li2533\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\
par\pard\li2533\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { else}\par\pard\
li2533\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2533\ri0\
sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {prin
tf("\\nYou entered an alphabet");}\par\pard\li2533\ri0\sl-213\slmult0 \fs14\cf0\
f0\charscalex100 { \}}\par\pard\li2533\ri0\sl-213\slmult0 \fs14\cf0\f0\charscal
ex100 {\}}\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-2
13\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li518
6\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\
pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs1
8\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\sl
mult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0
\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\
\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0
\fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-2
6\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\
8\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\sl
mult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0
\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\
li5186\ri0\sl-333\slmult0 \fs18\cf0\f0\charscalex100 {4}\par\pard\sect\sectd\sbk
page
{\sp{\sn pVerticies}{\sv 8;4;(0,10880);(0,0);(6720,0);(6720,10906);}}
{\sp{\sn pSegmentInfo}{\sv 2;9;16384;45824;1;45824;1;45824;1;45824;32768}}
0\f0\charscalex100 {CHAPTER 3}\par\pard\li2346\ri0\sl-280\slmult0 \fs22\cf0\f0\c
harscalex100 {CONSTANTS, VARIABLES, AND DATA TYPES}\par\pard\li1226\ri0\sl-466\s
lmult0 \fs22\cf0\f0\charscalex100 {1. Program shows the usage of the size of key
word in C to get the storage space used by various}\par\pard\li1520\ri0\sl-266\s
lmult0 \fs22\cf0\f0\charscalex100 {data types. Note that the results are differe
nt for a 16-bit environment (such as DOS) and 32-bit}\par\pard\li1520\ri0\sl-266
\slmult0 \fs22\cf0\f0\charscalex100 {environment (such as Windows).}\par\pard\li
2360\ri0\sl-306\slmult0 \fs12\cf0\f0\charscalex100 {/***************************
*************************************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16
\cf0\f0\charscalex100 {/* Program to demonstrate the storage space used by data
types */}\par\pard\li2360\ri0\sl-226\slmult0 \fs12\cf0\f0\charscalex100 {/******
**********************************************************/}\par\pard\li2360\ri0
\sl-426\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-226\s
lmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\
pri}\fs16\cf0\f0\charscalex100 {ntf("\\nStorage space
(in bits) for various data types (32-bit environment)");}\par\pard\li2360\ri0\sl
-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf
("\\n--------------------------------------------------------------------");}\pa
r\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\c
harscalex100 {printf("\\nint}\fs16\cf0\f0\charscalex100 {
%}\fs1
6\cf0\f0\charscalex100 {5d",sizeof(int)*8);}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("\\nsigned i
nt}\fs16\cf0\f0\charscalex100 {
%}\fs16\cf0\f0\charscalex100 {5d",sizeo
f(signed int)*8);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100

{
printf("\\nunsigned int
%5d",sizeof(unsigned int)*8);}\par\pard\li2
360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
prin}\fs16\cf0\f0\charsca
lex100 {tf("\\nshort int}\fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\ch
arscalex100 {%5d",sizeof(short int)*8);}\par\pard\li2360\ri0\sl-226\slmult0 \fs1
6\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("\\nsigned short
int}\fs16\cf0\f0\charscalex100 {
%}\fs16\cf0\f0\charscalex100 {5d",sizeof(si
gned short int)*8);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex1
00 {
}\fs16\cf0\f0\charscalex100 {printf("\\nunsigned short int %5d",sizeof(
unsigned short int)*8);}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charsca
lex100 {
prin}\fs16\cf0\f0\charscalex100 {tf("\\nlong int}\fs16\cf0\f0\charsc
alex100 {
}\fs16\cf0\f0\charscalex100 {%5d",sizeof(long int)*8);}\par
\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
prin}\fs16\cf0\f
0\charscalex100 {tf("\\nsigned long int}\fs16\cf0\f0\charscalex100 {
}\fs16\
cf0\f0\charscalex100 {%5d",sizeof(signed long int)*8);}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 {
prin}\fs16\cf0\f0\charscalex100 {tf("
\\nunsigned long int %5d",sizeof(unsigned long int)*8);}\par\pard\li2360\ri0\s
l-226\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {print
f("\\nfloat}\fs16\cf0\f0\charscalex100 {
%}\fs16\cf0\f0\charscalex
100 {5d",sizeof(float)*8);}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\char
scalex100 {
}\fs16\cf0\f0\charscalex100 {printf("\\ndouble}\fs16\cf0\f0\chars
calex100 {
%}\fs16\cf0\f0\charscalex100 {5d",sizeof(double)*8);}\pa
}\fs16\cf0\f0\c
harscalex100 {printf("\\nlong double}\fs16\cf0\f0\charscalex100 {
%}\fs1
6\cf0\f0\charscalex100 {5d",sizeof(long double)*8);}\par\pard\li2360\ri0\sl-226\
slmult0 \fs16\cf0\f0\charscalex100 {
pri}\fs16\cf0\f0\charscalex100 {ntf("\\n
char
}\fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {%5d
",sizeof(char)*8);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex10
0 {
}\fs16\cf0\f0\charscalex100 {printf("\\nunsigned char}\fs16\cf0\f0\charsc
alex100 {
%}\fs16\cf0\f0\charscalex100 {5d",sizeof(unsigned char)*8);}\par
}\fs16\cf0\f0\ch
arscalex100 {printf("\\n-------------------------------------------------------------------");}\par\pard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\charscalex100 {
\}}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {Continued in
the next page}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {St
orage space (in bits) for various data types (16-bit environment)}\par\pard\li23
60\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {-------------------------------------------------------------------}\par\pard\li2360\ri0\sl-213\slmult0 \fs16
\cf0\f0\charscalex100 {int
16}\par\pard\li2360\ri0\
sl-213\slmult0 \fs16\cf0\f0\charscalex100 {signed int}\fs16\cf0\f0\charscalex100
{
16}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscal
ex100 {unsigned int}\fs16\cf0\f0\charscalex100 {
16}\par\pard\li236
0\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {short int
16
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {signed short in
t}\fs16\cf0\f0\charscalex100 {
16}\par\pard\li2360\ri0\sl-226\slmult0 \f
s16\cf0\f0\charscalex100 {unsigned short int}\fs16\cf0\f0\charscalex100 {
16
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {long int}\fs16\
32}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 {signed long int}\fs16\cf0\f0\charscalex100 {
32}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {unsigned
long int}\fs16\cf0\f0\charscalex100 {
32}\par\pard\li2360\ri0\sl-226\slmul
t0 \fs16\cf0\f0\charscalex100 {float}\fs16\cf0\f0\charscalex100 {
32}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {d
ouble}\fs16\cf0\f0\charscalex100 {
64}\par\pard\li2360\ri0
\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {long double}\fs16\cf0\f0\charscalex1
00 {
80}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscale
x100 {char
8}\par\pard\li2360\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 {unsigned char}\fs16\cf0\f0\charscalex100 {
8}\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmu
lt0 \fs18\cf0\par\pard\li5186\ri0\sl-426\slmult0 \fs18\cf0\f0\charscalex100 {5}\
par\pard\sect\sectd\sbkpage
7;32768}}
{\shp{\*\shpinst\shpleft2546\shptop-3866\shpright9266\shpbottom7026\shpfhdr0\shp
0\f0\charscalex100 {Storage space (in bits) for various data types (32-bit envir
onment)}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {-------------------------------------------------------------------}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {int
32
}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {signed int}\fs1
32}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 {unsigned int}\fs16\cf0\f0\charscalex100 {
32}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {short i
nt}\fs16\cf0\f0\charscalex100 {
16}\par\pard\li2360\ri0\sl-
226\slmult0 \fs16\cf0\f0\charscalex100 {signed short int}\fs16\cf0\f0\charscalex

100 {
16}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100
{unsigned short int}\fs16\cf0\f0\charscalex100 {
16}\par\pard\li2360\ri0\s
l-213\slmult0 \fs16\cf0\f0\charscalex100 {long int}\fs16\cf0\f0\charscalex100 {
32}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charsc
alex100 {signed long int}\fs16\cf0\f0\charscalex100 {
32}\par\pard\li
2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {unsigned long int}\fs16\cf0\
f0\charscalex100 {
32}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\ch
arscalex100 {float
32}\par\pard\li2360\ri0\sl-226\slm
ult0 \fs16\cf0\f0\charscalex100 {double}\fs16\cf0\f0\charscalex100 {
64}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
long double}\fs16\cf0\f0\charscalex100 {
96}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {char
8
}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {unsigned char}\
fs16\cf0\f0\charscalex100 {
8}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 {-------------------------------------------------------------------}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1226\
ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1226\ri0\sl-320\slmult0 \fs22\cf0\f0\cha
rscalex100 {2. Program shows the usage of the char variable. Note that we have a
ssigned the character variable}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\
charscalex100 {a, the value A. When we print the value of the variable a as inte
ger (%d), we get 65 as result,}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\
charscalex100 {which is the ASCII code of the value of the variable. However, wh
en we print the value as a}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\char
scalex100 {character (%c), we get A as the result. Also, we are able to incremen
t the variable a as if it is a}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\
charscalex100 {numeric variable. In this case, we get the next ASCII value into
the variable which is 66 or B.}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\pa
r\pard\li2360\ri0\sl-320\slmult0 \fs12\cf0\f0\charscalex100 {/******************
**********************************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 {/* Program to }\fs16\cf0\f0\charscalex100 {demonstrate usa
ge of char data type */}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charsca
lex100 {/****************************************************/}\par\pard\li2360\
ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-21
3\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 { char a;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 { a = 'A';}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 { prin}\fs16\cf0\f0\charscalex100 {tf("\\nValue of a is %c",a);
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nV
alue of a is %d",a);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 { a = a + 1;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex10
0 { prin}\fs16\cf0\f0\charscalex100 {tf("\\nValues after incrementing\\n");}\p
ar\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { prin}\fs16\cf0\
f0\charscalex100 {tf("\\nValue of a is %c",a);}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { printf("\\nValue of a is %d",a);}\par\pard\li2
0\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0
\fs16\cf0\f0\charscalex100 {Value of a is A}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 {Value of a is 65}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 {Values after incrementing}\par\pard\li2360\ri0\sl373\slmult0 \fs16\cf0\f0\charscalex100 {Value of a is B}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {Value of a is 66}\par\pard\li5186\ri0\sl
-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-293\slmult0 \fs18\cf0\f0\charscale
x100 {6}\par\pard\sect\sectd\sbkpage

7;32768}}
7;32768}}
0\f0\charscalex100 {3. Program shows the usage of the typedef keyword. We have d
efined two data types of our own.}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\
f0\charscalex100 {One is an unsigned short int and another is a string data type
. In C, we declare a string as a}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f
0\charscalex100 {character array, which we will see later. Here, we have defined
char* as a STRING data type.}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\c
harscalex100 {The exact meaning of char* will be seen later.}\par\pard\li1520\ri
0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {In the program, we have assigned a
huge value which cannot be contained in a short int. Hence,}\par\pard\li1520\ri0
\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {we get a junk result.}\par\pard\li23
60\ri0\sl-360\slmult0 \fs12\cf0\f0\charscalex100 {/*****************************
****************************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\c
harscalex100 {/* PROGRAM TO SHOW USAGE OF TYPEDEF keyword}\fs16\cf0\f0\charscale
x100 {
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscal
ex100 {/*********************************************************/}\par\pard\li2
360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {typedef unsigned short int UN

SHORTINT;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {typede
f char* STRING;}\par\pard\li2360\ri0\sl-266\slmult0 \fs16\cf0\f0\charscalex100 {
main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { short int y = 56765;
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { UNSHORTINT x
= 56765;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { STRIN
G s = "Test";}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
printf("String is %s Number is %d\\n", s, y);}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { printf("String is %s Number is %d\\n", s, x);}
360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\s
l-280\slmult0 \fs16\cf0\f0\charscalex100 {String is Test Number is -8771}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {String is Test Number
is 56765}\par\pard\li1226\ri0\sl-480\slmult0 \fs22\cf0\f0\charscalex100 {4. Pro
gram shows the usage of the enum keyword. The program shows how the enum keyword
}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {assigns the fir
st variable (MATHS) a value 2 and subsequent variable (PHYSICS) automatically}\p
ar\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {a value 3. Also, l
ook at the way we break this increment by starting another sequence with}\par\pa
rd\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {CHEMISTRY.}\par\pard\li
2360\ri0\sl-293\slmult0 \fs12\cf0\f0\charscalex100 {/***************************
*************************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 {/* PROGRAM TO SHOW THE USAGE OF enum keyword}\fs16\cf0\f0\charscalex1
00 {
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/
****************************************************/}\par\pard\li2360\ri0\sl-24
0\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0
\fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 { enum \{MATHS = 2, PHYSICS, CHEMISTRY = 7, BOTANY, ZOOLOGY\};}\
par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nMATH
S = %d\\n", MATHS);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex1
00 { printf("\\nPHYSICS = %d\\n", PHYSICS);}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { printf("\\nCHEMISTRY = %d\\n", CHEMISTRY);}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nBOTANY =
%d\\n", BOTANY);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{ printf("\\nZOOLOGY = %d\\n", ZOOLOGY);}\par\pard\li2360\ri0\sl-213\slmult0 \f
s14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\ch
arscalex100 {Output}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex1
00 {MATHS = 2}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {PH
YSICS = 3}\par\pard\li2360\ri0\sl-306\slmult0 \fs16\cf0\f0\charscalex100 {CHEMIS
TRY = 7}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {BOTANY =
8}\par\pard\li2360\ri0\sl-306\slmult0 \fs16\cf0\f0\charscalex100 {ZOOLOGY = 9}\
\fs18\cf0\f0\charscalex100 {7}\par\pard\sect\sectd\sbkpage
7;32768}}

0\f0\charscalex100 {5. Program shows the usage of the enum keyword. In this prog
ram we have extended the usage of}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\
f0\charscalex100 {the enum keyword. We have declared a variable to be of enum ty
pe. Note how we can use the}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\cha
rscalex100 {individual components of the enumerated variable.}\par\pard\li2360\r
i0\sl-386\slmult0 \fs12\cf0\f0\charscalex100 {/*********************************
*********************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 {/* PROGRAM SHOWING USAGE OF ENUM VARIABLE}\fs16\cf0\f0\charscalex100 {
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/**
****************************************************/}\par\pard\li2360\ri0\sl-37
3\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0
\fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 { enum subject \{MATHS = 2, PHYSICS, CHEMISTRY = 7, BOTANY, ZOOL
OGY\};}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { enum su
bject mysub;}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 { m
ysub = MATHS + PHYSICS;}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charsca
lex100 { printf("\\nTotal credit for my subjects is %d", mysub);}\par\pard\li23
60\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\n\\nZOOLOGY has a
credit of %d", ZOOLOGY);}\par\pard\li2360\ri0\sl-386\slmult0 \fs14\cf0\f0\charsc
alex100 {\}}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Outp
ut}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Total credit
for my subjects is 5}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex
100 {ZOOLOGY has a credit of 9}\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par
0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl213\slmult0 \fs18\cf0\par\pard\li5186\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li51
0 \fs18\cf0\f0\charscalex100 {8}\par\pard\sect\sectd\sbkpage

7;32768}}
harscalex100 {OPERATORS AND EXPRESSIONS}\par\pard\li1226\ri0\sl-466\slmult0 \fs2
2\cf0\f0\charscalex100 {1. We will now write a program that will accept a four-d
igit number and find the sum of its digits.}\par\pard\li1520\ri0\sl-266\slmult0
\fs22\cf0\f0\charscalex100 {The principle used in this program is the modulo ope
rator, which yields a reminder when one}\par\pard\li1520\ri0\sl-266\slmult0 \fs2
0\cf0\f0\charscalex100 {number is divided by another number and integer division
gives only an integer as result}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f
0\charscalex100 {(quotient), truncating the decimal portion. You can extend this
program using loops to find the}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f
0\charscalex100 {sum of any number.}\par\pard\li2360\ri0\sl-320\slmult0 \fs12\cf
0\f0\charscalex100 {/***********************************************************
*********/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/*
PROGRAM TO FIND THE SUM OF DIGITS
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/******
*************************************************************/}\par\pard\li2360\
16\cf0\f0\charscalex100 { int number;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16

\cf0\f0\charscalex100 { int f1,f2,f3,f4,sum;}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 { printf("Enter a four digit number whose digits a
re to be added : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 { scanf("%d",&number);}\par\pard\li2360\ri0\sl-280\slmult0 \fs16\cf0\f0\cha
rscalex100 { f1 = number / 1000; /* integer division to extract first digit */}
\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { f2 = number %
1000; /* extracts the last three digits */}\par\pard\li2360\ri0\sl-213\slmult0 \
fs16\cf0\f0\charscalex100 { f2 = f2 / 100; /* integer division to extract first
digit */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { f3 =
number % 100; /* extract last two digits only */}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs16\cf0\f0\charscalex100 { f3 = f3 / 10;}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs16\cf0\f0\charscalex100 { f4 = number % 10;}\par\pard\li2360\ri0\sl-21
3\slmult0 \fs16\cf0\f0\charscalex100 { sum = f1 + f2 + f3 + f4;}\par\pard\li236
0\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nSum of digits of %
d is %d",number,sum);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscale
x100 { \}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Output
}\par\pard\li2360\ri0\sl-240\slmult0 \fs16\cf0\f0\charscalex100 {Enter a four di
git number whose digits are to be added : 2398}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 {Sum of digits of 2398 is 22}\par\pard\li2360\ri0\
sl-320\slmult0 \fs16\cf0\f0\charscalex100 {Enter a four digit number whose digit
s are to be added : 9876}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsc
alex100 {Sum of digits of 9876 is 30}\par\pard\li1226\ri0\sl-400\slmult0 \fs22\c
f0\f0\charscalex100 {2. Let us understand through another simple program, the re
sult of expressions where we declare}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\c
f0\f0\charscalex100 {the variables as float. Note that when one of the operands
is turned to be a float, we get a proper}\par\pard\li1520\ri0\sl-266\slmult0 \fs
22\cf0\f0\charscalex100 {result.}\par\pard\li2360\ri0\sl-400\slmult0 \fs12\cf0\f
0\charscalex100 {/*********************************************************/}\pa
r\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/*
}\fs16
\cf0\f0\charscalex100 {FLOATING POINT DIVISION ILLUSTRATION}\fs16\cf0\f0\charsca
lex100 {
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex10
0 {/*********************************************************/}\par\pard\li2360\
16\cf0\f0\charscalex100 { float n1,n2,n3,n4,n5,n6,n7;}\par\pard\li2360\ri0\sl-2
93\slmult0 \fs16\cf0\f0\charscalex100 { n1 = 11/15;}\par\pard\li2360\ri0\sl-213
\slmult0 \fs16\cf0\f0\charscalex100 { n2 = 11/15.0;}\par\pard\li2360\ri0\sl-213
\slmult0 \fs16\cf0\f0\charscalex100 { n3 = 11.0/15;}\par\pard\li2360\ri0\sl-213
\slmult0 \fs16\cf0\f0\charscalex100 { n4 = 11.0/15.0;}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 { n5 = 11/(float)15;}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { n6 = 11.0/(float)15;}\par\pard\li5
186\ri0\sl-360\slmult0 \fs18\cf0\f0\charscalex100 {9}\par\pard\sect\sectd\sbkpag
e
7;32768}}

0\f0\charscalex100 { n7 = (float)(11/15);}\par\pard\li2360\ri0\sl-360\slmult0 \
fs16\cf0\f0\charscalex100 { printf("Operands are 11 and 15");}\par\pard\li2360\
ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nInteger over integer
is %f",n1);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { p
rintf("\\nInteger over float is %f",n2);}\par\pard\li2360\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 { printf("\\nFloat over integer is %f",n3);}\par\pard\l
i2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nFloat over flo
at is %f",n4);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
printf("\\nInteger over (floatcast)integer is %f",n5);}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nfloat over (floatcast)integ
er is %f",n6);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {
printf("\\n(floatcast)Integer over integer is %f",n7);}\par\pard\li2360\ri0\sl213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \
fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-240\slmult0 \fs16\cf0\
f0\charscalex100 {Operands are 11 and 15}\par\pard\li2360\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 {Integer over integer is 0.000000}\par\pard\li2360\ri0\s
l-213\slmult0 \fs16\cf0\f0\charscalex100 {Integer over float is 0.733333}\par\pa
rd\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Float over integer is 0
.733333}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Float ov
er float is 0.733333}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 {Integer over (floatcast)integer is 0.733333}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs16\cf0\f0\charscalex100 {float over (floatcast)integer is 0.733333}\par\
pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {(floatcast)Integer ov
er integer is 0.000000}\par\pard\li1226\ri0\sl-293\slmult0 \fs22\cf0\f0\charscal
ex100 {3. Let us understand the shift operators through a simple program. When w
e right shift a value, a}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charsc
alex100 {zero is added in the left of the binary equivalent of the number. This
is indirectly dividing the}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\char
scalex100 {number by 2. When we left shift a number, we indirectly multiply the
number by 2. Also, when}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charsca
lex100 {an odd number is shifted, the result is always rounded. For example, 12
>> 2 gives 3 (this is 12}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charsc
alex100 {/ 2 = 6; 6 / 2 = 3 one division by 2 for each shift), whereas 13 >> 1
will give only 6 (13 / 2 = 6}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\ch
arscalex100 { decimal portion is truncated).}\par\pard\li2360\ri0\sl-413\slmult0
\fs12\cf0\f0\charscalex100 {/**************************************************
****/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/*
SHIFT OPERATORS
*/}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs12\cf0\f0\charscalex100 {/************************************************
******/}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {main()}\
par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li23
60\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int a,b;}\par\pard\li2360\r
i0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 { printf("Enter a number (integer
) : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf
("%d",&a);}\par\pard\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 { b
= a >> 2;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { pri
n}\fs16\cf0\f0\charscalex100 {tf("\\nValue when right shifted by 2 is %d",b);}\p
ar\pard\li2360\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 { b = a << 3;}\pa
r\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nValue
when left shifted by 3 is %d",b);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0
\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscale
x100 {Output}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 {Ent
er a number (integer) : 12}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 {Value when right shifted by 2 is 3}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 {Value when left shifted by 3 is 96}\par\pard\li236
0\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {Enter a number (integer) : 13}\
par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Value when right
shifted by 2 is 3}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{Value when left shifted by 3 is 104}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\
cf0\par\pard\li5133\ri0\sl-280\slmult0 \fs18\cf0\f0\charscalex100 {10}\par\pard\
sect\sectd\sbkpage
7;32768}}
0\f0\charscalex100 {4. Let us now understand the XOR (exclusive OR) operator. Th
is is widely used for encoding and}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0
\f0\charscalex100 {decoding purposes. When you XOR string (or character) with a
character (this is called the key),}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf
0\f0\charscalex100 {you get a result. This is an encoded form. When you again XO
R the result (encoded form) with}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f
0\charscalex100 {the same key, you will get back the original character. If you
XOR the encoded string with a}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\c
harscalex100 {different key, you will not get back the original string. The prog
ram shown below illustrates this}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f
0\charscalex100 {concept.}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard
\li2360\ri0\sl-253\slmult0 \fs12\cf0\f0\charscalex100 {/************************
***********************************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\c
f0\f0\charscalex100 {/*
}\fs16\cf0\f0\charscalex100 {USAGE OF XOR FOR EN
CODING and DECODING}\fs16\cf0\f0\charscalex100 {
*/}\par\pard\li2360\ri
0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/**********************************
scalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100
{\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char a =
'A';}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char b =
'*';}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char c =
'/';}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char d;}\
par\pard\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 { d = a ^ b;}\par
\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\n\\n%c w
hen encoded using %c gives %c",a,b,d);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16
\cf0\f0\charscalex100 { a = d ^ b;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 { printf("\\n\\n%c when decoded using %c gives %c",d,b,a);}\
par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 { a = d ^ c;}\par
\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\n\\n%c w
hen decoded using %c gives %c",d,c,a);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14
\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\chars
calex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100
{A when encoded using * gives k}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0
\charscalex100 {k when decoded using * gives A}\par\pard\li2360\ri0\sl-400\slmul
t0 \fs16\cf0\f0\charscalex100 {k when decoded using / gives D}\par\pard\li5133\r
i0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\par
d\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\c
f0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmul
t0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl
-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5
133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\pa
r\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \f
s18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\
slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\r
d\li5133\ri0\sl-400\slmult0 \fs18\cf0\f0\charscalex100 {11}\par\pard\sect\sectd\
sbkpage

7;32768}}
harscalex100 {MANAGING INPUT AND OUTPUT OPERATIONS}\par\pard\li1226\ri0\sl-466\s
lmult0 \fs22\cf0\f0\charscalex100 {1. When dealing with string input and output,
the scanf and prinf will not be handy when the string}\par\pard\li1520\ri0\sl-2
66\slmult0 \fs22\cf0\f0\charscalex100 {has an embedded space character. For exam
ple, you may not be able to input the string}\par\pard\li1520\ri0\sl-266\slmult0
\fs20\cf0\f0\charscalex100 {Programming Language. If you do so, only the string
Programming will be stored in the}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0
\f0\charscalex100 {variable and the string Language will be left out. To avoid t
his, C has two other functions}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\
charscalex100 {gets() and puts(). Look at the program given. Note that printf()
is capable of printing the string}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\
f0\charscalex100 {with embedded spaces.}\par\pard\li2360\ri0\sl-240\slmult0 \fs1
2\cf0\f0\charscalex100 {/*******************************************************
/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/*
STR
ING INPUT and OUTPUT
*/}\par\pard\li2360\ri0\sl-213\slmult0
\fs12\cf0\f0\charscalex100 {/***************************************************
****/}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {main()}\pa
r\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360
\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char mystring[100];}\par\pard\

li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnter a strin
g : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { gets(m
ystring); /* gets is string input */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\c
f0\f0\charscalex100 { printf("\\nYou entered %s\\n",mystring);}\par\pard\li2360
\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 { puts("You entered");}\par\pard
\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { puts(mystring); /* puts
is string output */}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex
100 {\}}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {Output}\
par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 {Enter a string :
programming language}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 {You entered programming language}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 {You entered}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 {programming language}\par\pard\li1226\ri0\sl-413\slmult0 \fs22
\cf0\f0\charscalex100 {2. C supports two other indirect input and output functio
ns. These are sprintf() and sscanf(). The}\par\pard\li1520\ri0\sl-266\slmult0 \f
s20\cf0\f0\charscalex100 {sprintf() function behaves exactly same as the printf(
) function except that instead of sending the}\par\pard\li1520\ri0\sl-266\slmult
0 \fs20\cf0\f0\charscalex100 {result to the screen, the sprintf() function store
s the result in a string variable. The sscanf()}\par\pard\li1520\ri0\sl-266\slmu
lt0 \fs20\cf0\f0\charscalex100 {function works in the reverse way of sprintf(),
i.e. it reads from a string variable (as opposed to}\par\pard\li1520\ri0\sl-266\
slmult0 \fs20\cf0\f0\charscalex100 {scanf() function which reads from keyboard)
and stores the values in different variables. Look at}\par\pard\li1520\ri0\sl-26
6\slmult0 \fs20\cf0\f0\charscalex100 {the program given. The input variables a,
b, c and d are stored in mystring through fprintf(). The}\par\pard\li1520\ri0\sl
-266\slmult0 \fs22\cf0\f0\charscalex100 {sscanf() reads the mystring and distrib
utes the values to the variables x, y, m and n.}\par\pard\li2360\ri0\sl-333\slmu
lt0 \fs12\cf0\f0\charscalex100 {/***********************************************
***********/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/*
PROGRAM TO SHOW USAGE OF sprintf() and sscanf()}\fs16\cf0\f0\charscalex100 {
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/********
**************************************************/}\par\pard\li2360\ri0\sl-373\
slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \
fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\c
harscalex100 { int a,b,x,y;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\ch
arscalex100 { char resultstring[50];}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 { float c,d,m,n;}\par\pard\li2360\ri0\sl-346\slmult0 \fs16
\cf0\f0\charscalex100 { printf("\\nEnter two integers (separated by space): ");
}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult
0 \fs18\cf0\par\pard\li5133\ri0\sl-253\slmult0 \fs18\cf0\f0\charscalex100 {12}\p
ar\pard\sect\sectd\sbkpage
7;32768}}

0\f0\charscalex100 { scanf("%d %d",&a,&b);}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { printf("\\nEnter two floats (separated by space):
");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%f
%f",&c,&d);}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { sp
rintf(resultstring,"%d %d %f %f",a,b,c,d); /* sprintf adds to string */}\par\par
d\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("Full string is
: %s",resultstring);}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscale
x100 { sscanf(resultstring,"%d %d %f %f",&x,&y,&m,&n); /* sscanf reads from str
ing */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf(
"\\nx=%d \\ny=%d \\nm=%f \\nn=%f",x,y,m,n);}\par\pard\li2360\ri0\sl-213\slmult0
\fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\
charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscale
x100 {Enter two integers (separated by space): 12 45}\par\pard\li2360\ri0\sl-213
\slmult0 \fs16\cf0\f0\charscalex100 {Enter two floats (separated by space): 1.23
5.67}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Full strin
g is : 12 45 1.230000 5.670000}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 {x=12}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex1
00 {y=45}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {m=1.230
000}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {n=5.670000}\
par\pard\li1226\ri0\sl-413\slmult0 \fs22\cf0\f0\charscalex100 {3. Sometimes it m
ay be desirable to just press a character without any Enter key pressed after th
at.}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {The function
getchar() requires you to press Enter key after you type a character. Also, the
}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {getchar() will
allow you to enter more than one character before pressing Enter key, but will t
ake}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {into account
the first character only. C provides two other single character input functions
}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {getch() and get
che(). They will exactly take only one character as input and also they do not}\
par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {require you to pr
ess the Enter key. The function getche() will echo what you press while getch()}
\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {will not show on
the screen. You can use putch() or putchar() to display the value. Look at the}
\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {program.}\par\pa
rd\li2720\ri0\sl-333\slmult0 \fs12\cf0\f0\charscalex100 {/**********************
*****************************************/}\par\pard\li2720\ri0\sl-213\slmult0 \
fs16\cf0\f0\charscalex100 {/*
}\fs16\cf0\f0\charscalex100 {PROGRAM TO ILL
USTRATE getch() and getche()}\fs16\cf0\f0\charscalex100 {
*/}\par\pard
16\cf0\f0\charscalex100 {main()}\par\pard\li2706\ri0\sl-213\slmult0 \fs14\cf0\f0
\charscalex100 {\{}\par\pard\li2706\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex10
0 { char mychar;}\par\pard\li2706\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100
{ printf("Press a key (this will echo): ");}\par\pard\li2706\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 { mychar = getche();}\par\pard\li2706\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 { printf("\\nYou pressed ");}\par\pard\li2706
\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { putch(mychar);}\par\pard\li270
6\ri0\sl-253\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nPress a key (this
will not echo): ");}\par\pard\li2706\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex1
00 { mychar = getch();}\par\pard\li2706\ri0\sl-213\slmult0 \fs16\cf0\f0\charsca
lex100 { printf("\\nYou pressed ");}\par\pard\li2706\ri0\sl-213\slmult0 \fs16\c
f0\f0\charscalex100 { putch(mychar);}\par\pard\li2706\ri0\sl-213\slmult0 \fs14\
cf0\f0\charscalex100 {\}}\par\pard\li2706\ri0\sl-226\slmult0 \fs16\cf0\f0\charsc
alex100 {Output}\par\pard\li2706\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 {
Press a key (this will echo): A}\par\pard\li2706\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 {You pressed A}\par\pard\li2706\ri0\sl-213\slmult0 \fs16\cf0\f0\c
harscalex100 {Press a key (this will not echo):}\par\pard\li2706\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 {You pressed K}\par\pard\li5133\ri0\sl-373\slmult
0 \fs18\cf0\f0\charscalex100 {13}\par\pard\sect\sectd\sbkpage
harscalex100 {DECISION MAKING AND LOOPING}\par\pard\li1226\ri0\sl-466\slmult0 \f

s22\cf0\f0\charscalex100 {1. We will now extend the program to find the sum of d
igits of a given number. The program uses a}\par\pard\li1520\ri0\sl-266\slmult0
\fs22\cf0\f0\charscalex100 {while loop to keep track of the number of the digit
being added. The program also uses a function}\par\pard\li1520\ri0\sl-266\slmult
0 \fs20\cf0\f0\charscalex100 {(which we will study later) to compute the powers
of 10. This function (called power10) also}\par\pard\li1520\ri0\sl-266\slmult0 \
fs20\cf0\f0\charscalex100 {uses a while loop. The program has a sprintf() to con
vert the number to a string so that its length}\par\pard\li1520\ri0\sl-266\slmul
t0 \fs22\cf0\f0\charscalex100 {can be got.}\par\pard\li2360\ri0\sl-346\slmult0 \
fs12\cf0\f0\charscalex100 {/****************************************************
*************/}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {/
* Sum of digits - PROGRAM TO ILLUSTRATE THE USAGE OF while loop */}\par\pard\li2
360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/****************************
*************************************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs18
\cf0\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {#include <st
ring.h>}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {main()}\
60\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { int number,digit,len,sum;}\p
ar\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char n[20];}\par
\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int power10();}\pa
r\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnter
a number whose digits are to be added : ");}\par\pard\li2360\ri0\sl-226\slmult0
\fs16\cf0\f0\charscalex100 { scanf("%d",&number);}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 { sprintf(n,"%d",number); /* convert to strin
g to find number of digits */}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\c
harscalex100 { len = strlen(n); /* find the number of digits */}\par\pard\li236
0\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { len = len - 1; /* start off w
ith a digit lesser */}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2
360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { /* get first digit alone ou
tside the loop */}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100
{ digit = number / power10(len);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0
\f0\charscalex100 { sum = digit;}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\
f0\charscalex100 { while (len > 0)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf
0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsc
alex100 {
digit = }\fs16\cf0\f0\charscalex100 {number % power10(len);}\par\pa
rd\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
len = len - 1;}\par
digit = digit /
}\fs16\cf0\f0\charscalex100 {power10(len);}\par\pard\li2360\ri0\sl-213\slmult0 \
sum = sum + }\fs16\cf0\f0\charscalex100 {digit;}\
par\pard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li
2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\n Sum of digits
of %d is %d",number,sum);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\chars
calex100 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\s
l-240\slmult0 \fs16\cf0\f0\charscalex100 {/* function to find the powers of 10 *
/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {int power10(n)
}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {int n;}\par\par
d\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\
sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int p = 1;}\par\pard\li2360\ri0\sl
-226\slmult0 \fs16\cf0\f0\charscalex100 { w}\fs16\cf0\f0\charscalex100 {hile (
n > 0)}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { \{}\pa
p = p * 10;}\p
ar\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
n = n - 1;}\p
ar\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { \}}\par\pard\li
ar\pard\li5133\ri0\sl-280\slmult0 \fs18\cf0\f0\charscalex100 {14}\par\pard\sect\
sectd\sbkpage

7;32768}}
0\f0\charscalex100 { return(p);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\
f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li23
60\ri0\sl-240\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl
-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscale
x100 {Enter a number whose digits are to be added : 24578}\par\pard\li2360\ri0\s
l-213\slmult0 \fs16\cf0\f0\charscalex100 { Sum of digits of 24578 is 26}\par\par
f0\f0\charscalex100 {Enter a number whose digits are to be added : 98765}\par\pa
rd\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { Sum of digits of 98765
is 35}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-226\
slmult0 \fs14\cf0\f0\charscalex100 {Enter a number whose digits are to be added
: 99999}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { Sum of
digits of 99999 is 45}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1
226\ri0\sl-346\slmult0 \fs22\cf0\f0\charscalex100 {2. We will now develop a prog

ram to find the square root of a number using the iterative Newton-}\par\pard\li
1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {Raphson method. The method i
s based on the following:}\par\pard\li2706\ri0\sl-440\slmult0 \fs22\cf0\f0\chars
calex100 {X}\fs14\cf0\f0\charscalex100 {curr}\fs22\cf0\f0\charscalex100 { = 0.5
* (X}\fs14\cf0\f0\charscalex100 {prev}{ }\fs22\cf0\f0\charscalex100 {+ number /
X}\fs14\cf0\f0\charscalex100 {prev}\fs22\cf0\f0\charscalex100 {) where X}\fs14\
cf0\f0\charscalex100 {prev (initial) = 1.0}\par\pard\li1520\ri0\sl-400\slmult0 \
fs22\cf0\f0\charscalex100 {The second of the above expression will be executed i
n a loop till X}\fs14\cf0\f0\charscalex100 {prev}\fs22\cf0\f0\charscalex100 { an
d X}\fs14\cf0\f0\charscalex100 {curr}\fs22\cf0\f0\charscalex100 { matches. The}\
par\pard\li1506\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {value of either o
f the variables is the square root of the given number. We will use a dowhile}\p
ar\pard\li1506\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {loop.}\par\pard\li
2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-226\slmult0 \fs12\cf0\f
0\charscalex100 {/**************************************************************
***/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* PROGRAM
TO COMPUTE SQUARE ROOT USING NEWTON-}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 {RAPHSON METHOD}\fs16\cf0\f0\charscalex100 { */}\par\pard
\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* PROGRAM ILLUSTRATES T
HE USAGE OF THE DO...WHILE}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 {LOOP
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\char
scalex100 {/*****************************************************************/}\
par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\
li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl
-213\slmult0 \fs16\cf0\f0\charscalex100 { float xprev,xcurr,number;}\par\pard\
li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnter the num
ber whose square root is required : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
6\cf0\f0\charscalex100 { scanf("%f",&number);}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { xcurr = 1.0;}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 { do}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0
\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsca
lex100 {
xprev = xcurr;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 {
}\fs16\cf0\f0\charscalex100 {xcurr = 0.5 * (xprev + (number / xpr
ev));}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16
\cf0\f0\charscalex100 {printf("\\n%f %f",xcurr,xprev);}\par\pard\li2360\ri0\sl213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { while(xprev != xcurr);}\par\pard\li2360\ri0\sl-21
3\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\n\\nThe square root of the num
ber is %f\\n",xcurr);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscale
x100 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Output}
\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter the number
whose square root is required : 4}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0
\f0\charscalex100 {2.500000 1.000000}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 {2.050000 2.500000}\par\pard\li2360\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 {2.000610 2.050000}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 {2.000000 2.000610}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 {2.000000 2.000000}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs16\cf0\f0\charscalex100 {The square root of the number is 2.000000}\par
\pard\li5133\ri0\sl-253\slmult0 \fs18\cf0\f0\charscalex100 {15}\par\pard\sect\se
ctd\sbkpage

7;32768}}
0\f0\charscalex100 {3. Let us now write a program to find all the factors of a g
iven number. If the number is a prime}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\
cf0\f0\charscalex100 {number, the program displays that it is prime. The program
is written using a}{ }\fs22\cf0\f0\charscalex100 {for}\fs22\cf0\f0\charscalex10
0 { loop and uses}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100
{the initialization using comma operator in the}{ }\fs22\cf0\f0\charscalex100 {
for}{ }\fs22\cf0\f0\charscalex100 {statement itself.}\par\pard\li2360\ri0\sl-213
\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-253\slmult0 \fs16\cf0\f0\charscalex100
{/* Program to find the factors of number using for loop}\fs16\cf0\f0\charscale
x100 {
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\
sl-226\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\c
f0\f0\charscalex100 { int number,i,prime;}\par\pard\li2360\ri0\sl-213\slmult0 \
fs18\cf0\par\pard\li2360\ri0\sl-240\slmult0 \fs16\cf0\f0\charscalex100 { printf
("Enter the number whose factors are to be found : ");}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d", &number);}\par\pard\li2360\
rscalex100 { /* notice the use of comma operator in for statement */}\par\pard\
\f0\charscalex100 { for (prime=1,i=2; i <= (number / 2); i++)}\par\pard\li2360\
ri0\sl-226\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\
if }\fs16\cf0\f0\charscalex100 {((number
% i) == 0)}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
if }\fs
16\cf0\f0\charscalex100 {(prime)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f
0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("The factors of %d are:
\\n", number);}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
prime = 0;}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100
{
prin}\fs16\cf0\f0\charscalex100 {tf("%d, ", i);}\par\pard\li2360\ri0\sl-2
\}}\par\pard\li2360\ri0\sl-226\slmult
0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0
\f0\charscalex100 { if (prime)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("%d is a prime number",
number);}\par\pard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par
16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\pa
r\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {Enter the number wh
ose factors are to be found : 180}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 {The factors of 180 are:}\par\pard\li2360\ri0\sl-226\slmult0 \f
s16\cf0\f0\charscalex100 {2, 3, 4, 5, 6, 9, 10, 12, 15, 18, 20, 30, 36, 45, 60,
90,}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-226\slm
ult0 \fs16\cf0\f0\charscalex100 {Enter the number whose factors are to be found
: 78}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {The factors
of 78 are:}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {2, 3
, 6, 13, 26, 39,}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\r
i0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {Enter the number whose factors are
to be found : 13}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100
{13 is a prime number}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li
1226\ri0\sl-373\slmult0 \fs22\cf0\f0\charscalex100 {4. We will look at one more
example using nested for loop. We will find out the list of numbers that}\par\pa
rd\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {are perfect within a gi
ven range. A perfect number is one whose sum of factors (including 1) is}\par\pa
rd\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {the number itself. For
example, 6 = 1 + 2 + 3. The outer for loop enumerates the number range}\par\pard
\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {while the inner for loop
identifies the factors one by one.}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0
\fs18\cf0\par\pard\li5133\ri0\sl-293\slmult0 \fs18\cf0\f0\charscalex100 {16}\pa
r\pard\sect\sectd\sbkpage
7;32768}}
0\f0\charscalex100 {/***********************************************************
****/}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {/* Progra
m to illustrate nested for loop and also}\fs16\cf0\f0\charscalex100 {
*/}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {/* for loo
p with different increment}\fs16\cf0\f0\charscalex100 {
*/}\par\pard\li2360\ri0\sl-226\slmult0 \fs10\cf0\f0\charscalex100 {/***********
****************************************************/}\par\pard\li2360\ri0\sl-21
0 {main()}\par\pard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\charscalex100 {\{}\pa
r\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { int i,sum,numberc
urr;}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { int numbe
r,endnumber;}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\s
l-240\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnter the maximum number

upto which search will go on : ");}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0
\f0\charscalex100 { scanf("%d",&endnumber);}\par\pard\li2360\ri0\sl-213\slmult0
\fs18\cf0\par\pard\li2360\ri0\sl-240\slmult0 \fs16\cf0\f0\charscalex100 { /* y
ou need not search the odd numbers..they will never be perfect */}\par\pard\li23
60\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-253\slmult0 \fs16\cf0\f0\
charscalex100 { for (number = 2 ; number < endnumber ; number = number + 2)}\pa
r\pard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li23
}\fs16\cf0\f0\charscalex10
0 {sum = 0;}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {numbercurr = number;}\par\pard\li2360\ri0\sl-226\sl
mult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {for (i = 1; i
< numbercurr; i++)}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex1
00 {
if }\fs16\cf0\f0\charscalex100 {(number % i == 0)}\par\pard\li2360\ri0\sl-226\s
lmult0 \fs16\cf0\f0\charscalex100 {
\{}\par\pard\li3893\ri0\sl-226\slmult0
sum = sum + i;}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs18\cf0\par\pard\li2360\ri0\sl-253\slmult0 \fs16\cf0\f0\charscalex100 {
/* in }\fs16\cf0\f0\charscalex100 {this portion we find the corresponding ot
her factor */}\par\pard\li3240\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li3240\ri0\
if }\fs16\cf0\f0\charscalex100 {(
number / i != number)}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscale
x100 {
\{}\par\pard\li3000\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100
{
}\fs16\cf0\f0\charscalex100 {sum = sum + (number / i);}\par\pard\li3080\
ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
numbercurr = number / i;}\
par\pard\li4893\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
\}}\par\pard\
li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
\}}\par\pard\li2360\
\}}\par\pard\li2360\ri0\sl-21
0 {
if }\fs16\cf0\f0\charscalex100 {(sum == number)}\par\pard\li2360\ri0\sl-2
printf}\fs16\cf0\f0\charscalex100 {
("%d is a perfect number\\n", number);}\par\pard\li2360\ri0\sl-226\slmult0 \fs14
\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\char
scalex100 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\
sl-240\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs18\cf0\par\pard\li2360\ri0\sl-240\slmult0 \fs16\cf0\f0\charscalex100 {E
nter the maximum number upto which search will go on : 1000}\par\pard\li2360\ri0
\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-240\slmult0 \fs16\cf0\f0\charsc
alex100 {6 is a perfect square}\par\pard\li2360\ri0\sl-240\slmult0 \fs16\cf0\f0\
charscalex100 {28 is a perfect square}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\
cf0\f0\charscalex100 {496 is a perfect square}\par\pard\li5133\ri0\sl-213\slmult
0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl280\slmult0 \fs18\cf0\f0\charscalex100 {17}\par\pard\sect\sectd\sbkpage
7;32768}}

0\f0\charscalex100 {5. We will write a simple program that will demonstrate the
usage of the break keyword. The}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0
\charscalex100 {program will accept a number and identify if it is a prime or co
mposite number. Even if one}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\cha
rscalex100 {factor is found, the program will break the}{ }\fs22\cf0\f0\charscal
ex100 {for}\fs22\cf0\f0\charscalex100 { loop.}\par\pard\li2360\ri0\sl-213\slmult
0 \fs18\cf0\par\pard\li2360\ri0\sl-240\slmult0 \fs12\cf0\f0\charscalex100 {/****
************************************************/}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs16\cf0\f0\charscalex100 {/* PROGRAM TO SHOW USAGE OF break}\fs16\cf0\f0
\charscalex100 {
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\
cf0\f0\charscalex100 {/****************************************************/}\pa
r\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li
2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 { int i, number, flag;}\par\pard\li2360\r
i0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnter a number to be
tested : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { s
canf("%d",&number);}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex1
00 { for (i = 2; i <= number / 2; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
4\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\ch
arscalex100 {
flag = 0;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 {
if }\fs16\cf0\f0\charscalex100 {(number % i == 0)}\par\pard\li236
\{}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {flag
= 1;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
br}\f
s16\cf0\f0\charscalex100 {eak;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 {
\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscale
x100 { \}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { if
(flag == 1)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("%d is a composite number",number);}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { else}\par\pard\li236
00 {printf("%d is a prime number",number);}\par\pard\li2360\ri0\sl-213\slmult0 \
fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\c
harscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex
100 {Enter a number to be tested : 13}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 {13 is a prime number}\par\pard\li2360\ri0\sl-386\slmult0 \
fs16\cf0\f0\charscalex100 {Enter a number to be tested : 15}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {15 is a composite number}\par\pard\l
i5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\
\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\p
ard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18
\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slm
ult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\
sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\l
i5133\ri0\sl-426\slmult0 \fs18\cf0\f0\charscalex100 {18}\par\pard\sect\sectd\sbk
page
7;32768}}
0\f0\charscalex100 {6. Binary to Decimal ConverterThis program will accept a bin
ary integer number and convert to}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\
f0\charscalex100 {its equivalent decimal integer number. The core logic is the s
eparation of the digits in the input}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\c
f0\f0\charscalex100 {number.}\par\pard\li2360\ri0\sl-333\slmult0 \fs12\cf0\f0\ch
arscalex100 {/*****************************************************************/
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* Conversion o
f Binary integer to Decimal integer}\fs16\cf0\f0\charscalex100 {
*
/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/*************
****************************************************/}\par\pard\li2360\ri0\sl-37
3\slmult0 \fs16\cf0\f0\charscalex100 {#include <string.h>}\par\pard\li2360\ri0\s
l-213\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 { int number,digit,len,sum;}\par\pard\li2360\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 { char n[20];}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 { int power();}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { printf("\\nEnter a binary number : ");}\par\pard\
li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d",&number);}\pa
r\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { sprintf(n,"%d",nu
mber); /* convert to string to find number of digits */}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 { len = strlen(n); /* find the number of
digits */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { len
= len - 1; /* start off with a digit lesser */}\par\pard\li2360\ri0\sl-266\slmu
lt0 \fs16\cf0\f0\charscalex100 { /* get first digit alone outside the loop */}\
par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { digit = number
/ power(len,10);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{ sum = digit * power (len,2); /* raise to power 2 */}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 { while (len > 0)}\par\pard\li2360\ri0\sl
-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {digit = number %
power(len,10);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
len = len - 1;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{
digit = digit / }\fs16\cf0\f0\charscalex100 {power(len,10);}\par\pard\li23
sum = sum + (digit * }\fs1
6\cf0\f0\charscalex100 {power (len,2));}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
4\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\ch
arscalex100 { printf("\\n Decimal equivalent of %d is %d",number,sum);}\par\par
d\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\
sl-253\slmult0 \fs16\cf0\f0\charscalex100 {/* function to find the powers */}\pa
r\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {int power(n,m)}\par
\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {int n,m;}\par\pard\l
i2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 { int p = 1;}\par\pard\li2360\ri0\sl-21
3\slmult0 \fs16\cf0\f0\charscalex100 { w}\fs16\cf0\f0\charscalex100 {hile (n >
0)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { \{}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
p = p * m;}\par\p
n = n - 1;}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { \}}\par\pard\li2360
\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { return(p);}\par\pard\li2360\r
i0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-240\slm
ult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-413\slmult0 \fs1
6\cf0\f0\charscalex100 {Enter a binary number : 1001}\par\pard\li2360\ri0\sl-213
\slmult0 \fs16\cf0\f0\charscalex100 {Decimal equivalent of 1001 is 9}\par\pard\l
i2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 {Enter a binary number : 111
1}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Decimal equiva
lent of 1111 is 15}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133
\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-333\slmult0 \fs18\cf0\f0\ch
arscalex100 {19}\par\pard\sect\sectd\sbkpage
harscalex100 {ARRAYS}\par\pard\li1226\ri0\sl-466\slmult0 \fs22\cf0\f0\charscalex
100 {1. The next program is to find from a list of numbers, the smallest and lar
gest numbers. The array is}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\char
scalex100 {not sorted. The program should also show the positions of these numbe
rs.}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-266\slm
ult0 \fs12\cf0\f0\charscalex100 {/**********************************************
*******************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 {/* PROGRAM TO SHOW THE USAGE OF ONE-DIMENSIONAL ARRAY */}\par\pard\li2360\r
********************************/}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\
f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charsc
alex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int
i,smallest,largest,smallpos,largepos,count,getval;}\par\pard\li2360\ri0\sl-213\
slmult0 \fs16\cf0\f0\charscalex100 { int numbers[100];}\par\pard\li2360\ri0\sl360\slmult0 \fs16\cf0\f0\charscalex100 { /* Array input */}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnter number of numbers
in the list : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex10
0 { scanf("%d",&count);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsc
alex100 { for (i=0; i<count; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0
\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsca
lex100 {
}\fs16\cf0\f0\charscalex100 {printf("\\nEnter number[%d] : ",i);}\pa
}\fs16\cf0\f0\c
harscalex100 {scanf("%d",&getval);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0
\f0\charscalex100 {
num}\fs16\cf0\f0\charscalex100 {bers[i] = getval;}\par\pa
rd\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li2360\r
i0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 { /* Array display */}\par\pard\li
2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nGiven array is
: ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for (i=0
; i<count; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
prin}\fs16\cf0\f0\charscalex100 {tf("%d,",numbers[i]);}\par\pard\li2360\ri0
\sl-360\slmult0 \fs16\cf0\f0\charscalex100 { smallest = 9999; /* guess for smal
lest */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { larges
t = -9999; /* guess for largest */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0
\f0\charscalex100 { smallpos = largepos = 0;}\par\pard\li2360\ri0\sl-373\slmult
0 \fs16\cf0\f0\charscalex100 { for (i=0; i<count; i++)}\par\pard\li2360\ri0\sl213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0
if (}\fs16\cf0\f0\charscalex100 {smallest > num
bers[i])}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
\{}
\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
sm}\fs16\
cf0\f0\charscalex100 {allest = numbers[i];}\par\pard\li2360\ri0\sl-213\slmult0 \
sm}\fs16\cf0\f0\charscalex100 {allpos = i;}\pa
\}}\par\pard\li
if }\fs16\cf0\f0\charsca
lex100 {(largest < numbers[i])}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 {
\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscale
x100 {
l}\fs16\cf0\f0\charscalex100 {argest = numbers[i];}\par\pard\li2360
\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
lar}\fs16\cf0\f0\charscal
ex100 {gepos = i;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{
\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { \}}\
par\pard\li2360\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nSma
llest number is %d found at position %d",smallest,smallpos);}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { prin}\fs16\cf0\f0\charscalex100
{tf("\\nLargest number is %d found at position %d",largest,largepos);}\par\pard\
li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li5133\ri0\sl
-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5
133\ri0\sl-293\slmult0 \fs18\cf0\f0\charscalex100 {20}\par\pard\sect\sectd\sbkpa
ge

0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\char
scalex100 {Enter number of numbers in the list : 5}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 {Enter number[0] : 3}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 {Enter number[1] : 12}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter number[2] : 56}\par\pard\li236
0\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter number[3] : 2}\par\pard\l
i2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter number[4] : 44}\par\p
ard\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 {Given array is : 3,12,
56,2,44,}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Smalles
t number is 2 found at position 3}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 {Largest number is 56 found at position 2}\par\pard\li1226\ri0\
sl-213\slmult0 \fs18\cf0\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard\l
i1226\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {2. The next program is to r
everse the given array. The program simply reads each array element and}\par\par
d\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {swaps with the correspon
ding mirror element. While swapping, the program uses a temporary}\par\pard\li15
20\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {variable. The looping must be
done only up to half of the array size.}\par\pard\li2360\ri0\sl-400\slmult0 \fs1

2\cf0\f0\charscalex100 {/*******************************************************
**********/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* P
ROGRAM TO SHOW THE USAGE OF ONE-DIMENSIONAL ARRAY */}\par\pard\li2360\ri0\sl-226
\slmult0 \fs12\cf0\f0\charscalex100 {/******************************************
***********************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\
li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri
0\sl-226\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 { int i,count,getval,temp,j;}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int numbers[100];}\par\pard\li2360
\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-240\slmult0 \fs16\cf0\f0\ch
arscalex100 { /* Array input */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f
0\charscalex100 { printf("\\nEnter number of numbers in the list : ");}\par\par
d\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d",&count);}\p
ar\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for (i=0; i<coun
t; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\pa
}\fs16\cf0\f0\c
harscalex100 {printf("\\nEnter number[%d] : ",i);}\par\pard\li2360\ri0\sl-226\sl
}\fs16\cf0\f0\charscalex100 {scanf("%d",&g
etval);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
num}
\fs16\cf0\f0\charscalex100 {bers[i] = getval;}\par\pard\li2360\ri0\sl-226\slmult
0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-426\slmult0 \fs16\cf0
\f0\charscalex100 { /* Array display */}\par\pard\li2360\ri0\sl-226\slmult0 \fs
16\cf0\f0\charscalex100 { printf("\\nGiven array is : ");}\par\pard\li2360\ri0\
sl-226\slmult0 \fs16\cf0\f0\charscalex100 { for (i=0; i<count; i++)}\par\pard\l
i2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
prin}\fs16\cf0\f0\char
scalex100 {tf("%d,",numbers[i]);}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\p
ar\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { j = 1;}\par\pard
\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for (i=0; i<count/2; i+
+)}\par\pard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\par
d\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
temp = num}\fs16\cf0
\f0\charscalex100 {bers[i];}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\cha
rscalex100 {
}\fs16\cf0\f0\charscalex100 {numbers[i] = numbers[count-j];}\par
num}\fs16\cf0\f0
\charscalex100 {bers[count-j] = temp;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
j = j + 1;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\c
f0\f0\charscalex100 { \}}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard
\li5133\ri0\sl-400\slmult0 \fs18\cf0\f0\charscalex100 {21}\par\pard\sect\sectd\s
bkpage
0\f0\charscalex100 { printf("\\nReversed array is : ");}\par\pard\li2360\ri0\sl
-213\slmult0 \fs16\cf0\f0\charscalex100 { for (i=0; i<count; i++)}\par\pard\li2
prin}\fs16\cf0\f0\charsc
alex100 {tf("%d,",numbers[i]);}\par\pard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\
charscalex100 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\
ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {Enter number of numbers in the li
st : 5}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter num
ber[0] : 3}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter
number[1] : 12}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
Enter number[2] : 56}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex
100 {Enter number[3] : 2}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsc
alex100 {Enter number[4] : 44}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\
pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {Given array is : 3,12
,56,2,44,}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Revers
ed array is: 44,2,56,12,3}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard
\li1226\ri0\sl-360\slmult0 \fs22\cf0\f0\charscalex100 {3. This program is to fin
d the LCM of two numbers. The program uses two arrays for multiples of}\par\pard
\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {each number. An array mat
ching is done to find the common element. Though a greedy method to}\par\pard\li
1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {find LCM is available, this
method is given here to highlight the usage of multiple single}\par\pard\li1520\
ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {dimension arrays, array matching
and nested for loops.}\par\pard\li2360\ri0\sl-320\slmult0 \fs12\cf0\f0\charscale
x100 {/************************************************************/}\par\pard\l
i2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* PROGRAM TO FIND THE LCM
OF TWO GIVEN NUMBERS
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 {/* TWO SINGLE DIMENSION ARRAYS ARE USED - ONE FOR EACH MULTI
PLE */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* WHEN A
MATCH BETWEEN ARRAYS IS FOUND, LCM IS GOT
*/}\par\pard\li2360\ri0\sl-21
3\slmult0 \fs12\cf0\f0\charscalex100 {/*****************************************
*******************/}\par\pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex
100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\
par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { long int firsta

rr[100],secondarr[100];}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsca
lex100 { int firstnum,secondnum,i,j,multiple,flag,lcm;}\par\pard\li2360\ri0\sl360\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnter the first number : ")
;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d",&
firstnum);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { pri
ntf("\\nEnter the second number : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 { scanf("%d",&secondnum);}\par\pard\li2360\ri0\sl-360\slmu
lt0 \fs16\cf0\f0\charscalex100 { /* fill the arrays with the multiples */}\par\
pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { multiple = 0;}\par\
pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for (i=0; i<100; i+
}\fs16\cf0\f0\charsc
alex100 {multiple = multiple + firstnum;}\par\pard\li2360\ri0\sl-213\slmult0 \fs
first}\fs16\cf0\f0\charscalex100 {arr[i] = multiple
;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\pard
\li2360\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 { multiple = 0;}\par\pard
\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for (i=0; i<100; i++)}\
par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li
multiple = multiple + }\
fs16\cf0\f0\charscalex100 {secondnum;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
}\fs16\cf0\f0\charscalex100 {secondarr[i] = multiple;}
\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\l
i2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 { flag = 0;}\par\pard\li513
harscalex100 {22}\par\pard\sect\sectd\sbkpage

0\f0\charscalex100 { for (i=0; i < 100; i++)}\par\pard\li2360\ri0\sl-213\slmult
0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0
\f0\charscalex100 {
for (j=0; j < }\fs16\cf0\f0\charscalex100 {100; j++)}\par
if }\fs16\cf0\
f0\charscalex100 {(firstarr[i] == secondarr[j])}\par\pard\li2360\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 {
\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs
}\fs16\cf0\f0\charscalex100 {flag = 1;}\par\pa
lcm = first}\f
s16\cf0\f0\charscalex100 {arr[i];}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {break;}\par\pard\li2360\
\}}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {
if }\fs16\cf0\f0\charscalex100 {(fla
g == 1) break;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
\}}\par\pard\li2360\ri0\sl-266\slmult0 \fs16\cf0\f0\charscalex100 { if (flag
== 1)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
prin
}\fs16\cf0\f0\charscalex100 {tf("\\nLCM of %d and %d is : %d",firstnum,secondnum
,lcm);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { else}\
prin}\fs16\c
f0\f0\charscalex100 {tf("\\nLCM not lying within 100 numbers range");}\par\pard\
li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl
-346\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmu
lt0 \fs16\cf0\f0\charscalex100 {Enter the first number : 56}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter the second number : 64}\par\pa
rd\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {LCM of 56 and 64 is : 4
lt0 \fs22\cf0\f0\charscalex100 {4. This program is to illustrate the usage of tw
o-dimensional arrays to hold matrices. The program}\par\pard\li1520\ri0\sl-266\s
lmult0 \fs22\cf0\f0\charscalex100 {accepts two matrices and performs their addit
ion.}\par\pard\li2360\ri0\sl-426\slmult0 \fs12\cf0\f0\charscalex100 {/**********
*********************************************************/}\par\pard\li2360\ri0\
sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* PROGRAM TO ADD TWO MATRICES
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f
0\charscalex100 {/**************************************************************
*****/}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-360\
slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \
fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\c
harscalex100 {
}\fs16\cf0\f0\charscalex100 {int arows,acols,brows,bcols,i,j,a
[20][20],b[20][20],c[20][20];}\par\pard\li2920\ri0\sl-373\slmult0 \fs16\cf0\f0\c
harscalex100 {printf("\\nEnter the number of rows in first matrix : ");}\par\par
alex100 {scanf("%d",&arows);}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\ch
arscalex100 {printf("\\nEnter the number of columns in first matrix : ");}\par\p
}\fs16\cf0\f0\char
scalex100 {scanf("%d",&acols);}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 {printf("\\nEnter the number of rows in second matrix : ");}\par\p
}\fs16\cf0\f0\char
scalex100 {scanf("%d",&brows);}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 {printf("\\nEnter the number of columns in second matrix : ");}\pa
}\fs16\cf0\f0\c
harscalex100 {scanf("%d",&bcols);}\par\pard\li2920\ri0\sl-306\slmult0 \fs16\cf0\
f0\charscalex100 {if (arows == brows && acols == bcols)}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {
\{}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 {
;}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 {
else}\par\pard\li2920\ri0\sl-213\slmult0 \fs14\cf0\f0\charsca
lex100 {\{}\par\pard\li3480\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {print
f("Addition of these two matrices is not possible" );}\par\pard\li3480\ri0\sl-21
3\slmult0 \fs16\cf0\f0\charscalex100 {exit(0);}\par\pard\li2920\ri0\sl-213\slmul
t0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li5133\ri0\sl-333\slmult0 \fs18\cf0\
f0\charscalex100 {23}\par\pard\sect\sectd\sbkpage
7;32768}}
7;32768}}

7;32768}}
0\par\pard\li2360\ri0\sl-306\slmult0 \fs16\cf0\f0\charscalex100 {
/* }\fs16\c
f0\f0\charscalex100 {get the matrix */}\par\pard\li2920\ri0\sl-213\slmult0 \fs16
\cf0\f0\charscalex100 {for(i=0; i < arows; i++)}\par\pard\li2920\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 { for(j=0; j < acols; j++)}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
\{}\par\pard\li2360\ri0\sl-21
}\fs16\cf0\f0\charscalex100 {prin
tf("\\nEnter element at row %d col %d for matrix A",i,j);}\par\pard\li3480\ri0\s
l-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d",&a[i][j]);}\par\pard\li292
0\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { \}}\par\pard\li2920\ri0\sl-3
20\slmult0 \fs16\cf0\f0\charscalex100 {for(i=0; i < brows; i++)}\par\pard\li2920
\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for(j=0; j < bcols; j++)}\par
\{}\par\pard\
}\fs14\cf0\f0\cha
rscalex100 {printf("\\nEnter element at row %d col %d for matrix B",i,j);}\par\p
ard\li3480\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d",&b[i][j]);
}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { \}}\par\pard
\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 {
/* perform }\fs16\cf0
\f0\charscalex100 {addition */}\par\pard\li2920\ri0\sl-400\slmult0 \fs16\cf0\f0\
charscalex100 {for(i=0; i < arows; i++)}\par\pard\li2920\ri0\sl-213\slmult0 \fs1
6\cf0\f0\charscalex100 { for(j=0;j < acols; j++)}\par\pard\li3480\ri0\sl-213\sl
mult0 \fs14\cf0\f0\charscalex100 {c[i][j] = a[i][j] + b[i][j];}\par\pard\li2360\
/* }\fs16\cf0\f0\charscalex10
0 {print the matrices */}\par\pard\li2920\ri0\sl-400\slmult0 \fs16\cf0\f0\charsc
alex100 {printf("\\nMatrix A is : \\n");}\par\pard\li2920\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 {for(i=0; i < arows; i++)}\par\pard\li2360\ri0\sl-213\sl
\{}\par\pard\li2920\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 { for(j=0;j < acols; j++)}\par\pard\li2360\ri0\sl-213\s
}\fs16\cf0\f0\charscalex100 {printf(
"%d ",a[i][j]);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("\\n"); /* this is required for row br
eak */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
\}}\p
ar\pard\li2920\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 {printf("\\nMatrix
B is : \\n");}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {fo
r(i=0; i < brows; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 {
for(j=0;j < bcols; j++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsca
lex100 {
}\fs16\cf0\f0\charscalex100 {printf("%d ",b[i][j]);}\par\pard\l
i2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charsca
lex100 {printf("\\n"); /* this is required for row break */}\par\pard\li2360\ri0
\}}\par\pard\li2360\ri0\sl-320\s
}\fs16\cf0\f0\charscalex100 {printf("\\nM
atrix sum is : \\n");}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscale
x100 {for(i=0; i < arows; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 {
\{}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscale
x100 { for(j=0;j < acols; j++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("%d ",c[i][j]);}\pa
}\fs16\cf0\f0
\charscalex100 {printf("\\n"); /* this is required for row break */}\par\pard\li
\}}\par\pard\li2360\ri0\
sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-306\slmult
0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\c
f0\f0\charscalex100 {Enter the number of rows in first matrix : 2}\par\pard\li23
60\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter the number of columns in
first matrix : 2}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{Enter the number of rows in second matrix : 2}\par\pard\li2360\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 {Enter the number of columns in second matrix : 2
}\par\pard\li5133\ri0\sl-440\slmult0 \fs18\cf0\f0\charscalex100 {24}\par\pard\se
ct\sectd\sbkpage

0\f0\charscalex100 {Enter element at row 0 col 0 for matrix A 2}\par\pard\li2360
\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {Enter element at row 0 col 1 for
matrix A 3}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {Ente
r element at row 1 col 0 for matrix A 4}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
4\cf0\f0\charscalex100 {Enter element at row 1 col 1 for matrix A 5}\par\pard\li
2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {Enter element at row 0 col 0
for matrix B 7}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {
Enter element at row 0 col 1 for matrix B 8}\par\pard\li2360\ri0\sl-213\slmult0
\fs14\cf0\f0\charscalex100 {Enter element at row 1 col 0 for matrix B 9}\par\par
d\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter element at row 1 c
ol 1 for matrix B 10}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 {Matrix A is :}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex10
0 {2 3}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {4 5}\par\
pard\li2360\ri0\sl-266\slmult0 \fs16\cf0\f0\charscalex100 {Matrix B is :}\par\pa
rd\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {7 8}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {9 10}\par\pard\li2360\ri0\sl-373\sl
mult0 \fs16\cf0\f0\charscalex100 {Matrix sum is :}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs16\cf0\f0\charscalex100 {9 11}\par\pard\li2360\ri0\sl-213\slmult0 \fs16
\cf0\f0\charscalex100 {13 15}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\p
ard\li1226\ri0\sl-280\slmult0 \fs22\cf0\f0\charscalex100 {5. This program will f
ind the transpose of a given matrix. The transpose is got by interchanging the}\
par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {rows and columns
of a matrix. Note in the program, how we change the columns to be outer loop}\pa
r\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {and rows to be the
inner loop and change the subscript order to print the transpose.}\par\pard\li23
**************************************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
6\cf0\f0\charscalex100 {/* PROGRAM TO FIND MATRIX TRANSPOSE
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/*
******************************************************************/}\par\pard\li
2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\
sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {int arows,acols,b
rows,bcols,i,j,a[20][20];}\par\pard\li2920\ri0\sl-373\slmult0 \fs16\cf0\f0\chars
calex100 {printf("\\nEnter the number of rows in the matrix : ");}\par\pard\li23
0 {scanf("%d",&arows);}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 {printf("\\nEnter the number of columns in the matrix : ");}\par\pard\li23
0 {scanf("%d",&acols);}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscal
ex100 {
/* }\fs16\cf0\f0\charscalex100 {get the matrix */}\par\pard\li2920\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {for(i=0; i < arows; i++)}\par\pard\
li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for(j=0; j < acols; j++
)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
\{}\par
prin}\fs16\
cf0\f0\charscalex100 {tf("\\nEnter element at row %d col %d ",i,j);}\par\pard\li
3480\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d",&a[i][j]);}\par\
pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { \}}\par\pard\li236
/* }\fs16\cf0\f0\charscalex
100 {print the matrices */}\par\pard\li2920\ri0\sl-400\slmult0 \fs16\cf0\f0\char

scalex100 {printf("\\nInput matrix is : \\n");}\par\pard\li2920\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 {for(i=0; i < arows; i++)}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {
\{}\par\pard\li2920\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { for(j=0;j < acols; j++)}\par\pard\li2360\ri0\sl
}\fs16\cf0\f0\charscalex100 {p
rintf("%d ",a[i][j]);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscale
x100 {
}\fs16\cf0\f0\charscalex100 {printf("\\n"); /* this is required for
row break */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
\}}\par\pard\li5133\ri0\sl-333\slmult0 \fs18\cf0\f0\charscalex100 {25}\par\pard
\sect\sectd\sbkpage
3\margtsxn666\margbsxn546\cols2\colno1\colw2920\colsr-0\colno2\colw8173\pard\li2
f0\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-213\slmul
t0 \fs18\cf0\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {
\{}\par\column\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slm
ult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213
\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl
-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri
0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li
0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\par
d\li0\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 {printf("\\nTranspose matrix
is : \\n");}\par\pard\li0\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {for(i=
0; i < acols; i++)}\fs16\cf0\f0\charscalex100 {
/* note that we }\fs16\cf0\f
0\charscalex100 {changes the rows */}\par\pard\li0\ri0\sl-400\slmult0 \fs16\cf0\
f0\charscalex100 { for(j=0;j < arows; j++)}\par\pard\sect\sectd\sbknone\pgwsxn1
1893\pghsxn16840\marglsxn666\margrsxn133\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 {
prin}\fs16\cf0\f0\charscalex100 {tf("%d ",a[j][i]);
/*reverse printing */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsca
lex100 {
}\fs16\cf0\f0\charscalex100 {printf("\\n"); /* this is required fo
r row break */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pa
rd\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360
\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Enter the number of rows in the
matrix : 2}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter
the number of columns in the matrix : 3}\par\pard\li2360\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 {Enter element at row 0 col 0 1}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {Enter element at row 0 col 1 2}\par\pard
\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter element at row 0 co
l 2 3}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter elem
ent at row 1 col 0 4}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 {Enter element at row 1 col 1 5}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 {Enter element at row 1 col 2 6}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 {Input matrix is :}\par\pard\li2360\ri0\sl-213
\slmult0 \fs16\cf0\f0\charscalex100 {1 2 3}\par\pard\li2360\ri0\sl-213\slmult0 \
fs16\cf0\f0\charscalex100 {4 5 6}\par\pard\li2360\ri0\sl-266\slmult0 \fs16\cf0\f
0\charscalex100 {Transpose matrix is :}\par\pard\li2360\ri0\sl-213\slmult0 \fs16
\cf0\f0\charscalex100 {1 4}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 {2 5}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {3
lt0 \fs22\cf0\f0\charscalex100 {6. This program is also a matrix related program
. The program will compute the determinant of a}\par\pard\li1520\ri0\sl-266\slmu
lt0 \fs22\cf0\f0\charscalex100 {given square matrix. Since the method is based o
n pivotal method, the diagonal elements should}\par\pard\li1520\ri0\sl-266\slmul
t0 \fs20\cf0\f0\charscalex100 {not be the same number. The matrix is declared a
float data type since the pivoted matrix will}\par\pard\li1520\ri0\sl-266\slmult
0 \fs22\cf0\f0\charscalex100 {definitely be a float data type.}\par\pard\li2360\
ri0\sl-386\slmult0 \fs12\cf0\f0\charscalex100 {/********************************
**********************************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 {/* PROGRAM TO FIND THE DETERMINANT OF A SQUARE MATRIX}\fs16\
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\
cf0\f0\charscalex100 {/*********************************************************
*********/}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {main(
)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\l
i2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int i,j,k,rows;}\par\pard
\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { float matrix[20][20];}\
par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { float pivot,dete
rminant;}\par\pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100 { /* ac
cept the matrix details */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 { printf("Enter the numbers of rows in the square matrix : ");}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d",&rows);}\
par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnte
r the matrix elements now :");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 { for(i=0; i < rows; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs

}\fs16\cf0\f0\charscalex100 {for(j=0; j < rows;j++)
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
\{}\par\par
}\fs16\cf0\f0\char
scalex100 {printf("\\nEnter element at row %d column %d ",i,j);}\par\pard\li2920
\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%f",&matrix[i][j]);}\pa
\}}\par\pard\li
5133\ri0\sl-373\slmult0 \fs18\cf0\f0\charscalex100 {26}\par\pard\sect\sectd\sbkn
one\pgwsxn11893\pghsxn16840\marglsxn666\margrsxn133\pard\sect\sectd\sbkpage
0\f0\charscalex100 { /* begin to compute the determinant */}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for(i=0; i < rows; i++)}\par\pard
\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2920\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {for(j=0; j < rows; j++)}\par\pard\li
2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { if(j != i)}\par\pard\li292
0\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2920\ri0\sl-21
}\fs16\cf0\f0\charscalex100 {pivot =
matrix[j][i] / matrix[i][i];}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\ch
arscalex100 {
f}\fs16\cf0\f0\charscalex100 {or(k=0; k < rows; k++)}\par\pard
\li3480\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 { matrix[j][k]= matrix[j]
[k] - matrix[i][k] * pivot;}\par\pard\li2920\ri0\sl-213\slmult0 \fs14\cf0\f0\cha
rscalex100 { \}}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100
{ \}}\par\pard\li2360\ri0\sl-266\slmult0 \fs16\cf0\f0\charscalex100 { determin
ant = 1;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for(i
=0; i < rows; i++)}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex10
0 {determinant = determinant * matrix[i][i];}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { printf("The determinant is %6.2f\\n",determinant)
;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\l
i2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0
\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Enter the numbers of rows in the squ
are matrix : 3}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {E
nter the matrix elements now :}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 {Enter element at row 0 column 0 2}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs16\cf0\f0\charscalex100 {Enter element at row 0 column 1 3}\par\pard\li2

360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter element at row 0 column
2 5}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter eleme
nt at row 1 column 0 1}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 {Enter element at row 1 column 1 2}\par\pard\li2360\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 {Enter element at row 1 column 2 3}\par\pard\li2360\ri0\
sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter element at row 2 column 0 3}\pa
r\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter element at ro
w 2 column 1 1}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {E
nter element at row 2 column 2 3}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f
0\charscalex100 {The determinant is -1.00}\par\pard\li5133\ri0\sl-213\slmult0 \
\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\
ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pa
lt0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\s
rscalex100 {27}\par\pard\sect\sectd\sbkpage
7;32768}}
7;32768}}

0\f0\charscalex100 {CHAPTER 10}\par\pard\li3253\ri0\sl-280\slmult0 \fs22\cf0\f0\
charscalex100 {USER-DEFINED FUNCTIONS}\par\pard\li1226\ri0\sl-466\slmult0 \fs22\
cf0\f0\charscalex100 {1. This program demonstrates a very simple function. It ca
lls another function without any}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f
0\charscalex100 {arguments and the function also does not return any value. A mo
re complicated no return no}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\cha
rscalex100 {argument function is in the next example.}\par\pard\li2360\ri0\sl-33
3\slmult0 \fs12\cf0\f0\charscalex100 {/*****************************************
*********/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* a
simple function - no arguments and return values */}\par\pard\li2360\ri0\sl-213\
slmult0 \fs12\cf0\f0\charscalex100 {/*******************************************
*******/}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {main()}
\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2
360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nAbout to call a
function");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { ca
llfunction();}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
printf("\\nReturned from the function to main");}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 {callfunction()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0
\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscale
x100 { printf("\\nI am now in the called function");}\par\pard\li2360\ri0\sl-21
3\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-240\slmult0 \fs
16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0
\charscalex100 {About to call a function}\par\pard\li2360\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 {I am now in the called function}\par\pard\li2360\ri0\sl
-213\slmult0 \fs16\cf0\f0\charscalex100 {Returned from the function to main}\par
\pard\li1226\ri0\sl-373\slmult0 \fs22\cf0\f0\charscalex100 {2. This program demo
nstrates a function call with arguments passed to the function. The function}\pa
r\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {gets two arguments
from the main program and finds their maximum and displays the result.}\par\pard
**************************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\cha
rscalex100 {/* a simple function - with arguments and no return values */}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/*********************
*****************************/}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\
charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscale
x100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int a
,b;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\
nEnter the first number : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\c
harscalex100 { scanf("%d",&a);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 { printf("\\nEnter the second number : ");}\par\pard\li2360\ri0\
sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d",&b);}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { findmax(a,b);}\par\pard\li2360\ri
0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 {findmax(x,y)}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 {int x,y;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\

cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsc
alex100 { int c; /* this is a local variable */}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs16\cf0\f0\charscalex100 { c = (x < y) ? y : x;}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nThe maximum is : %d",c);}\p
ar\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li236
0\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {Enter the first number : 10}\par\pard\li
2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter the second number : 5}
\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {The maximum is :
10}\par\pard\li5133\ri0\sl-253\slmult0 \fs18\cf0\f0\charscalex100 {28}\par\pard
\sect\sectd\sbkpage
7;32768}}

0\f0\charscalex100 {3. This program demonstrates a function call with arguments
passed to the function. The function}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\c
f0\f0\charscalex100 {also returns a result back to the main program. We will pas
s an integer to the function which will}\par\pard\li1520\ri0\sl-266\slmult0 \fs2
2\cf0\f0\charscalex100 {compute the sum from 1 up to the number like 1 + 2 + 3 +
+ n.}\par\pard\li2360\ri0\sl-346\slmult0 \fs12\cf0\f0\charscalex100 {/********
******************************************/}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 {/* a simple function - with arguments and with retur
n values */}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/***
***********************************************/}\par\pard\li2360\ri0\sl-373\slm
ult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
4\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 { int n,sum;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsca
lex100 { printf("\\nEnter the number : ");}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { scanf("%d",&n);}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 { sum = findsum(n);}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs16\cf0\f0\charscalex100 { printf("\\nSum is (1+2+3+...+%d) : %d",n,sum
);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\
li2360\ri0\sl-306\slmult0 \fs16\cf0\f0\charscalex100 {findsum(number)}\par\pard\
li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {int number;}\par\pard\li23
\slmult0 \fs16\cf0\f0\charscalex100 { int mysum,i; /* these are local variables
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { mysum = 0;
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for (i=1; i <
= number; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
m}\fs16\cf0\f0\charscalex100 {ysum = mysum + i;}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 { return(mysum);}\par\pard\li2360\ri0\sl-213\
slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-293\slmult0 \fs16
\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\c
harscalex100 {Enter the number : 10}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 {Sum is (1+2+3+...+10) : 55}\par\pard\li1226\ri0\sl-213\slmul
t0 \fs18\cf0\par\pard\li1226\ri0\sl-293\slmult0 \fs22\cf0\f0\charscalex100 {4. T
his program accepts a character and calls a function to convert it to uppercase.
The argument}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {da
ta type and return data type are both characters.}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs18\cf0\par\pard\li2360\ri0\sl-266\slmult0 \fs12\cf0\f0\charscalex100 {/
*********************************************************/}\par\pard\li2360\ri0\
sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* passing of character datatype to f
unction */}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/****
*****************************************************/}\par\pard\li2360\ri0\sl-3
73\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult
0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f
0\charscalex100 { char a,b;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\ch
arscalex100 { char convert();}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 { printf("\\nEnter a character to be converted to uppercase : ");
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { a=getchar();}
\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { b=convert(a);}
\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nUpp
ercase of %c is %c",a,b);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\chars
calex100 {\}}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {cha
r convert(c)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {cha
r c;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\par
d\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char d;}\par\pard\li51
33\ri0\sl-453\slmult0 \fs18\cf0\f0\charscalex100 {29}\par\pard\sect\sectd\sbkpag
e

7;32768}}
0\f0\charscalex100 { d = toupper(c);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 { return(d);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0
x100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Ent
er a character to be converted to uppercase : a}\par\pard\li2360\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 {Uppercase of a is A}\par\pard\li2360\ri0\sl-386\
slmult0 \fs16\cf0\f0\charscalex100 {Enter a character to be converted to upperca
se : m}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Uppercase
of a is M}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1226\ri0\sl333\slmult0 \fs22\cf0\f0\charscalex100 {5. This program demonstrates a nested fu
nction call. The main program calls a function. The}\par\pard\li1520\ri0\sl-266\
slmult0 \fs22\cf0\f0\charscalex100 {function in turn calls another function. The
se kinds of calls are nested function calls.}\par\pard\li2360\ri0\sl-426\slmult0
\fs12\cf0\f0\charscalex100 {/**************************************************
********/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* NES
TED FUNCTION CALLS */}\par\pard\li2360\ri0\sl-226\slmult0 \fs12\cf0\f0\charscale
x100 {/**********************************************************/}\par\pard\li2
360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0
\charscalex100 {main()}\par\pard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\charscal
ex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { prin
tf("\\nThis is main program before calls");}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { function_one();}\par\pard\li2360\ri0\sl-226\slmult
0 \fs16\cf0\f0\charscalex100 { printf("\\nThis is main program after call");}\p
harscalex100 {function_one()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\ch
arscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
printf("\\nThis is function_one before calls");}\par\pard\li2360\ri0\sl-226\sl
mult0 \fs16\cf0\f0\charscalex100 { function_two();}\par\pard\li2360\ri0\sl-226\
slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nThis is function_one after call
");}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard
0\f0\charscalex100 {function_two()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0
\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscale
x100 { printf("\\nThis is function_two");}\par\pard\li2360\ri0\sl-226\slmult0 \
fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\
pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li23
60\ri0\sl-426\slmult0 \fs16\cf0\f0\charscalex100 {This is main program before ca
lls}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {This is func
tion_one before calls}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscale
x100 {This is function_two}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 {This is function_one after call}\par\pard\li2360\ri0\sl-226\slmult0 \
fs16\cf0\f0\charscalex100 {This is main program after call}\par\pard\li1226\ri0\
sl-213\slmult0 \fs18\cf0\par\pard\li1226\ri0\sl-320\slmult0 \fs20\cf0\f0\charsca
lex100 {6. This program demonstrates the recursive function usage. The program c
omputes the greatest}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex
100 {common divisor (GCD) of two integers recursively.}\par\pard\li5133\ri0\sl-2
3\ri0\sl-413\slmult0 \fs18\cf0\f0\charscalex100 {30}\par\pard\sect\sectd\sbkpage
7;32768}}

0\f0\charscalex100 {int findgcd(int m,int y);}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\c
f0\f0\charscalex100 {\{}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charsca
lex100 {int firstno,secondno,gcd;}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 {printf("Enter the first number: ");}\par\pard\li2920\ri0\sl-21
3\slmult0 \fs16\cf0\f0\charscalex100 {scanf("%d",&firstno);}\par\pard\li2920\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {printf("Enter the second number: ");
}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {scanf("%d",&sec
ondno);}\par\pard\li2920\ri0\sl-306\slmult0 \fs16\cf0\f0\charscalex100 {if(first
no > secondno)}\par\pard\li3480\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {g
cd = findgcd(firstno,secondno);}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 {else}\par\pard\li3480\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex
100 {gcd = findgcd(secondno,firstno);}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 {printf("The GCD of %d and %d is: %d",firstno,secondno,gcd)
;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\l
i2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 {int findgcd(int m,int n)}\p
ar\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li292
0\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {int z;}\par\pard\li2920\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {while(n!=0)}\par\pard\li2920\ri0\sl-213\
\cf0\f0\charscalex100 {
z = m % n;}\par\pard\li2920\ri0\sl-213\slmult0 \fs1
m = n;}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\c
f0\f0\charscalex100 {
n = z;}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 {
fi}\fs16\cf0\f0\charscalex100 {ndgcd(m,n); /* this is a
recursive call */}\par\pard\li2920\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100
{\}}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {return(m);}
l-400\slmult0 \fs16\cf0\f0\charscalex100 {Enter the first number: 8}\par\pard\li
2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter the second number: 36}
\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {The GCD of 8 and
36 is: 4}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1226\ri0\sl-3
33\slmult0 \fs22\cf0\f0\charscalex100 {7. This program demonstrates how to pass
an array to a function. The program accepts three}\par\pard\li1520\ri0\sl-266\sl
mult0 \fs22\cf0\f0\charscalex100 {numbers in an array. The array is passed to a

function that computes the average of the three}\par\pard\li1520\ri0\sl-266\slmu
lt0 \fs22\cf0\f0\charscalex100 {numbers. The arguments are int data types while
the result is a float.}\par\pard\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscal
ex100 {float findaverage(int myarray[]);}\par\pard\li2360\ri0\sl-400\slmult0 \fs
0 { int numbers[3],i;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 { float average;}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscal
ex100 { for(i=0; i < 3; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\c
harscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex10
0 {
}\fs16\cf0\f0\charscalex100 {printf("\\nEnter number[%d] : ",i);}\par\par
alex100 {scanf("%d",&numbers[i]);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\
f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscal
ex100 { average = findaverage(numbers);}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
6\cf0\f0\charscalex100 { printf("\\nThe sum of the numbers is : %f",average);}\
par\pard\li5133\ri0\sl-360\slmult0 \fs18\cf0\f0\charscalex100 {31}\par\pard\sect
\sectd\sbkpage
7;32768}}

0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscal
ex100 {float findaverage(int myarray[])}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
4\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 { int mysum = 0;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\cha
rscalex100 { int i;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 { float average;}\par\pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex
100 { for(i=0; i < 3; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\cha
rscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{
m}\fs16\cf0\f0\charscalex100 {ysum = mysum + myarray[i];}\par\pard\li2360\r
i0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-360\s
lmult0 \fs16\cf0\f0\charscalex100 { return (mysum / 3.0);}\par\pard\li2360\ri0\
sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-386\slmult
0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\c
f0\f0\charscalex100 {Enter number[0] : 1}\par\pard\li2360\ri0\sl-213\slmult0 \fs
16\cf0\f0\charscalex100 {Enter number[1] : 2}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 {Enter number[2] : 3}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs16\cf0\f0\charscalex100 {The sum of the numbers is : 2.000000}\par\pard\
\f0\charscalex100 {8. This program demonstrates another interesting feature of a
uto. You can declare a variable with}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\c
f0\f0\charscalex100 {same within a function under different blocks. When the blo
ck is exited, the variable is destroyed.}\par\pard\li1520\ri0\sl-266\slmult0 \fs
22\cf0\f0\charscalex100 {The program below explains the usage of different data
types for auto.}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {
Assume that we declare a variable as extern. If we use the same variable name wi
thin a function,}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100
{what will happen? The local variable will take precedence over the extern varia
ble. This is}\par\pard\li1520\ri0\sl-266\slmult0 \fs20\cf0\f0\charscalex100 {dem
onstrated through the following program. We have defined a variable myvar as ext
ern and}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {used the
same in main().}\par\pard\li2360\ri0\sl-280\slmult0 \fs12\cf0\f0\charscalex100
{/**************************************************************/}\par\pard\li23
60\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* using auto within program b
locks */}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/******
********************************************************/}\par\pard\li2360\ri0\s
l-333\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 { auto int myvar = 10;}\par\pard\li2360\ri0\sl-213\slmult0 \
fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 {
auto float myvar = 20.0;}\par\pard\li2360\ri0\sl-213\slmult0
\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
auto }\fs16\cf0\f0\charscalex100 {char myvar = 'A';}\
}\fs16\cf0
\f0\charscalex100 {printf("\\nInnermost myvar (char) is %c",myvar);}\par\pard\li
\}}\par\pard\li2360\ri0\
prin}\fs16\cf0\f0\charscalex100 {
tf("\\nMiddle myvar (float) is %f",myvar);}\par\pard\li2360\ri0\sl-213\slmult0 \
fs14\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 { printf("\\nOutermost myvar (int) is %d",myvar);}\par\pard\li23
\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-266\slmult0
\fs16\cf0\f0\charscalex100 {Innermost myvar (char) is A}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {Middle myvar (float) is 20.000000}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Outermost myvar (int)
is 10}\par\pard\li5133\ri0\sl-400\slmult0 \fs18\cf0\f0\charscalex100 {32}\par\pa
rd\sect\sectd\sbkpage
7;32768}}
charscalex100 {STRUCTURES AND UNIONS}\par\pard\li1226\ri0\sl-466\slmult0 \fs22\c
f0\f0\charscalex100 {1. This is a simple program that illustrates a structure. W
e have defined a structure called currency}\par\pard\li1520\ri0\sl-266\slmult0 \
fs22\cf0\f0\charscalex100 {with two members such as rupees and paise.}\par\pard\
li2360\ri0\sl-426\slmult0 \fs12\cf0\f0\charscalex100 {/*************************

16\cf0\f0\charscalex100 {/* RUPEES AND PAISE STRUCTURE */}\par\pard\li2360\ri0\s
l-213\slmult0 \fs12\cf0\f0\charscalex100 {/*************************************
***************************/}\par\pard\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\ch
arscalex100 {struct currency}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\ch
int rupees;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
int paise;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\};}\
par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\
li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl
-213\slmult0 \fs16\cf0\f0\charscalex100 { struct currency money;}\par\pard\li23
60\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnter Rupees : ")
;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d",&m
oney.rupees);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
printf("\\nEnter Paise : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\ch
arscalex100 { scanf("%d",&money.paise);}\par\pard\li2360\ri0\sl-226\slmult0 \fs1
6\cf0\f0\charscalex100 { printf("\\nRs. %d.%2d",money.rupees,money.paise);}\par\
pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\r
i0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-386
\slmult0 \fs16\cf0\f0\charscalex100 {Enter Rupees : 12}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 {Enter Paise : 35}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 {Rs. 12.35}\par\pard\li1226\ri0\sl-373\sl
mult0 \fs20\cf0\f0\charscalex100 {2. This simple program illustrates how to init
ialize the members of a structure. Look at how}\par\pard\li1520\ri0\sl-266\slmul
t0 \fs22\cf0\f0\charscalex100 {different data types are initialized in this exam
ple.}\par\pard\li2360\ri0\sl-373\slmult0 \fs12\cf0\f0\charscalex100 {/**********
******************************************************/}\par\pard\li2360\ri0\sl213\slmult0 \fs14\cf0\f0\charscalex100 {/* STRUCTURE INITIALIZATION */}\par\pard
****************************************/}\par\pard\li2360\ri0\sl-373\slmult0 \f
s16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f
0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex1
00 { struct employee}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscale
x100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}
\fs16\cf0\f0\charscalex100 {int empno;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16
}\fs16\cf0\f0\charscalex100 {char name[20];}\par\pard
\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
float }\fs16\cf0\f0\c
harscalex100 {basic;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 { \};}\par\pard\li2360\ri0\sl-306\slmult0 \fs16\cf0\f0\charscalex100 { str
uct employee emp1 = \{100,"Muthu",5000.00\};}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { struct employee emp2 = \{101,"Saravanan",6000.00\}
;}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-373\slmul
t0 \fs16\cf0\f0\charscalex100 { printf("\\nEno : %d, Name : %s, Basic :}\par\pa
cf0\f0\charscalex100 {33}\par\pard\sect\sectd\sbkpage
7;32768}}

0\f0\charscalex100 {%5.2f",emp1.empno,emp1.name,emp1.basic);}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEno : %d, Name : %s, B
asic : %5.2f",emp2.empno,emp2.name,emp2.basic);}\par\pard\li2360\ri0\sl-386\slmu
lt0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0
\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\chars
calex100 {Eno : 100, Name : Muthu, Basic : 5000.00}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 {Eno : 101, Name : Saravanan, Basic : 6000.00}
\fs18\cf0\par\pard\li1226\ri0\sl-280\slmult0 \fs22\cf0\f0\charscalex100 {3. Thi
s simple program illustrates how to use a nested structure.}\par\pard\li2360\ri0
\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-360\slmult0 \fs12\cf0\f0\charsc
alex100 {/****************************************************************/}\par
\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* Nested structures
*/}\par\pard\li2360\ri0\sl-226\slmult0 \fs12\cf0\f0\charscalex100 {/***********
*****************************************************/}\par\pard\li2360\ri0\sl-2
0\ri0\sl-240\slmult0 \fs16\cf0\f0\charscalex100 { struct date}\par\pard\li2360\
ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\
}\fs16\cf0\f0\charscalex100 {int day;}\p
ar\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\
charscalex100 {int month;}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\chars
calex100 {
int }\fs16\cf0\f0\charscalex100 {year;}\par\pard\li2360\ri0\sl-213
\slmult0 \fs16\cf0\f0\charscalex100 { \};}\par\pard\li2360\ri0\sl-213\slmult0 \
fs18\cf0\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 { struct
employee}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\

}\fs16\cf0\f0
\charscalex100 {int empno;}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\char
scalex100 {
}\fs16\cf0\f0\charscalex100 {char name[20];}\par\pard\li2360\ri0\
float }\fs16\cf0\f0\charscalex100
{basic;}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {
str
uct date joi}\fs16\cf0\f0\charscalex100 {ndate;}\par\pard\li2360\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 { \};}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\
cf0\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\p
ard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri
0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\chars
calex100 { struct employee emp1 = \{100,"Muthu",5000.00,10,12,2002\};}\par\pard
\li2360\ri0\sl-426\slmult0 \fs14\cf0\f0\charscalex100 { printf("\\nEno : %d, Na
me : %s, Basic : %5.2f",emp1.empno,emp1.name,emp1.basic);}\par\pard\li2360\ri0\s
l-226\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nJoindate %2d.%2d.",emp1.jo
indate.day,emp1.joindate.month);}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f
0\charscalex100 { printf("%4d",emp1.joindate.year);}\par\pard\li2360\ri0\sl-213\
slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-226\slmult0 \fs14\cf0\f0\charscalex100
{\}}\par\pard\li2360\ri0\sl-426\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\
6\cf0\f0\charscalex100 {Eno : 100, Name : Muthu, Basic : 5000.00}\par\pard\li236
0\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Joindate 10.12.2002}\par\pard\l
\fs18\cf0\f0\charscalex100 {34}\par\pard\sect\sectd\sbkpage
7;32768}}
7;32768}}

0\f0\charscalex100 {4. This is a simple program that illustrates how to use a un
ion. Note that since the members share}\par\pard\li1520\ri0\sl-266\slmult0 \fs22
\cf0\f0\charscalex100 {the same location, the last members value has overridden
other members values.}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscale
x100 {typedef union date mydate;}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f
0\charscalex100 {union date}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\cha
rscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
int day;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int mo
nth;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int year;}
\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\};}\par\pard\li
2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\
sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 { mydate date1;}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { date1.day = 15;}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { date1.month = 12;}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 { date1.year = 2002;}\par\pard\li2360\ri0\sl333\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nDate is %2d.%2d.%4d", date1.
day,date1.month,date1.year);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\ch
arscalex100 {\}}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 {
Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Date is 2
002.2002.2002}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1226\ri0\
sl-320\slmult0 \fs20\cf0\f0\charscalex100 {5. This is a simple program that illu
strates how to use a union. Note that since the members share}\par\pard\li1520\r
i0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {the same location, the last member
s value will overwrite the other members values (which we}\par\pard\li1520\ri0\s
l-266\slmult0 \fs20\cf0\f0\charscalex100 {saw in the last example). By rearrangi
ng the order of usage of the members, you can prevent this.}\par\pard\li1520\ri0
\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {The example illustrates this.}\par\p
ard\li2360\ri0\sl-240\slmult0 \fs16\cf0\f0\charscalex100 {typedef union date myd
ate;}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {union date}
\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2
360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int day;}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int month;}\par\pard\li2360\ri0\sl
-213\slmult0 \fs16\cf0\f0\charscalex100 { int year;}\par\pard\li2360\ri0\sl-213\
slmult0 \fs14\cf0\f0\charscalex100 {\};}\par\pard\li2360\ri0\sl-333\slmult0 \fs1
6\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\
charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{ mydate date1;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{ date1.day = 15;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex10
0 { printf("\\nDate is %2d.", date1.day);}\par\pard\li2360\ri0\sl-213\slmult0 \
fs16\cf0\f0\charscalex100 { date1.month = 12;}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { printf("%2d.", date1.month);}\par\pard\li2360\r
i0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { date1.year = 2002;}\par\pard\li2
360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("%4d", date1.year);}

l-400\slmult0 \fs16\cf0\f0\charscalex100 {Date is 15.12.2002}\par\pard\li5133\ri
0\sl-400\slmult0 \fs18\cf0\f0\charscalex100 {35}\par\pard\sect\sectd\sbkpage
7;32768}}
0\f0\charscalex100 {6. This is a simple program that illustrates an array of uni
on. Note that this is same as a structure}\par\pard\li1520\ri0\sl-266\slmult0 \f
s22\cf0\f0\charscalex100 {variable.}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf
0\par\pard\li2360\ri0\sl-266\slmult0 \fs12\cf0\f0\charscalex100 {/**************
*************************************************/}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 {/* Arrays in union */}\par\pard\li2360\ri0\sl
-213\slmult0 \fs12\cf0\f0\charscalex100 {/**************************************

scalex100 {typedef union date mydate;}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\
cf0\f0\charscalex100 {union date}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f
00 { int day;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
int month;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { in
t year;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\};}\par
\pard\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2
3\slmult0 \fs16\cf0\f0\charscalex100 { int i;}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { mydate dates[2];}\par\pard\li2360\ri0\sl-360\sl
mult0 \fs16\cf0\f0\charscalex100 { dates[0].day = 10;}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 { dates[0].month = 12;}\par\pard\li2360\r
i0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { dates[0].year = 2002;}\par\pard\
li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { dates[1].day = 11;}\par\
pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { dates[1].month = 12
;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { dates[1].yea
r = 2003;}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { for(
i = 0; i < 2; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex10
0 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs
16\cf0\f0\charscalex100 {printf("\\nYear[%d] is %4d",i,dates[i].year);}\par\pard
\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0
\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-346\slmul
t0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\
cf0\f0\charscalex100 {Year[0] is 2002}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 {Year[0] is 2003}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\
cf0\par\pard\li1226\ri0\sl-306\slmult0 \fs22\cf0\f0\charscalex100 {7. This simpl
e program illustrates how to place a union inside a structure.}\par\pard\li2360\
ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 {struct mystructure}\par\pard\li23
\slmult0 \fs16\cf0\f0\charscalex100 { union}\par\pard\li2360\ri0\sl-213\slmult0
\fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {int myval1;}\par\pard\li2360\
ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { \};}\par\pard\li2360\ri0\sl-213
\slmult0 \fs16\cf0\f0\charscalex100 { int myval2;}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs14\cf0\f0\charscalex100 {\};}\par\pard\li2360\ri0\sl-306\slmult0 \fs16
{ struct mystructure struct1;}\par\pard\li5133\ri0\sl-346\slmult0 \fs18\cf0\f0\
charscalex100 {36}\par\pard\sect\sectd\sbkpage
7;32768}}

0\f0\charscalex100 { printf("\\nEnter a number (this will goto union) : ");}\pa
r\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d", &stru
ct1.myval1);}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { p
rintf("\\nEnter a number (this will goto structure) : ");}\par\pard\li2360\ri0\s
l-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d", &struct1.myval2);}\par\p
ard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nUnion val
ue is %d",struct1.myval1);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 { printf("\\nStructure value is %d",struct1.myval2);}\par\pard\li2360
\ri0\sl-386\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-400\s
lmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \f
s16\cf0\f0\charscalex100 {Enter a number (this will goto union) : 12}\par\pard\l
i2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Enter a number (this will g
oto structure) : 13}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex1
00 {Union value is 12}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscale
x100 {Structure value is 13}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pa
rd\li1226\ri0\sl-426\slmult0 \fs22\cf0\f0\charscalex100 {8. This simple program
illustrates how to use bit fields in structures.}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs18\cf0\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 {ma
in()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\par
d\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { struct category}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\
}\fs16\cf0\f0\charscalex100 {
unsigned book : 4;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex10
0 {
}\fs16\cf0\f0\charscalex100 {unsigned fine : 4;}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 { \};}\par\pard\li2360\ri0\sl-320\slmult
0 \fs16\cf0\f0\charscalex100 { struct category mycat;}\par\pard\li2360\ri0\sl-4
00\slmult0 \fs16\cf0\f0\charscalex100 { mycat.book = 2;}\par\pard\li2360\ri0\sl
-213\slmult0 \fs16\cf0\f0\charscalex100 { mycat.fine = 3;}\par\pard\li2360\ri0\
sl-386\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nBook value is %d",mycat.
book);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf(

"\\nFine value is %d",mycat.fine);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0
x100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Boo
k value is 2}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Fin
e value is 3}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\s
ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pa
rd\li5133\ri0\sl-320\slmult0 \fs18\cf0\f0\charscalex100 {37}\par\pard\sect\sectd
\sbkpage
7;32768}}
7;32768}}

charscalex100 {POINTERS}\par\pard\li1226\ri0\sl-466\slmult0 \fs22\cf0\f0\charsca
lex100 {1. This simple program illustrates how to represent and access an array
element using pointers.}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charsca
lex100 {Note that the array name itself could be used as a pointer to the array
or a separate pointer}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscale
x100 {variable equated to the array can be used as the pointer to the array.}\pa
**************************************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
6\cf0\f0\charscalex100 {/* pointer to array - a simple example */}\par\pard\li23
***************************/}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\ch
arscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex1
00 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { int mya
rray[5] = \{10,2,3,4,5\};}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\chars
calex100 { int *myptr;}\par\pard\li2360\ri0\sl-253\slmult0 \fs16\cf0\f0\charsca
lex100 { myptr = myarray;}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\char
scalex100 { printf("Value of myarray[0]: %d\\n", myarray[0]);}\par\pard\li2360\
ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("Value of myarray[0]: %d
\\n", *myarray);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{ printf("Value of myarray[0]: %d\\n", *myptr);}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-266\slmult0 \fs16\cf
0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\char
scalex100 {Value of myarray[0] : 10}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 {Value of myarray[0] : 10}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 {Value of myarray[0] : 10}\par\pard\li1226\ri0\sl-40
0\slmult0 \fs22\cf0\f0\charscalex100 {2. This simple program illustrates how to
use pointer arithmetic to access various elements of an}\par\pard\li1520\ri0\sl266\slmult0 \fs22\cf0\f0\charscalex100 {array. A more detailed example is given
subsequent to this example.}\par\pard\li2360\ri0\sl-386\slmult0 \fs12\cf0\f0\cha
rscalex100 {/*********************************************************/}\par\par
d\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* pointer arithmetic to
access array elements */}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\chars
calex100 {/*********************************************************/}\par\pard\
li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri
0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmu
lt0 \fs16\cf0\f0\charscalex100 { int *myptr;}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 { int myarray[5] = \{12,14,16,18,20\};}\par\pard\l
i2360\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 { myptr = myarray;}\par\par
d\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nThe pointer
is at first element %d", *myptr);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0
\f0\charscalex100 { printf("\\nAbout to increment the pointer");}\par\pard\li23
60\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { myptr++;}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nThe pointer is at next
element %d", *myptr);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 { printf("\\nThis will access the fourth element which is %d", *(myptr+2)
);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\
li2360\ri0\sl-266\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri
0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {The pointer is at first element 12}
\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {About to increme
nt the pointer}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {T
he pointer is at next element 14}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f
0\charscalex100 {This will access the fourth element which is 18}\par\pard\li513
3\ri0\sl-386\slmult0 \fs18\cf0\f0\charscalex100 {38}\par\pard\sect\sectd\sbkpage
7;32768}}
0\f0\charscalex100 {3. This simple program illustrates how to change the values
of the array elements using pointers.}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\
cf0\par\pard\li2360\ri0\sl-226\slmult0 \fs12\cf0\f0\charscalex100 {/************
*********************************************/}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 {/* modifying array elements using pointers */}\pa
0 { int *myptr;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{ int myarray[5] = \{12,14,16,18,20\};}\par\pard\li2360\ri0\sl-360\slmult0 \fs1
6\cf0\f0\charscalex100 { myptr = myarray;}\par\pard\li2360\ri0\sl-400\slmult0 \

fs16\cf0\f0\charscalex100 { printf("\\nThe pointer is at first element %d", *my
ptr);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("
\\nAbout to change the value of 2nd element %d",*(myptr+1));}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { *(myptr+1) = 78;}\par\pard\li2360
\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nThe value of 2nd el
ement is now %d",*(myptr+1));}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\c
harscalex100 {\}}\par\pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100
{Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {The poin
ter is at first element 12}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 {About to change the value of 2nd element 14}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 {The value of 2nd element is now 78}\par\p
ard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1226\ri0\sl-320\slmult0 \fs22
\cf0\f0\charscalex100 {4. This program is another example for pointer arithmetic
. The program will accept an array. The}\par\pard\li1520\ri0\sl-266\slmult0 \fs2
2\cf0\f0\charscalex100 {printing of the array and the finding of the largest num
ber in the array are done using pointer}\par\pard\li1520\ri0\sl-266\slmult0 \fs2
2\cf0\f0\charscalex100 {arithmetic.}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf
0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\char
scalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { i
nt i,number,largest,*myptr,numbers[20];}\par\pard\li2360\ri0\sl-373\slmult0 \fs1
6\cf0\f0\charscalex100 { printf("\\nEnter the number of elements in the array :
");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { scanf("%d
",&number);}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { fo
r (i=0; i < number; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charsc
alex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("\\nEnter number[%d] : ",i);}\par\pard\li2
00 {scanf("%d",&numbers[i]);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\ch
arscalex100 { \}}\par\pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100
{ printf("\\nThe array is : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 { myptr = numbers;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\c
f0\f0\charscalex100 { for (i=0; i < number; i++)}\par\pard\li2360\ri0\sl-213\sl
pri}\fs16\cf0\f0\charscalex100 {ntf("%d,
",*myptr++);}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 { m
yptr = numbers;}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {
largest = 0;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
for (i=0; i < number; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\cha
rscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{
if }\fs16\cf0\f0\charscalex100 {(largest < *myptr) largest = *myptr;}\par\p
m}\fs16\cf0\f0\cha
rscalex100 {yptr++;}\par\pard\li5133\ri0\sl-360\slmult0 \fs18\cf0\f0\charscalex1
00 {39}\par\pard\sect\sectd\sbkpage
7;32768}}

0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charsc
alex100 { printf("\\nThe largest element is : %d",largest);}\par\pard\li2360\ri
lt0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16
\cf0\f0\charscalex100 {The array is : 12, 34, 2, 67, 12,}\par\pard\li2360\ri0\sl
-213\slmult0 \fs16\cf0\f0\charscalex100 {The largest element is : 67}\par\pard\l

f0\charscalex100 {5. This program is an illustration for pointer to two-dimensio
nal array. Notice the way the array}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf
0\f0\charscalex100 {elements are printed.}\par\pard\li2360\ri0\sl-400\slmult0 \f
s16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f
00 { int matrix[3][3]=\{\{1,2,3\},\{4,5,6\},\{7,8,9\}\};}\par\pard\li2360\ri0\s
l-373\slmult0 \fs16\cf0\f0\charscalex100 { int row,col;}\par\pard\li2360\ri0\sl
-400\slmult0 \fs16\cf0\f0\charscalex100 { for (row = 0; row <= 2; row++)}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\
prin}\fs16\cf0\f0\charscalex1
00 {tf("\\n");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
for (col = 0; col <= 2; col++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("%d ",*(*(matrix + r
ow) + col));}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \
}}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\l
\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {1 2 3}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs16\cf0\f0\charscalex100 {4 5 6}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
6\cf0\f0\charscalex100 {7 8 9}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\
pard\li1226\ri0\sl-346\slmult0 \fs20\cf0\f0\charscalex100 {6. This program is an
illustration for an array of pointers. Instead of containing the elements, the}
\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {array has the po
inter to various variables. When the variables value changes the program reflect
s}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {the change.}\p
ar\pard\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\l
i2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl213\slmult0 \fs16\cf0\f0\charscalex100 { int *myarray[3];}\par\pard\li2360\ri0\
sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int var1 = 10;}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int var2 = 20;}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int var3 = 30;}\par\pard\li2360\r
i0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int i;}\par\pard\li2360\ri0\sl-3
20\slmult0 \fs16\cf0\f0\charscalex100 { myarray[0] = &var1;}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { myarray[1] = &var2;}\par\pard\li2
360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { myarray[2] = &var3;}\par\pa
rd\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nThe array
formed is : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
for(i = 0; i < 3; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charsc
alex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("%d,",*(myarray[i]));}\par\pard\li5133\ri0
\sl-320\slmult0 \fs18\cf0\f0\charscalex100 {40}\par\pard\sect\sectd\sbkpage
7;32768}}

0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charsc
alex100 { var1 = 100; var2 = 200; var3 = 300;}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { printf("\\nThe new array formed is : ");}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { for(i = 0; i < 3; i+
alex100 {printf("%d,",*(myarray[i]));}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\
cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\char
scalex100 {\}}\par\pard\li2360\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 {Ou
tput}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {The array f
ormed is : 10,20,30,}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 {The new array formed is : 100,200,300,}\par\pard\li1226\ri0\sl-213\slmult0
\fs18\cf0\par\pard\li1226\ri0\sl-386\slmult0 \fs22\cf0\f0\charscalex100 {7. This
program is an illustration for an array of pointers for strings. It finds the p
osition of the}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {g
iven substring using pointer arithmetic.}\par\pard\li2360\ri0\sl-213\slmult0 \fs
18\cf0\par\pard\li2360\ri0\sl-266\slmult0 \fs12\cf0\f0\charscalex100 {/*********
**************************************************/}\par\pard\li2360\ri0\sl-213\
slmult0 \fs16\cf0\f0\charscalex100 {/* find substring position */}\par\pard\li23
******************************/}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0
\charscalex100 {#include "string.h"}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 {#include "stdio.h"}\par\pard\li2360\ri0\sl-213\slmult0 \fs16
{ char *source = "This is the source string";}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { char *search = "source";}\par\pard\li2360\ri0\s
l-213\slmult0 \fs16\cf0\f0\charscalex100 { char *pos;}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 { int i;}\par\pard\li2360\ri0\sl-306\slmu
lt0 \fs16\cf0\f0\charscalex100 { pos = strstr(source, search);}\par\pard\li2360

\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 { if(pos==NULL)}\par\pard\li2360
\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213
\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("\\
n%s is not found",search);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\char
scalex100 { \}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
else}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par
i = }\fs16\cf0\f
0\charscalex100 {source - pos;}\par\pard\li2360\ri0\sl-320\slmult0 \fs16\cf0\f0\
charscalex100 {
}\fs16\cf0\f0\charscalex100 {if(i < 0) i = -i;}\par\pard\li23
printf}\fs16\cf0\f0\charsc
alex100 {("%s is found at position %d",search,i);}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-213\slmult0 \fs14
\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\chars
calex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100
{Source is found at position 12}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\pa
slmult0 \fs18\cf0\f0\charscalex100 {41}\par\pard\sect\sectd\sbkpage
7;32768}}
7;32768}}

0\f0\charscalex100 {8. This program is an illustration for an array of pointers
for strings.}\par\pard\li2360\ri0\sl-386\slmult0 \fs12\cf0\f0\charscalex100 {/**
**********************************************************/}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* array of pointers - swap two arra
y elements */}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/*
***********************************************************/}\par\pard\li2360\ri
0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\
\cf0\f0\charscalex100 { char *myarray[] = \{"first","second","third","fourth"\}
;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char *myvar;
}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nBe
fore swapping %s : %s",myarray[1],myarray[2]);}\par\pard\li2360\ri0\sl-400\slmul
t0 \fs16\cf0\f0\charscalex100 { myvar = myarray[1];}\par\pard\li2360\ri0\sl-213\
slmult0 \fs16\cf0\f0\charscalex100 { myarray[1] = myarray[2];}\par\pard\li2360\r
i0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { myarray[2] = myvar;}\par\pard\li2
360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nAfter swapping %
s : %s",myarray[1],myarray[2]);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0
\charscalex100 {\}}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex10
0 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Before
swapping second : third}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsc
alex100 {After swapping third : second}\par\pard\li1226\ri0\sl-213\slmult0 \fs18
\cf0\par\pard\li1226\ri0\sl-400\slmult0 \fs22\cf0\f0\charscalex100 {9. This prog
ram is an illustration that explains how to use pointers to make a function retu
rn more}\par\pard\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {than one
value.}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 {main()}\
60\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int a,b,c;}\par\pard\li2360\
ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int sum,product;}\par\pard\li23
60\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnter the values
separated by space bar");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\chars
calex100 { scanf("%d %d %d",&a,&b,&c);}\par\pard\li2360\ri0\sl-386\slmult0 \fs1
6\cf0\f0\charscalex100 { calculate(a,b,c,&sum,&product);}\par\pard\li2360\ri0\s
l-400\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nThe sum of the numbers :
%d",sum);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { prin
tf("\\nThe product of the numbers : %d",product);}\par\pard\li2360\ri0\sl-386\sl
mult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\c
f0\f0\charscalex100 {calculate(int a,int b,int c,int *mysum,int *myprod)}\par\pa
rd\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { *mysum = a + b + c;}\par\pard\li23
60\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { *myprod = a * b * c;}\par\pa
rd\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0
\sl-346\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\s
lmult0 \fs16\cf0\f0\charscalex100 {Enter the values separated by space bar 1 2 4
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {The sum of the
numbers : 7}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {The
product of the numbers : 8}\par\pard\li5133\ri0\sl-373\slmult0 \fs18\cf0\f0\char
scalex100 {42}\par\pard\sect\sectd\sbkpage

7;32768}}
7;32768}}
0\f0\charscalex100 {10. This program is an illustration that explains how to inv
oke a function using its pointer.}\par\pard\li2360\ri0\sl-426\slmult0 \fs16\cf0\
f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charsc
alex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { in
t myfunction();}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
int (*myfuncptr)();}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscale
x100 { int myarg = 10;}\par\pard\li2360\ri0\sl-226\slmult0 \fs16\cf0\f0\charsca
lex100 { myfuncptr = myfunction;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 { (*myfuncptr)(myarg);}\par\pard\li2360\ri0\sl-213\slmult0 \fs
14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-293\slmult0 \fs16\cf0\f0\cha
rscalex100 {int myfunction(int param)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\
cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsc
alex100 { printf("\\nThis is from the function %d",param);}\par\pard\li2360\ri0

\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-266\slmul
t0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\
cf0\f0\charscalex100 {This is from the function 10}\par\pard\li1120\ri0\sl-466\s
lmult0 \fs22\cf0\f0\charscalex100 {11. This program is an illustration that expl
ains how to make a function return a pointer. It converts}\par\pard\li1506\ri0\s
l-266\slmult0 \fs20\cf0\f0\charscalex100 {a string to uppercase. Though this can
be done in simpler ways, the idea is to explain the concept}\par\pard\li1506\ri
0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {of returning a pointer from a funct
ion.}\par\pard\li2360\ri0\sl-280\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par
\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\
ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char *upper;}\par\pard\li2360\r
i0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char *upper_function();}\par\par
d\li2360\ri0\sl-253\slmult0 \fs16\cf0\f0\charscalex100 { char input[20],output[
20];}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 { printf("\
\nEnter a string : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 { gets(input);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscale
x100 { upper = upper_function(input,output);}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 { printf("\\nGiven string is %s",input);}\par\pard
\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nConverted st
ring is %s",upper);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex1
00 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {char *upp
er_function(char *i,char *o)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\ch
char *myptr;}\par\pard\li2360\ri0\sl-280\slmult0 \fs16\cf0\f0\charscalex100 {
myptr = o;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { wh
ile (*i != '\\0')}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100
{ \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
*o =
t}\fs16\cf0\f0\charscalex100 {oupper(*i);}\par\pard\li2360\ri0\sl-213\slmult0 \f
s16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {o++;}\par\pard\li2360
\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
i++;}\par\pard\li2360\ri0\sl
-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 { *o = '\\0';}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 { return(myptr);}\par\pard\li2360\ri0\sl-213\slmult0
\fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 {Output}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 {Enter a string : testing}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 {Given string is testing}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
6\cf0\f0\charscalex100 {Converted string is TESTING}\par\pard\li5133\ri0\sl-453\
slmult0 \fs18\cf0\f0\charscalex100 {43}\par\pard\sect\sectd\sbkpage
7;32768}}

0\f0\charscalex100 {12. This program is an illustration that explains how to pas
s the pointer of a structure to a function.}\par\pard\li2360\ri0\sl-400\slmult0
\fs16\cf0\f0\charscalex100 {struct currency}\par\pard\li2360\ri0\sl-213\slmult0
\fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 { int rupees;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\ch
arscalex100 { int paise;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\chars
calex100 {\};}\par\pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100 {ma
in()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\par
d\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { struct currency mycurr
= \{123,25\};}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
showit(&mycurr);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100
{\}}\par\pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100 {showit(stru
ct currency *myptr)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex1
00 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("
\\nRupees %d.%d",myptr->rupees,myptr->paise);}\par\pard\li2360\ri0\sl-213\slmult
0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f
0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charsca
lex100 {Rupees 100.25}\par\pard\li1120\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1
120\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1120\ri0\sl-293\slmult0 \fs20\cf0\f0
\charscalex100 {13. This program is an illustration that explains how to pass va
riable number of arguments to a}\par\pard\li1506\ri0\sl-266\slmult0 \fs22\cf0\f0
\charscalex100 {function using pointers. This uses stdarg.h for this purpose.}\p
ar\pard\li2360\ri0\sl-413\slmult0 \fs16\cf0\f0\charscalex100 {#include "stdarg.h
"}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {main()}\par\pa
rd\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int sum;}\par\pard\li2360\ri0\sl-3
60\slmult0 \fs16\cf0\f0\charscalex100 { sum = computesum(4,2,3,4,5);}\par\pard\
li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nSum of the 4
numbers is %d",sum);}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex
100 { sum = computesum(3,2,3,4);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 { printf("\\nSum of the 3 numbers is %d",sum);}\par\pard\li236

0\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl-373\
slmult0 \fs16\cf0\f0\charscalex100 {computesum(int no_of_args,...)}\par\pard\li2
3\slmult0 \fs16\cf0\f0\charscalex100 { int mysum,i,myparam;}\par\pard\li2360\ri
0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { va_list myptr;}\par\pard\li2360\r
i0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { va_start(myptr,no_of_args);}\par\
pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { mysum=0;}\par\pard\
li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { for(i=0; i < no_of_args;
i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\
pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
m}\fs16\cf0\f0\ch
arscalex100 {yparam = va_arg(myptr,int);}\par\pard\li2360\ri0\sl-213\slmult0 \fs
m}\fs16\cf0\f0\charscalex100 {ysum = mysum + mypara
m;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\par
d\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100 { return(mysum);}\par\pa
rd\li5133\ri0\sl-440\slmult0 \fs18\cf0\f0\charscalex100 {44}\par\pard\sect\sectd
\sbkpage
f0\par\pard\li2360\ri0\sl-320\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\l
\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Sum of the 4 numbers is 14}\par\pard
\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Sum of the 3 numbers is 9
}\par\column\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmul
t0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\s
lmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-2
13\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\
sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\
ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\
li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\p
ard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\p
ar\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\c
f0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs
18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0
\fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slm
d\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par
\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0
\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18
\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \
fs18\cf0\par\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmul
\slmult0 \fs18\cf0\f0\charscalex100 {45}\par\pard\sect\sectd\sbkpage
7;32768}}

charscalex100 {FILE MANAGEMENT IN C}\par\pard\li1226\ri0\sl-466\slmult0 \fs22\cf
0\f0\charscalex100 {1. You can also use fputc() to write to a file and fgetc() t
o read from a file. This example illustrates}\par\pard\li1520\ri0\sl-266\slmult0
\fs22\cf0\f0\charscalex100 {these functions.}\par\pard\li2360\ri0\sl-386\slmult
0 \fs16\cf0\f0\charscalex100 {/* writing and reading from a file using fgetc and
fputc() */}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 {#inc
lude <stdio.h>}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 {m
ain()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pa
rd\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { FILE *myfile;}\par\pa
rd\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char text[100];}\par\
pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int i;}\par\pard\li
2360\ri0\sl-293\slmult0 \fs16\cf0\f0\charscalex100 { myfile = fopen("example.tx
t", "w+");}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { pri
ntf("Enter a sentence to store in the file : ");}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs16\cf0\f0\charscalex100 { gets(text);}\par\pard\li2360\ri0\sl-360\slmul
t0 \fs16\cf0\f0\charscalex100 { for(i=0; text[i]; i++)}\par\pard\li2360\ri0\sl213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0
}\fs16\cf0\f0\charscalex100 {fputc(text[i],myfi
le);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\p
ard\li2360\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 { fclose(myfile);}\par
\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { myfile = fopen("ex
ample.txt", "r");}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100
{ printf("\\n The file has : ");}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0
\f0\charscalex100 { while(!feof(myfile))}\par\pard\li2360\ri0\sl-213\slmult0 \f
s14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 {
}\fs16\cf0\f0\charscalex100 {printf("%c", fgetc(myfile));}\pa
r\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li23
60\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 { fclose(myfile);}\par\pard\li
60\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-386\slmult
0 \fs16\cf0\f0\charscalex100 {Enter a sentence to store in the file : this is an
example for fgetc() and fputc()}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f
0\charscalex100 {The file has : this is an example for fgetc() and fputc()}\par\
pard\li1226\ri0\sl-453\slmult0 \fs22\cf0\f0\charscalex100 {2. This example illus
trates how you can append (add) to the contents of an existing file.}\par\pard\l
i2360\ri0\sl-386\slmult0 \fs12\cf0\f0\charscalex100 {/**************************
f0\f0\charscalex100 {/* illustrating file append operation */}\par\pard\li2360\r
****************************/}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\c
harscalex100 {#include <stdio.h>}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f
0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charsca
lex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { FIL
E *myfile;}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl400\slmult0 \fs18\cf0\f0\charscalex100 {46}\par\pard\sect\sectd\sbkpage
0\f0\charscalex100 { char text[100];}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 { int i;}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\
charscalex100 { myfile = fopen("example.txt", "a");}\par\pard\li2360\ri0\sl-400
\slmult0 \fs16\cf0\f0\charscalex100 { printf("Enter a sentence to store in the
file : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { get
s(text);}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { for(i
=0; text[i]; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100
{ \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs1
6\cf0\f0\charscalex100 {fputc(text[i],myfile);}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs14\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf
0\f0\charscalex100 { fclose(myfile);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\
cf0\f0\charscalex100 { myfile = fopen("example.txt", "r");}\par\pard\li2360\ri0

\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\n The file has : ");}\pa
r\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 { while(!feof(myfil
e))}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\par\pa
}\fs16\cf0\f0\chars
calex100 {printf("%c", fgetc(myfile));}\par\pard\li2360\ri0\sl-213\slmult0 \fs14
\cf0\f0\charscalex100 { \}}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\cha
rscalex100 { fclose(myfile);}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\c
harscalex100 {\}}\par\pard\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100
{Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Enter a
sentence to store in the file : This is the new line added}\par\pard\li2360\ri0\
sl-400\slmult0 \fs16\cf0\f0\charscalex100 {this is an example for fgetc() and fp
utc()}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {this is th
e new line added}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1226\r
i0\sl-400\slmult0 \fs22\cf0\f0\charscalex100 {3. This example illustrates how to
use fputs() and fputs() to write to a file. Unlike character based I/}\par\pard
\li1520\ri0\sl-266\slmult0 \fs22\cf0\f0\charscalex100 {O (fgetc), these are stri
ng based functions. Note the usage of feof() to check end of file.}\par\pard\li2
360\ri0\sl-426\slmult0 \fs12\cf0\f0\charscalex100 {/****************************
f0\f0\charscalex100 {/* usage of fgets and fputs */}\par\pard\li2360\ri0\sl-213\
slmult0 \fs12\cf0\f0\charscalex100 {/*******************************************
********************/}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscale
x100 {#include <stdio.h>}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsc
alex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {
\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { FILE *myfil
e;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char *text;
}\par\pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100 { myfile = fope
n("example.txt", "w");}\par\pard\li2360\ri0\sl-400\slmult0 \fs16\cf0\f0\charscal
ex100 { printf("Enter a line to be stored : ");}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs16\cf0\f0\charscalex100 { gets(text);}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { fputs(text, myfile);}\par\pard\li2360\ri0\sl-21
3\slmult0 \fs16\cf0\f0\charscalex100 { fclose(myfile);}\par\pard\li2360\ri0\sl360\slmult0 \fs16\cf0\f0\charscalex100 { myfile = fopen("example.txt", "r");}\p
ar\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nThe f
ile has : ");}\par\pard\li5133\ri0\sl-346\slmult0 \fs18\cf0\f0\charscalex100 {47
}\par\pard\sect\sectd\sbkpage
7;32768}}
0\f0\charscalex100 { while(!feof(myfile))}\par\pard\li2360\ri0\sl-213\slmult0 \
fs14\cf0\f0\charscalex100 { \{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 {
prin}\fs16\cf0\f0\charscalex100 {tf("%s", fgets(text, 10, my
file));}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \}}\pa
r\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { fclose(myfile);}\
par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li23
60\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl
-400\slmult0 \fs16\cf0\f0\charscalex100 {Enter a line to be stored : usage of fp
uts and fgets}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {Th
e file has : usage of fputs and fgets}\par\pard\li1226\ri0\sl-213\slmult0 \fs18\
lt0 \fs22\cf0\f0\charscalex100 {4. This example shows how to copy one file to an
other using fread() and fwrite(). Notice the usage}\par\pard\li1520\ri0\sl-266\s
lmult0 \fs22\cf0\f0\charscalex100 {of two file pointers, one for input file and
other for output file.}\par\pard\li2360\ri0\sl-426\slmult0 \fs12\cf0\f0\charscal
ex100 {/**************************************************************/}\par\par
d\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* fread and fwrite for
multiple line read and write */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 {/* program which copies from one file to another file */}\par\pa
rd\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscalex100 {/**********************
****************************************/}\par\pard\li2360\ri0\sl-360\slmult0 \f
s16\cf0\f0\charscalex100 {#include <stdio.h>}\par\pard\li2360\ri0\sl-213\slmult0
\fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf
0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 { FILE *inputfile;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\chars
calex100 { FILE *outputfile;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\c
harscalex100 { char text[100];}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 { int chars;}\par\pard\li2360\ri0\sl-320\slmult0 \fs16\cf0\f0\ch
arscalex100 { inputfile = fopen("size.c", "r");}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs16\cf0\f0\charscalex100 { outputfile = fopen("exam.txt", "w");}\par\par
d\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { /* in fread, 1 indicat
es how many characters to be read at a time and */}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 { /* 50 indicates how many characters to be r
ead from the file */}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex

100 { chars = fread(text, 1, 100, inputfile);}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs16\cf0\f0\charscalex100 { fwrite(text, 1, chars, outputfile);}\par\pard\l
i2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { fclose(inputfile);}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { fclose(outputfile);}
\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { outputfile = f
open("exam.txt", "r");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 { chars = fread(text, 1, 100, outputfile);}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs16\cf0\f0\charscalex100 { printf("%s", text;}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 { fclose(outputfile);}\par\pard\li2360\ri
lt0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-400\slmult0 \fs12
\cf0\f0\charscalex100 {/********************************************************
********/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* Pro
gram to demonstrate the sto}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pa
cf0\par\pard\li5133\ri0\sl-400\slmult0 \fs18\cf0\f0\charscalex100 {48}\par\pard\
sect\sectd\sbkpage
0\f0\charscalex100 {5. This example is to generate a calendar for a given month
and year. The output is stored in a file.}\par\pard\li1520\ri0\sl-266\slmult0 \f
s22\cf0\f0\charscalex100 {This is an example for formatted outputs.}\par\pard\li
2360\ri0\sl-413\slmult0 \fs16\cf0\f0\charscalex100 {#include <stdio.h>}\par\pard
\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {#define TRUE 1}\par\pard\
li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {#define FALSE 0}\par\pard\
li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {int check_leap (int year);
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {void construct
(FILE *outputfile, int year,int month, int day_code, int}\par\pard\li2360\ri0\sl
-213\slmult0 \fs16\cf0\f0\charscalex100 {leap);}\par\pard\li2360\ri0\sl-373\slmu
lt0 \fs16\cf0\f0\charscalex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14
\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\chars
calex100 { FILE *outpu}\fs16\cf0\f0\charscalex100 {tfile;}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { int }\fs16\cf0\f0\charscalex100 {y
ear,week_day_number,leap,month;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0
\charscalex100 { int a,b,c;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\c
harscalex100 { outputfile = fopen ("cal.txt", "w");}\par\pard\li2360\ri0\sl-21
3\slmult0 \fs16\cf0\f0\charscalex100 { prin}\fs16\cf0\f0\charscalex100 {tf("\\
nEnter year : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{ scanf("%d",&year);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsca
lex100 { printf("\\nEnter month : ");}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
6\cf0\f0\charscalex100 { scanf("%d",&month);}\par\pard\li2360\ri0\sl-280\slmul
t0 \fs16\cf0\f0\charscalex100 { /* use Zeller's congreunce to find the first d
ay of the year */}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{ a = }\fs16\cf0\f0\charscalex100 {(year - 1.0) / 4.0;}\par\pard\li2360\ri0\s
l-213\slmult0 \fs16\cf0\f0\charscalex100 { b = }\fs16\cf0\f0\charscalex100 {(y
ear - 1.0) / 100.0;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex1
00 { c = }\fs16\cf0\f0\charscalex100 {(year - 1.0)/ 400.0;}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { week_day_number = (year + a - b
+ c) % 7;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { lea
p = check_leap (year);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 { construct(outputfile, year,month, week_day_number, leap);}\par\pard\li2
6\slmult0 \fs16\cf0\f0\charscalex100 {int check_leap (int year)}\par\pard\li2360
\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 { if ((year % 4 == 0) && (year % 100 != 0) |
| (year%400 == 0))}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex10
0 {
}\fs16\cf0\f0\charscalex100 {return TRUE;}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs16\cf0\f0\charscalex100 { else}\par\pard\li2360\ri0\sl-213\slmult0 \f
s16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {return FALSE;}\par\p
ard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri
0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 {void construct (FILE *outputfile, i
nt year,int month, int}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscal
ex100 {week_day_number, int leap)}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\
f0\charscalex100 {\{}\par\pard\li2920\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex
100 {int days,daycount;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsc
alex100 {
sw}\fs16\cf0\f0\charscalex100 {itch ( month )}\par\pard\li2360\ri0\
\{}\par\pard\li2360\ri0\sl-213\sl
}\fs16\cf0\f0\charscalex100 {case 1:}\pa
}\fs16\cf0
\f0\charscalex100 {days = 31;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\c
harscalex100 {
}\fs16\cf0\f0\charscalex100 {break;}\par\pard\li2360\ri0\
}\fs16\cf0\f0\charscalex100 {ca
se 2:}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}
\fs16\cf0\f0\charscalex100 {days = leap ? 29 : 28;}\par\pard\li2360\ri0\sl-213\s
}\fs16\cf0\f0\charscalex100 {break;}
93\slmult0 \fs18\cf0\f0\charscalex100 {49}\par\pard\sect\sectd\sbkpage

}\fs16\cf0\f0\charscalex100 {case 3:}\par\pard\li2360\
}\fs16\cf0\f0\charscalex
100 {days = 31;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {break;}\par\pard\li2360\ri0\sl-373\slmult0
}\fs16\cf0\f0\charscalex100 {case 4:}\par\par
}\fs14\cf0\f0\c
harscalex100 {days = 30;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsc
alex100 {
}\fs16\cf0\f0\charscalex100 {break;}\par\pard\li2360\ri0\sl-37
}\fs16\cf0\f0\charscalex100 {case 5:
}\fs14
\cf0\f0\charscalex100 {days = 31;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\
f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {break;}\par\pard\li2360\
{case 6:}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {
}\fs14\cf0\f0\charscalex100 {days = 30;}\par\pard\li2360\ri0\sl-213\slmult0 \
}\fs16\cf0\f0\charscalex100 {break;}\par\par
}\fs16\cf0\f0\char
scalex100 {case 7:}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex10
0 {
}\fs14\cf0\f0\charscalex100 {days = 31;}\par\pard\li2360\ri0\sl-213\
}\fs16\cf0\f0\charscalex100 {break;
}\fs16\cf
0\f0\charscalex100 {case 8:}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\cha
rscalex100 {
}\fs14\cf0\f0\charscalex100 {days = 31;}\par\pard\li2360\ri
0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
0 {break;}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {case 9:}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\c
f0\f0\charscalex100 {
}\fs14\cf0\f0\charscalex100 {days = 30;}\par\pard\
}\fs16\cf0\f0\cha
rscalex100 {break;}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex10
0 {
}\fs16\cf0\f0\charscalex100 {case 10:}\par\pard\li2360\ri0\sl-213\slmul
t0 \fs14\cf0\f0\charscalex100 {
}\fs14\cf0\f0\charscalex100 {days = 31;}
\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\
cf0\f0\charscalex100 {break;}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\ch
arscalex100 {
}\fs16\cf0\f0\charscalex100 {case 11:}\par\pard\li2360\ri0\sl
}\fs14\cf0\f0\charscalex100 {d
ays = 30;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {break;}\par\pard\li2360\ri0\sl-373\slmult0 \fs16
}\fs16\cf0\f0\charscalex100 {case 12:}\par\pard\li2
alex100 {days = 31;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex1
00 {
}\fs16\cf0\f0\charscalex100 {break;}\par\pard\li2360\ri0\sl-213\slm
ult0 \fs16\cf0\f0\charscalex100 {
\}}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
}\fs16\cf0\f0\charscalex100 {fprintf(outputfile,"\\n
\\nSun |Mon |Tue |Wed |Thu |Fri |Sat\\n" );}\par\pard\li2360\ri0\sl-213\slmult0
for ( }\fs16\cf0\f0\charscalex100 {daycount = 1;
daycount <= 1 + week_day_number * 5; daycount++ )}\par\pard\li2360\ri0\sl-213\s
fprin}\fs16\cf0\f0\charscalex100 {tf(o
utputfile," " );}\par\pard\li2360\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100

{
for ( }\fs16\cf0\f0\charscalex100 {daycount = 1; daycount <= days; daycount
++ )}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
\{}\par
fprintf}\fs16
\cf0\f0\charscalex100 {(outputfile,"%2d", daycount );}\par\pard\li2360\ri0\sl-21
if ( ( }\fs16\cf0\f0\charscalex100
{daycount + week_day_number ) % 7 > 0 )}\par\pard\li2360\ri0\sl-213\slmult0 \fs1
}\fs16\cf0\f0\charscalex100 {fprintf(outputfil
e," | " );}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
else}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
}\fs16\cf0\f0\charscalex100 {fprintf(outputfile, "\\n " );}\par\pard\li2360\ri0
\}}\par\pard\li2360\ri0\sl-213\s
}\fs16\cf0\f0\charscalex100 {week_day_num
ber = ( week_day_number + days ) % 7;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\
cf0\f0\charscalex100 {\}}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\
li5133\ri0\sl-346\slmult0 \fs18\cf0\f0\charscalex100 {50}\par\pard\sect\sectd\sb
kpage
7;32768}}
charscalex100 {DYNAMIC MEMORY ALLOCATION AND LINKED LISTS}\par\pard\li1226\ri0\s
l-466\slmult0 \fs22\cf0\f0\charscalex100 {1. This example is to illustrate the u
sage of malloc for characters.}\par\pard\li2360\ri0\sl-413\slmult0 \fs12\cf0\f0\
charscalex100 {/****************************************************************
*/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {/* usage of m
alloc in characters */}\par\pard\li2360\ri0\sl-213\slmult0 \fs12\cf0\f0\charscal
ex100 {/*****************************************************************/}\par\
pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\charscalex100 {#include <stdio.h>}\p
ar\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {#include <string.h
>}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {#include <stdl
ib.h>}\par\pard\li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 {main()}\pa
r\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\{}\par\pard\li2360
\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char *first = "Programming ";}
\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char *second =
"Language";}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { c
har *final;}\par\pard\li2360\ri0\sl-306\slmult0 \fs16\cf0\f0\charscalex100 { fi
nal = (char *)malloc((strlen(first) + strlen(second) + 1)*sizeof(char));}\par\pa
rd\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex100 { strcpy(final, first);
}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { strcat(final,
second);}\par\pard\li2360\ri0\sl-360\slmult0 \fs16\cf0\f0\charscalex100 { prin
tf("first: %s\\n", first);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\char
scalex100 { printf("second: %s\\n", second);}\par\pard\li2360\ri0\sl-213\slmult
0 \fs16\cf0\f0\charscalex100 { printf("concatenated: %s\\n", final);}\par\pard\
li2360\ri0\sl-333\slmult0 \fs16\cf0\f0\charscalex100 { free(final);}\par\pard\l
i2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2360\ri0\sl373\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl-373\slmul
t0 \fs16\cf0\f0\charscalex100 {first: Programming}\par\pard\li2360\ri0\sl-213\sl
mult0 \fs16\cf0\f0\charscalex100 {second: Language}\par\pard\li2360\ri0\sl-213\s
lmult0 \fs16\cf0\f0\charscalex100 {concatenated: Programming Language}\par\pard\
\f0\charscalex100 {2. This example is to illustrate the usage of calloc for char
acters.}\par\pard\li2360\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li2360\ri0\sl-240
\slmult0 \fs12\cf0\f0\charscalex100 {/******************************************
**********************/}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charsca
lex100 {/* usage of calloc for strings */}\par\pard\li2360\ri0\sl-213\slmult0 \f
s12\cf0\f0\charscalex100 {/*****************************************************
***********/}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 {#in
clude <stdio.h>}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {
#include <string.h>}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex1
00 {#include <stdlib.h>}\par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charsca
lex100 {main()}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\
{}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char *first
= "Programming ";}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100
{ char *second = "Language";}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\
charscalex100 { char *final;}\par\pard\li2360\ri0\sl-346\slmult0 \fs16\cf0\f0\c
harscalex100 { final = (char *)calloc(strlen(first) + strlen(second) + 1, sizeo
f(char));}\par\pard\li5133\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li5133\ri0\sl-2
80\slmult0 \fs18\cf0\f0\charscalex100 {51}\par\pard\sect\sectd\sbkpage

f0\par\pard\li2360\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100 { strcat(final
, first);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { strc
at(final, second);}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex10
0 { printf("first: %s\\n", first);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf
0\f0\charscalex100 { printf("second: %s\\n", second);}\par\pard\li2360\ri0\sl-2
13\slmult0 \fs16\cf0\f0\charscalex100 { printf("concatenated: %s\\n", final);}\
par\pard\li2360\ri0\sl-373\slmult0 \fs16\cf0\f0\charscalex100 { free(final);}\p
0\ri0\sl-400\slmult0 \fs16\cf0\f0\charscalex100 {Output}\par\pard\li2360\ri0\sl400\slmult0 \fs16\cf0\f0\charscalex100 {first: Programming}\par\pard\li2360\ri0\
sl-213\slmult0 \fs16\cf0\f0\charscalex100 {second: Language}\par\pard\li2360\ri0
\sl-213\slmult0 \fs16\cf0\f0\charscalex100 {concatenated: Programming Language}\
par\column\pard\li0\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li0\ri0\sl-213\slmult0

lmult0 \fs18\cf0\f0\charscalex100 {52}\par}

C and Data Structures Balaguruswamy

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

C and Data Structures Balaguruswamy

Caricato da

Copyright:

Formati disponibili

{\rtf\ansi\deff0\ansicpg1252

{\sp{\sn lineWidth}{\sv 50799}}

{\sp{\sn fFlipV}{\sv 0}}

{\sp{\sn fBehindDocument}{\sv 1}}

{\sp{\sn fFlipH}{\sv 0}}

f(signed int)*8);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100

226\slmult0 \fs16\cf0\f0\charscalex100 {signed short int}\fs16\cf0\f0\charscalex

{\sp{\sn geoRight}{\sv 6707}}

360\ri0\sl-226\slmult0 \fs16\cf0\f0\charscalex100 {typedef unsigned short int UN

{\sp{\sn lineDashing}{\sv 0}}

{\sp{\sn shapePath}{\sv 4}}

16\cf0\f0\charscalex100 { int number;}\par\pard\li2360\ri0\sl-213\slmult0 \fs16

{\sp{\sn lineDashing}{\sv 0}}

{\sp{\sn pVerticies}{\sv 8;5;(0,0);(0,4213);(6706,4213);(6706,0);(0,0);}}

\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { char mystring[100];}\par\pard\

{\sp{\sn lineType}{\sv 0}}

harscalex100 {DECISION MAKING AND LOOPING}\par\pard\li1226\ri0\sl-466\slmult0 \f

{\sp{\sn fFlipH}{\sv 0}}

226\ri0\sl-346\slmult0 \fs22\cf0\f0\charscalex100 {2. We will now develop a prog

{\sp{\sn pVerticies}{\sv 8;5;(0,0);(0,8333);(6706,8333);(6706,0);(0,0);}}

l-240\slmult0 \fs16\cf0\f0\charscalex100 { printf("\\nEnter the maximum number

{\sp{\sn fLine}{\sv 1}}{\sp{\sn lineColor}{\sv 0}}

{\sp{\sn geoRight}{\sv 6720}}

done only up to half of the array size.}\par\pard\li2360\ri0\sl-400\slmult0 \fs1

par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { long int firsta

{\sp{\sn lineWidth}{\sv 6350}}

{\sp{\sn fFlipH}{\sv 0}}

{\sp{\sn lineType}{\sv 0}}

100 {print the matrices */}\par\pard\li2920\ri0\sl-400\slmult0 \fs16\cf0\f0\char

charscalex100 { for(i=0; i < rows; i++)}\par\pard\li2360\ri0\sl-213\slmult0 \fs

ult0 \fs16\cf0\f0\charscalex100 {Enter element at row 0 column 1 3}\par\pard\li2

{\sp{\sn lineWidth}{\sv 6096}}

\fs16\cf0\f0\charscalex100 {int x,y;}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\

0\sl-213\slmult0 \fs18\cf0\par\pard\li1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard

{\sp{\sn fFlipH}{\sv 0}}

{\sp{\sn shapeType}{\sv 0}}

mult0 \fs22\cf0\f0\charscalex100 {numbers in an array. The array is passed to a

{\sp{\sn fBehindDocument}{\sv 1}}

li2360\ri0\sl-426\slmult0 \fs12\cf0\f0\charscalex100 {/*************************

{\sp{\sn lineWidth}{\sv 6096}}

employee}\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 { \{}\

{\sp{\sn fFilled}{\sv 0}}

\par\pard\li2360\ri0\sl-213\slmult0 \fs14\cf0\f0\charscalex100 {\}}\par\pard\li2

-213\slmult0 \fs12\cf0\f0\charscalex100 {/**************************************

{\sp{\sn fArrowheadsOK}{\sv 0}}

book);}\par\pard\li2360\ri0\sl-213\slmult0 \fs16\cf0\f0\charscalex100 { printf(

\pard\li4066\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li4066\ri0\sl-213\slmult0 \fs

6\cf0\f0\charscalex100 { myptr = myarray;}\par\pard\li2360\ri0\sl-400\slmult0 \

{\sp{\sn fLine}{\sv 1}}{\sp{\sn lineColor}{\sv 0}}

i1226\ri0\sl-213\slmult0 \fs18\cf0\par\pard\li1226\ri0\sl-373\slmult0 \fs22\cf0\

{\sp{\sn fArrowheadsOK}{\sv 0}}

lt0 \fs16\cf0\f0\charscalex100 { pos = strstr(source, search);}\par\pard\li2360

{\sp{\sn fArrowheadsOK}{\sv 0}}

{\sp{\sn fFlipH}{\sv 0}}

alex100 { printf("\\nThis is from the function %d",param);}\par\pard\li2360\ri0

{\sp{\sn fBehindDocument}{\sv 1}}

f0\charscalex100 { printf("\\nSum of the 3 numbers is %d",sum);}\par\pard\li236

{\sp{\sn lineColor}{\sv 0}}

cf0\f0\charscalex100 { myfile = fopen("example.txt", "r");}\par\pard\li2360\ri0

ead from the file */}\par\pard\li2360\ri0\sl-386\slmult0 \fs16\cf0\f0\charscalex

{\sp{\sn lineDashing}{\sv 0}}

utputfile," " );}\par\pard\li2360\ri0\sl-320\slmult0 \fs16\cf0\f0\charscalex100

{\sp{\sn fFlipV}{\sv 0}}