C Program in Khmer

vCBk
karsresrkmμviFI C
C Programming
(practice)
-I-
vCBk
matikar
CMBUkTI 1 : karENnaM ................................................................................................8
1.1 Rbvtiþrbs;Pasa C ...............................................................................................................9
1.2 critlkçN³rbs;Pasa C .....................................................................................................9
1.3 rcnasm<½n§kmμviFI C..............................................................................................................10
1.4 karbkRsaykmμviFI .............................................................................................................12
1.5 KMrUkarbkRsay C ..............................................................................................................15
lMhat; .......................................................................................................................... 16
CMBUkTI 2 : RbePT Types, RbmaNviFI Operations nigkenSam Expressions 18
2.1 eQμaHGBaaØt .......................................................................................................................19
2.2 RbePTTinñn½ynigTMhM ...........................................................................................................19
2.3 PaBminERbRbYl (Constants) ...............................................................................................21
2.4 karRbkas (Declarations) ..................................................................................................23
2.5 RbmaNviFInBVnþsaRsþ (Arithmetic Operations)...................................................................24
2.6 RbmaNviFIeRbobeFob .........................................................................................................25
2.7 RbmaNviFItkáviTüa Logical Operations...............................................................................25
2.8 RbmaNviFI Bitwise Bitwise Operations .............................................................................26
2.9 RbmaNviFIkMenIn ..................................................................................................................28
2.10 RbmaNviFIepÞrnigkenSam ...................................................................................................28
2.11 lMdab;énGTiPaB ................................................................................................................29
lMhat;......................................................................................................................................30
CMBUkTI 3: l½kçx½NÐ ...................................................................................................33
3.1 Xøanigbøúk............................................................................................................................34
3.2 Xøa if .................................................................................................................................34
3.3 RbmaNviFI ? ......................................................................................................................36
3.4 Xøa switch..........................................................................................................................37
lMhat;......................................................................................................................................38
-II-
vCBk
CMBUkTI 4: CMu Looping nigkareFIVeLIgvij Iteration.....................................40
4.1 kenSamBakübgÁab; .............................................................................................................41
4.2 kenSamBakübgÁab; while .................................................................................................43
4.3 kenSamBakübgÁab; do-while .........................................................................................43
4.4 break nig continue ...................................................................................................44
lMhat; .....................................................................................................................................45
CMBUkTI 5: Arrays nig Strings .................................................................................48
5.1 Array mYyvimaRtnigeRcInvimaRt ..........................................................................................49
5.2 Strings ..............................................................................................................................50
lMhat; .....................................................................................................................................50
CMBUkTI 6 : GnuKmn_ Functions ..............................................................................52
6.1 mUldæanRKwHrbs;GnuKmn_ .....................................................................................................53
6.2 Arguments - Call by Value ..............................................................................................57
6.3 GnuKmn_nig Arrays ............................................................................................................58
6.4 KMrUedImGnuKmn_ ...................................................................................................................58
lMhat; .....................................................................................................................................59
CMBUkTI 7 : RbePTTinñn½yBisþabEnßm ..............................................................63
7.1 GBaaØtsV½yRbvtþi nig GBaaØtxageRkA ...................................................................................64
7.2 GBaaØt Static .....................................................................................................................69
7.3 GBaaØt Register .................................................................................................................70
7.4 karRKb;RKgTMhMkargar .........................................................................................................71

7.5 Structures..........................................................................................................................72
7.6 kMnt;RbePTTinñn½yfμI ...........................................................................................................73
7.7 Unions ..............................................................................................................................74
7.8 Coercion or Type-Casting ................................................................................................73
7.9RbePT Enumerate .............................................................................................................74
lMhat;......................................................................................................................................74
CMBUkTI 8 : Pointers .........................................................................................................75
8.1 GIVeTACa Pointer? ...............................................................................................................83
8.2 Pointer nig GnuKmn_ Functions ..........................................................................................86
-II-
vCBk
8.3 Pointers nig Arrays ..........................................................................................................87
8.4 Arrays én Pointers ...........................................................................................................89
8.5 array eRcInvimaRt nig pointers ............................................................................................90
8.6 Static Initialisation én Pointer Arrays .............................................................................92
8.7 Pointers nig Structures .....................................................................................................92
8.8 eRKaHfñak; Pointer Fmμta .....................................................................................................95
lMhat; .....................................................................................................................................96
CMBUkTI 9: Memory EdlTukeGacERbRbYlnig Structures EdlERbRbYl ..............97
9.1 Malloc, Sizeof, nig Free....................................................................................................92
9.2 Calloc nig Realloc ............................................................................................................99

9.3 Linked Lists ....................................................................................................................... 100
9.4kmμviFIeBjelj : queue.c ........................................................................................ 100
lMhat; .......................................................................................................................... 102
CMBUkTI 10 : The C Preprocessor ..................................................................................104
10.1 #define ...........................................................................................................................105
10.2 #include ........................................................................................................................... 106
10.3 #undef nig #if karrab;bBa©Úll½kçx½NÐ ................................................................................. 106
10.4XøabBa¢a Preprocessor ..................................................................................................... 107
lMhat; ..........................................................................................................................108
CMBUkTI 11 : C, UNIX nig Standard Libraries ............................................................109
11.1 KuNsm,itþénkareRbIR)as; UNIX CamYy C ....................................................................... 110
11.2 karehARbB½n§ UNIX eRbIR)as;nigGnuKmn_ Library ......................................................111
CMBUkTI 12: GnuKmn_ Integer, cMnYnécdnü,karpøas;bþÚr String,

karravrknigtMerob : <stdlib.h> .............................. 112
12.1 GnuKmn_BiCKNit ..............................................................................................................113
12.2 cMnYnécdnü ......................................................................................................................114
12.3 karpøas;bþÚr String ............................................................................................................115
12.4 karravrknigtMerob .............................................................................................................. 116
lMhat; .....................................................................................................................................117
-IV-
vCBk
CMBUkTI 13: bBa©ÚlninbeBa©jTinñn½y (I/O):<stdio.h> ............................118
13.1 r)aykarN_kMhus .............................................................................................................. 119
13.2 Streams ............................................................................................................................ 120
13.3 mUldæanRKwH I/O ................................................................................................................. 121
13.4 kMnt;RTg;RTay I/O ............................................................................................................ 122
13.5 Files ................................................................................................................................. 126
13.6 I/O kMritTab ...................................................................................................................... 128
lMhat; ..........................................................................................................................129
CMBUkTI 14: GnuKmn_epSg² .................................................................................131
14.1 kareRbI String:<string.h> ......................................................................................132
14.2 karpøas;bþÚrtYrGkSrnigkarsakl,g:<ctype.h> ............................................................135
14.3 Rbtibtiþkar Memory: <memory.h> .......................................................................136
14.4 KNitsaRsþ: <math.h> ..........................................................................................137
lMhat; ..........................................................................................................................139
CMBUkTI 15 : viFIRtYtBinitü : <stdlib.h>,<unistd.h> ..................................140
lMhat; ..........................................................................................................................146
-V-
vCBk
CMBUkTI 1 esckþIepþIm
Introduction
-1-
vCBk
muneBleyIgcab;epþImemIledaysegçbelIvaküsm<½n§mUldæanrbs; C nigrcnasm<½n§eyIgpþl;Rbvtþisegçb
én C nigBinitücritlkçN³rbs;Pasa C. enAkñúgkarrMlwkénemeronenHeyIgnwgBinitüelITsSn³vis½y
mUldæanénkmμviFI C dUcCarcnasm<½n§kmμviFI C karRbkasrbs;GBaaØt RbePTTinñn½y nigRbmaNviFI.
vaCaeKalbMNgrbs;eyIgedIm,Ipþl;nUvkarENnaMy:agrh½stameKalkarN_ C EdlRsedogeTAPasakMrit
x<s;bMput. enHKWCavaküsm<½n§ (syntax) GacxusKñabnþicbnþÜcb:uEnþKMnitdUcKñaebH bit.
C BitCamannUvkareFIVeGayPJak;ep¥IltictYc :
PasakMritx<s; (High level) CaeRcIndUcCa PASCAL KWmanvin½yy:agx<s;nigrcnasm<½n§.
EteTaHCay:agNak¾edayRbytñ½ -- C KWbt;EbneRcInEmnETnehIygaysikSa. esrIPaBenHpþl;eGay
C nUvGnuPaBCaxøaMgEdlGñkeRbIR)as;EdlmanbTBiesaFn_GacmankargareFIV.
1.1 Rbvtþirbs;Pasa C
RBwtþikarN_sMxan;enAkñúgkarGPivDÆn_CaPasarbs; C KWRtUv)ankt;RtaxageRkam :
UNIX )anGPivDÆn_enAkñúgqñaM 1969 -- DEC PDP-7 PasaAssembly
BCPL – gayRsYleRbIR)as OS pþl;RbeyaCn_GPivDÆn_]bkrN_GPivDÆnmkBI BCPL . Pasa
Assembler Bi)aksresrnigBi)akrkkMhusCaxøaMg.
PasafμI B )ancUlrYmelIkTI2kñúgqñMa 1970.

srubmkPasafμI “C” bnþBIPasa “B” kñúgqñaM 1971
edayqñaM 1973 UNIX OS esÞIrEtTaMgGs;RtUv)ansresrkñúgPasa “C”.
sþg;dasMrab;;kmμviFI C KWmanlkçN³edImkMnt;edayelak Brian Kernighan. kñúgeKalbMNgedIm,IeFIV
eGayPasaenHkan;EtGacTTYlyk)anedayGnþrCati sþg;daGnþrCatiKWRtUv)anGPivDÆn_ ANSI C
(American National Standards Institute).
1.2 critlkçN³rbs;Pasa C
eyIgkt;Rtay:agsegçbmYycMnYnBIcritlkçN³rbs; C EdlkMnt;Gtßn½yPasaenHnigk¾)annaMRbCa
RbiyPaBrbs;vaCaPasasresrkmμviFI. CaFmμtaeyIgnwgsikSaCaeRcInBIRTg;RTayTMagenHtamry³kmμviFI
sikSaenH.
-2-
vCBk
TMhMtUc
kareRbIR)as;d¾FMTUlayénkarehAGnuKmn_
karvayminBi)ak -- mindUcPasa PASCAL
PasaEdlmanrcnasm<½n§
GacsresrkmμviFIkMritTab (BitWise)y:aggayRsYl
karRbtibtþi Pointer - kareRbIR)as;d¾FMTUlayrbs; pointer kñúg memory array structures
nigGnuKmn_.
\LÚv C )anRtUveRbIR)as;y:agTUlayCaPasaCMnajsMrab;;ehtuplepSg².
vamankMritx<s;kñúgkarksag
vaGacedaHRsayskmμPaBkMritTab
vabegáItkmμviFIEdlmansmtßPaB
vaGacRtUv)an compile elIkarpøas;bþÚrerOy²énkMuBüÚT½r
TMnas;FMrbs;vaKWfava)anrkeXIjkMhuslM)akEdlGaceFIVeGayvaeTArkkEnøgcab;epþImvij. EteTaHCa
y:agNak¾edaykarBüayamkñúglkçN³enHGaceGayplCaTIeBjcitþcab;taMgBI)aneronc,ab;én C
eyIgGacedaHRsaybBaðaenH)an. minmanPasaeRcIneTEdlGnuBaØatdUcenH. enHRbsinebIvaeFIVeday

RtwmRtUvnigedayRbugRby½tñnaMeTAPaBxøaMgrbs;kmμviFI C .
1.3 rcnasm<½n§kmμviFI C
kmμviFI C mYymanmUldæanRKwHTRmg;dUcxageRkam :
XøabBa¢a Preprocessor
niymn½yRbePT
KMrUedImGnuKmn_ -- karRbkasRbePTGnuKmn_nigkarbBa¢ÚnGBaaØteTAGnuKmn_
GBaaØt (Variables)
-3-
vCBk
GnuKmn_ (Function)
eyIgRtUvEtmanGnuKmn_ main().
GnuKmn_manTRmg; :
type function_name (parameters)
{
local variables
C Statements
RbsinebIRbePTénkarRbkasRtUv)anlub C snμt;faGnuKmn_epÞrtMélRbePTcMnYnKt; integer .

cMNMa : enHGacCaRbPBénbBaðakñúgkmμviFI.
dUcenHkarepÞrtMéleTAkmμviFI C dMbUgrbs;eyIg :
/* Sample program */
main()
{
printf( “I Like C \n” );
exit ( 0 );
}
cMNaM:
C RtUvkar semicolon mYyenAxagcugRKb;Xøa
printf KWCaGnuKmn_sþg;darbs; C – RtUv)anehABI main
\n mann½yfacuHbnÞat;. kare)aHecjRtUv)ancat;Ecg -- GkSreRcIn

exit() k¾CaGnuKmn_sþg;daEdlbNþaleGaykmμviFIbBa©b;. niyayeGayc,as;eTAvamincMa)ac;eTenA
TIenHxN³EdlvaCabnÞat;cugeRkayén main() ehIykmμviFInwgRtUv)anbBa©b;eTaHbICay:agNak¾
eday.
-4-
vCBk
cUrRkeLkemIlXøae)aHecjmYyepSgeTot :
printf(``.\n.1\n..2\n...3\n'');
kare)aHecjrbs;vanwgGacCa :
.
.1
..2
...3
1.4 karbkRsaykmμviFI
enAkñúgemeronenHeyIgcab;epþImedayKUrCaRTgRTayRbtibtþikarmUldæanRKwHGñkcMa)ac;RtUveFIVTal;Etcb;
edIm,I compile kmμviFI C (b¤ C++). bnÞab;mkeyIgRbtibtþielIkarBiBN’naCak;lak;KMrURbtibtþikar C
ehIynigrebob C KaMRTbNÑal½ybEnßm :
- Source file: ASCII file sresredayPasa C ( *.c)
- Object file: Binary file sresredayPasam:asIun (*.obj)
- Execution file: file EdlGacRbtibtþi ( *.exe )
- Compile: Rbtibtþikarpøas;bþÚr source file eTACa object file
- Link: RbtibtþikarbegáIt execution file BI object files
Source file Object file execution

(*.c) (*.obj) file
man C compiler CaeRcIn. cc Ca Sun compiler BIedIm. GNU C compiler gcc KWmanRbCaRbiynig
GaceRbI)ansMrab;; platform CaeRcIn. GñkeRbIR)as; PC k¾GacecHeRbI Borland bcc compiler Edr.
vak¾man compiler C++ EdlesμI EdlEtgEtbgðajR)ab;eday CC (cMNaM GkSrFM CC. ]TahrN_ Sun
pþl;eGay CC nig GNU GCC). GNU compiler k¾)anbgðajR)ab;eday g++ .
enAkñúgesovePAenH eyIgeRbI Visual C++ 6.0 compiler EdlRtUv)anbegáItedayRkumh‘un Microsoft
nigGaceRbI)ankñúg PC. Visual C++ 6.0 pþl;eGaynUvbrikçasresrkmμviFIgayRsYl gayRsYlGPivDÆn¾
user Interface MFC(Microsoft Foundation Class) nigCaKeRmagsresrkmμviFI window
EdlmanGnuPaB. eyIgnwgeRbI compiler enHsMrab;; C nig C++ class BIeRBaHedaysarvagayRsYlnig

smrmü.
-5-
vCBk
enHCarUbragrbs;Visual C++ 6.0.
Source Editing
Window
- Class View
- Resource
View
- File View
Output Display
Window
dMbUgGñkebIkkmμviFI C++ kñúg VC++ edIm,IbegáItkmμviFIkñúgfile EdleQμaHrbs;vabBa©b;eday “.cpp”

dUcviFIxageRkam : Run projects Æ Wine32 Console Application Æ Create new workspace,
bBa©ÚleQμaHkñúgeQμaHKMerag (Project name) ehIycuc OK
-6-
vCBk
bnÞab;mkeRCIserIsykRbePTénkarGnuvtþ console (console application) dUcKMrUGnuvtþenH
GñkGacEkERb file enAkñúg Source Editing Window bnÞab;mk compile nig link vaCamYyXøabBa¢a
Compile nig Build enAkúñg Build menu edayerog²xøÜn. dMNak;kalbnÞab;KWedIm,IdMeNIrkarRbtibtþi
kmμviFIBitR)akdrbs;GñkedayXøabBa¢a Execute enAkúñg Build menu. RbtibtþikarkmμviFIrbs;GñkenH

e)aHBum<ecjlT§plepSg²eTAeGRkg;. enAkñgú dMNak;kalenHvaGacmankMhuseBldMeNIkar (run-time
errors) dUcCaEckedaysUnüb¤vaGacCaCak;EsþgEdlkmμviFI)anbegáItkare)aHecjminRtImRtUv.
RbsinebIdUcenH GñkRtUvEtRtLb;eTAEkERbkmμviFIedImrbs;Gñknig compile vasaCafμI ehIydMeNIrkarva

mþgeTot.
-7-
vCBk
1.5KMrUkarbkRsay C
eyIgnwgsegçblkçN³KnøwHEdlsMxan;rbs;KMrU compile Pasa C
enATIenH.
rUb 1-1 KMrUkar compile Pasa C
9 The Preprocessor
enAkñúgEpñkenHeyIgcab;epþImedayKeRmagRbtibtþikarRKwHGñkcMa)ac;RtUvEtdMeNIrkaredIm,IeTAdl;kar
compile eyIgnwgsikSaEpñkenHénRbtibtþikar compile kñúglkçN³lMGitCagenHenAelIkeRkay.EteTaH
Cay:agNak¾edayeyIgRtUvkarcMeNaHdwgRKwHmYycMnYnsMrab;;kmμviFI C mYycMnYn.
Preprocessor RBmTTYlyk source code Cakare)aHcUlehIyCakarTTYlxusRtUvsMrab;;
bM)at;karBnül;
bkERb preprocessor directives Biesscg¥úlbgðajeday #
]TahrN_
#include – rab;bBa©ÚlKMniténeQμaH file. File TMagenaHEtgEtRtUv)anehAfa header files.
e.g
o #include <math.h> -- sþg;da library KNitviTüa file

o #include <stdio.h> -- sþg;da library I/O file
-8-
vCBk
#define – kMnt;Gtßn½yeQμaHnimitþsBaØab¤tMélefr. karykmkCMnYl Macro.
o #define MAX_ARRAY_SIZE 100
9 C Compiler
C compiler bkERbr source eTACa assembly code. Source code RtUv)anTTYlBI preprocessor.
9 The Assembler
Assembler begáIt object code. enAelIRbB½n§ window GñkGaceXIj file eday file_name.OBJ
bc©y½ (suffix) (file_name.o enAelIRbB½n§ UNIX ) edIMm,Ibgðaj file object code.
9 The Link Editor
RbsinebI source file mYysMGagGnuKmn_ library GnuKmn_EdlbegáItkñúg source file epSg² link
editor erobcMGnuKmn_TaMgenH (CamYy main()) edIm,IbegáIt fileRbtibtþi. k¾dUcCadMeNaHRsayenATI
enHsMGagelIGefrxageRkA (External Variable). nwgBisþarCagenHenAelIkeRkay.

9 Using Libraries
C BitCaPasad¾tUcéRkELg. GnuKmn_CaeRcInénPasaepSg²minRtUv)anrYmbBa©ÚlkñúgPasa C eT. e.g.

minman I/O Edl)anksagTukeT (built in I/O) dMeNaHRsay string b¤GnuKmn_KNitviTüa.
eRkaymketIPasa CeRbIGVI ?
C pþl;eGaynUvGnuKmn_tamry³sMnMuGnuKmn_ library (funtion libraries) y:ageRcIn.
CaliT§iplkarGnuvtþPasa C CaeRcInrYmmansþg;da library rbs;GnuKmn_sMrab;;PaBgayRsYlCaeRcIn
( I/O etc.). sMrab;;eKalbMNgGnuvtþCaeRcInTaMgenHGacRtUv)ancat;TukCaEpñkcab;epþImrbs;Pasa C.
b:uEnþ vaGacERbRbYlBIm:asIunmYyeTAma:sIunmYyeTot. (cf Borland C sMrab;; PC eTA UNIX C).

GñksresrkmμviFIk¾GacGPivDÆnGnuKmn_ library rbs;Kat;b¤nagedaypÞal;ehIyk¾GacbBa©ÚlbMNg
BiessRkum library TIbI (e.g. NAG, PHIGS).
lMhat;
Exercise 1-1
bBa©Úl compile nig runkmμviFixageRkam :

-9-
vCBk
main()
{ int i;
printf("\t Number \t\t Square of Number\n\n");
for (i=0; i<=25;++i)

printf("\t %d \t\t\t %d \n",i,i*i);
}
Exercise 1-2
kmμviFIxageRkameRbI library KNitviTüa. bBa©Úl compile nig run vay:agRtwmRtUv.

#include <math.h>
main()
{ int i;
printf("\t Number \t\t Square Root of Number\n\n");
for (i=0; i<=360; ++i)

printf("\t %d \t\t\t %d \n",i, sqrt((double) i));
WWWW±XXXX
-10-
vCBk
CMBYkTI 2
RbePT (Types), RbmaNviFI (Operations) nigkenSam (Expressions)
-11-
vCBk
GBaaØtnigtMélefrKWCaRKwH data objects RtUv)anerobcMkúñgkmμviFI. karRbkasbBa¢I (list)GBaaØtRtUv)an

eRbIehIysPaBRbePTGIVeKmanehIyRbEhlGIVEdlCatMélcab;epþImrbs;eK. RbmaNviFIkMnt;GIVEdlRtUv
)aneFIVeTAeK. Expressions rYmbBa©ÚlGBaaØtnigtMélefredIm,IbegáIttMélfμI. RbePTrbs; object
mYykMnt;sMnuMtMél vaGacmannigRbtibtþikarGIVGacRtUv)aneFIVelIva. bøúkEdlksagTMagenHKWCaRbFanbT
rbs;emeronenH.
sþg;da ANSI )anbegáItkarpøas;bþÚrtUc²CaeRcInnigbUkbEnßmelIRbePTmUldæannig expression. \LÚv
manTRmg;sBaØa (signed) nigGt;sBaØa (unsigned) RKb;RbePTcMnYnKt; integer nigkarkt;sMKal;sMrab;;
tMélefrGt;sBaØanigtMélefrGkSr hexadecimal. RbmaNviFIcMnYnek,ós (Floating-point)
GacRtUv)aneFIVkñúgPaBc,as;las;EtmYy (single precision) vak¾manRbePT long double sMrab;;
extended precision. tMélefr String GacRtUv)anP¢ab;enAeBl compile.
karrab;)ankøayCaEpñkrbs;Pasa kareFIVeGaymanTRmg;lkçN³ry³eBlEvg. Object GacRtUv)an
RbkasCa const EdlkarBarBYkvaBIkarpøas;bþÚr. c,ab;sMrab;;karbgçitbgçMedaysV½yRbvtþikñúgcMeNam
RbePTKNitviTüaEdlRtUv)anbegáItedIm,IedaHRsaysMnMuénRbePTCaeRcIn.
2.1 eQμaHGBaaØt
mankarkMnt;mYycMnYnelIeQμaHrbs;GBaaØtnignimitþsBaØatMélefr. eQμaHKWRtUv)anbegáIteLIgedayGkSr
nigelx tYGkSrdMbUgRtUvEtCaGkSr. Underscore “_” rab;faCaGkSr vaeBlxøHmanRbeyaCn_sMrab;;kar
eFIVeGaykarGaneQμaHGBaaØtEvgkan;EtRbesIreLIg. kuMcab;epþImeQμaHGBaaØteday underscore,
EteTaHCay:agNak¾edayedaysar library Cajwkjab;manTMlab;eRbIeQμaHdUcenH. GkSrFMnigGkSrtUc
KWEckdac;BIKña dUcenH x nig X KWCaeQμaHBIrxusBIKña. karGnuvtþ¾ C CaTUeTAKWedIm,IeRbIGkSrtUcsMrab;;eQμaH
GBaaØtnigGkSrFMTaMgGs;sMrab;;nimitþsBaØatMélefr. y:agtic 31 tYGkSrdMbUgrbs;eQμaHCaGnþrCatiKW
sMxan;. Keyword dUcCa if, else, int, float, .l. KWRtUv)anbMrugTuk : GñkminGaceRbIR)as;BYkvaCaeQμaH
GBaaØteT. eQμaHGBaaØtRtUvEtCaGkSrtUc. vaGacyl;)anc,as;edayeRCIsykeQμaHGBaaØtEdlman
TMnak;TMngeTAnwgeKalbMNgrbs;GBaaØtehIyEdlmindUcnwgkarcab;ykmkRcbl;bBa©ÚledayKμann½y.
2.2 RbePTTinñn½ynigTMhM
manRbePTTinñn½ymUldæanRKwHbnþicnþÜcenAkñúgPasa C:
char Ca byte EtmYyGacpÞúk)anmYytYGkSrenAkñúgkarkMnt;kEnøgtYGkSr
-12-
vCBk
int CacMnYnKt; integer CaTUeTAbgðajTMhMFmμtaéncMnYnKt;FmμCatienAelIm:asIunpÞal; (host machine)
float single-precision cMnYnek,ós
double double-precision cMnYnek,ósTMhMeTVdg. bEnßmelIenHmancMnYnEdlmansiT§iGacRtUv)an
Gnuvtþn_CaRbePTmUldæanRKwHTaMgenH . Short nig long GnuvtþCacMnYnKt;FmμCati (integers) :
C eRbIR)as;RTg;RTaye)aHecjedIm,Ie)aHBum<GBaaØt. GnuKmn_ printf mantYGkSrkMnt;RTg;RTay

Biess (%) – tYGkSrxageRkamenHkMnt;Gtßn½yRTg;RTayCak;lak;sMrab;;GBaaØt :
%c -- characters
%d -- integers
%f -- floats
e.g. printf(“%c %d %f”,ch,i,x);
kmμviFIbnÞab;RbkasGBaaØtnigkMnt;tMélefreTAeGayGBaaØtnige)aHBum<tMélrbs;GBaaØtTaMgenaH :
#include <stdio.h>
#include <conio.h>
void main()
{
int a;
float pt;
char ch;
a=3;
pt=10.5;
ch='A';
printf("integer number=%d\n", a);
printf("real number =%f\n", pt);
printf("character=%c\n", ch);
getch();
}
cMnaM: RTg;RTayXøabiTenAkñúg “....” GBaaØtenABIeRkaybnÞab;. eFIVeGayR)akdfalMdab;énkarkMnt;RTg;

RTaynigRbePTTinñn½yGBaaØtRtUvKUrKña.
-13-
vCBk
scanf() CaGnuKmn_sMrab;;kare)aHcUltMéleTArcnasm<½n§Tinñn½y : TRmg;rbs;vaKWRsedogKñaeTAnwg
printf:
i.e. scanf(``%c %d %f'',&ch,&i,&x);
enAkúñgniymn½yedImrbs; C scanf nwgRtUv)ansresrdUcenH :

#include <stdio.h>
void main()
{
char ch;
int num;
float f;
printf("Enter a character:"); scanf("%c", &ch);
printf("Enter an intger:");scanf("%d", &num);
printf("Enter a floating point number:"); scanf("%f", &f);
printf("%c\n", ch);
printf("%d\n", num);
printf("%f\n", f);
}
cMnaM : & enAxagmuxGBaaØt. sUmTTYlyksBaØaenHsMrab;;\LÚvenHehIycg;cMaedIm,IbBa©Úlva.

vaKWedIm,IeRbICa mYy pointer EdleyIgnwgCYbelIkeRkay.
2.3 PaBminERbRbYl (Constants)
cMnYnKt;FmμCati efrdUcCa 1234 Ca int. long tMélRtUv)ansresredaybBa©b;CamYyGkSr l
(ell) b¤ L dUcCa 123456789L tMélcMnYnKt;FmμCatiFMeBkedIm,IeFIVeGayeTACa int
nwgRtUv)anykCa long. tMélGt;sBaØaKWRtUv)ansresrbBa©b;eday u b¤ U nigbc©½y (suffix) ul b¤
UL bgðajfaCa unsigned long.
tMélcMnYnek,óspÞúkcMnucTsPaK (123.4) b¤niTsSnþ (1e-2) b¤TaMgBIr RbePTrbs;BYkvaKW double

Tal;EtRtUv)andak;bc©½y. bc©½y f b¤ F bgðajtMél float l b¤ L bgðajtMél long
double.
tMélrbs;cMnYnKt;FmμCati (integer) GacRtUv)ankMnt;kñúgeKalR)aMbI (octal) b¤eKaldb;R)aMmYy

(hexadecimal) CMnYseGayeKaldb; (decimal). karnaMmuxeday 0 (sUnü)
elItMélcMnYnKt;FmμCatiman n½yfaCaeKal8 (octal) karnaMmuxeday 0x b¤ 0X mann½yfaCaeKal16
(hexadecimal). ]TahrN_ eKal10 (decimal) 31 GacRtUv)ansresrCa 037 kñúgeKal8 (octal)
nig 0x1f b¤ 0x1F kñúgeKal16. tMéleKal8 (octal) nigeKal16
-14-
vCBk
(hexadecimal) k¾GacRtUv)andak;BIeRkayeday L edIm,IbegáItBYkvaCa long nig U edIm,IbegáItBYkva
unsigned : 0XFUL CatMél unsigned long CamYytMél 15 kñúgeKaldb; .
character constant KWCacMnYnKt;FmμCati RtUv)ansresrCamYytYGkSrCamYy single quotes
dUcCa 'x'. tMélrbs;tMélefrtYGkSrKWCatMélelxénGkSrkñúgsMnuMtYGkSrrbs;m:asIun. ]TahrN_kñúg

sMnuMtYGkSr ASCII tMélefrtYGkSr '0' mantMélesμI 48 EdlminmanTMnak;TMngeTAnigtMélelx 0.
RbsinebIvaRtUv)ansresr '0' CMnYseGaytMélelxdUc 48 EdlGaRs½yelIsMnuMtYGkSr kmμviFIenHKW
ÉkraCüBItMélCak;lak;niggayRsYlGan. tMélefr character cUlrYmkñúgRbmaNviFICaelxdUcEtcMnYn
Kt;FmμCatid¾éTepSgeTot. dUcenHBYkvaesÞIrEtCanicC© akalRtUv)aneRbIR)as;kñúgkareRbobeFobCamYytY
GkSrepSgeTot.
tYGkSrBitR)akdGacRtUv)anbgðajCatMéltYGkSrehIynig string eday escape sequences dUcCa \n
(cuHbnÞat;fμI) . sequences TaMgenHdUcCatYGkSrBIrb:uEnþtMNageGayEtmYyb:ueNÑaHbEnßmelIsenHTMhM
ERbRbYlén byte-sized KMrU bit GacRtUv)ankMnt;eday '\ooo' EdlkEnøg ooo KWmYydl;bICa

elxkñúgRbB½n§eKal8 (0...7) b¤eday '\xhh' EdlkEnøg hh KWmYyb¤eRcInCaelxeKaldb;R)aMmYy
(0...9, a...f, A...F).
sMnuMTaMgmUlrbs; escape sequences KW

\a alert (bell) character
\b backspace
\f formfeed
\n newline
\r carriage return
\t horizontal tab
\v vertical tab
\\ backslash
\? question mark
\' single quote
\" double quote
\ooo octal number
\xhh hexadecimal number
tMélefrtYGkSr (character constant) '\0' bgðajtYGkSrCamYynigtMélsUnü tYGkSr null . ‘\0'

KWCanic©CakalRtUv)ansresrCMnYseday 0 edIm,IbBa©ak;tYGkSrFmμtarbs; expression mYycMnYnb:uEnþtMél
elxKWRtwmEtsUnü.
tMélefr string (string constant)b¤ string literal KWCalMdab;énsUnüb¤GkSreRcInB½T§CMuvijeday double
quotes dUcCa
-15-
vCBk
"I am a string"
b¤
"" /* the empty string */
Quotes minEmnCaEpñkrbs; string eTb:uEnþbMerIedIm,IkMNt;RBMEdnvaEtb:ueNÑaH. dUcKñanig escape
sequences EdleRbIkñúgefrGkSrGnuvtþkñúg strings. \" bgðajtYGkSr double-quote. String
constants GacRtUv )antP¢ab;KñaenAeBl compile :
"hello, " "world" vaesμIeTAnig

"hello, world"
vamansar³sMxan;Nas;sMrab;;pþac; string Evgqøgkat;bnÞat;edImmYycMnYn. tambec©keTs string
constant KWCa array éntYGkSr. karbgðajTRmg;xagkñúgrbs; string mantYGkSr null '\0'
enAxagcugdUcenHrUbrag rkSaTukRtUvkarmYyeRcInCagcMnYnrbs;tYGkSrEdlRtUv)ansresrenAcenøaH
eFμjkNþúrBIr (quotes).
2.4 karRbkas (Declarations)
RKb;GBaaØtRtUvEt)anRbkasmunnwgeRbIR)as; dUcenHkarRbkasCak;lak;GacRtUveFIVedaymincat;Ecg
eGayc,as;edayeBjcitþ. karRbkasRbePTCak;lak;mYynigpÞúkbBa¢Irbs;GBaaØtmYyb¤eRcInrbs;RbePT
énRbePTenaHdUcCa
int lower, upper, step;
char c;
GBaaØtGacRtUv)anEbgEckkñúgcMeNamkarRbkaskñúgrebobNamYy bBa¢IxagelIGacRtUv)ansresrdUc
xageRkam
int lower;
int upper;
int step;
char c;
TRmg;GkSrykTITMenreRcInb:uEnþvagayRsYlsMrab;;karbEnßmkarBnül;eTAkarRbkasnimYy²sMrab;;lMdab;
EkERbbnþbnÞab;Kña.
GBaaØteRcInk¾GacRtUv)ankMnt;tMélefrkñúgkarRbkasrbs;va. RbsinebIeQμaHKWRtUv)andak;BIeRkayeday
sBaØaesμInig expression mYy eKfa expression enaHCaGñkkMnt;tMélcab;epþImeGayGBaaØtenaH
dUckñúg]TahrN_xageRkam :
char esc = '\\';
int i = 0;
float eps = 1.0e-5;
This is the same as:

-16-
vCBk
char esc;
int i;
float eps;
esc = '\\';
i = 0;
eps = 1.0e-5;
RbsinebIGBaaØtenAkñúgsMnYrminsV½yRbvtþi karkMnt;tMélcab;epþImKWRtUv)aneFIVEtmþgb:ueNÑaH
CaKMnitmunkmμviFIcab;epþImRbtibtþinigGñkkMnt;tMélcab;epþImRtUvEtCa expression efr (constant
expression).
C k¾GnuBaØatkareGayXøaepÞrtMéleRcInedayeRbIR)as; “=” ]TahrN_ :

a=b=c=d=3;
EdldUcKñaeTAnigxagelI b:uEnþmanplläeRcInCag :
a=3;
b=3;
c=3;
d=3;
karepÞrtMélenHGaceFIVeTA)anRbsinebIRKb;RbePTGBaaØtenAkñúgXøamanRbePTdUcKañ.
2.5 RbmaNviFInBVnþsaRsþ (Arithmetic Operations)
k¾dUcCasþg;dakarIKNitviTüa (+, - ,*, / , %) CYbenAkñúgesÞIrEtRKb;kmμviFI C pþl;eGaykarImYy
cMnYn. Expression x % y begáItsMnl;enAeBl x RtUv)anEcknig y ehIydUcenHsUnüenAeBl y
BitCaEcknig x. karI “%” minGacRtUv)anGnuvtþeTAelI float b¤ double. TisedAénkarkat;eGayxøI
sMrab;; “/” nigsBaØaénlT§plsMrab;; “%” KWGaRs½yelIm:asIunsMrab;; operand GviC¢mank¾
dUcCaskmμPaBcab; epþIm overflow b¤ underflow. elxEck “/” KWsMrab;;TMagkarEckcMnYnKt;FmμCati
integer nig float .dUcenHcUrRbugRby½tñ. cMelIyelIRbmaNviFI : x = 3 / 2 KWesIμ 1 sUm,IEt x
RtUv)anRbkasCa float. karEckcMnYnKt;FmμCati integer kat;eGayxøIEpñkRbPaKmYycMnYn.

c,ab; : RbsinebITaMg argument rbs; “/” KWCacMnYnKt;FmμCati integer bnÞab;mkeFIVkarEckcMnYnKt;. dUc
enHeGayR)akdfaGñkeFIVva. cMelIyRtwmRtUv (sMrab;;karEckelx) enAxagelIKW x = 3.0 / 2 b¤ x= 3 / 2.0
b¤ (RbesIrCag) x = 3.0 / 2.0. vak¾manviFIkat;gayRsYledIm,IbgðajkarKNnaenAkñúg C.
karI binary + nig – manGaTiPaBdUcKña EdlticCagGaTiPaBrbs; *, / nig % EdlkøayCaticCag
unary + nig -. karIKNitviTüaKNnaBIeqVgeTAsþaM.
-17-
vCBk
2.6 RbmaNviFIeRbobeFob
edIm,Isakl,gsMrab;;smPaBKW “= =”
Baküdas;etOn : cUrRbugRby½tñkareRbIR)as; “=” CMnYseGay “= =” dUcCakarsresredayKμanRbugTuk
if ( i = j ) .....
enHKWBitR)akdCaXøa C RtwmRtUv (karniyaytam syntactically) EdlcmøgtMélkñúg "j" eTA "i"

nigRbKl;eGaytMélenH EdlbnÞab;mkRtUv)anbkERbCaBit (TRUE) RbsinebI j minesμIsUnü.
enHRtUv)anehAfakarepÞredaytMél (assignment by value) – lkçN³KnwøHrbs; C.
minesμIKW : “!=”
karIepSgeTot < (ticCag) , > (FMCag) <= (ticCagb¤esμI) >= (FMCagb¤esμI) KWeRbIdUcFmμta.
Gñksresr X = = Y edIm,Isakl,gfaetItMélrbs; X esμItMélrbs; Y. lT§plKWCacMnYnKt;FmμCati
EdltMélrbs;vaKWesμI 1 RbsinebIkarsakl,g)aneCaKC½y ebImindUcenHeTtMélKWesμIsUnü. lT§pl
sMrab;;karIeRbobeFobepSgKWk¾)anedayviFIxagelI. Operand nimYy²KWRtUv)anpøas;bþÚredIm,IRbePTsak
l,gFmμtasMrab;;kareRbobeFob.
2.7 RbmaNviFItkáviTüa (Logical Operations)
karItkáviC¢aKWCanic©CakalEtgEtRtUv)aneRbIR)as;CamYyXøalkç½x½NÐEdleyIgnwgCYbenAkñúgemeronbnÞab;.
karItkáviC¢aRKwHbIKW : && sMrab;;tkáviC¢a AND, || sMrab;;tkáviC¢a OR nig ! sMrab;;tkáviC¢a NOT.
Gñksresr X && Y edIm,Isakl,gfaetITaMg operand X nig Y KWminsUnü. RbsinebI X
esμIsUnüenaHmanEt X mYyKt;RtUv)anvaytMélnigtMélrbs;kenSam (expression) KWesμIsUnü
ebImindUcenHeT Y RtUv)anvaytMélnigtMélén expression KWesμI 1 RbsinebI Y
minesμIsUnüb¤esμIsUnüRbsinebI Y esμIsUnü.
Gñksresr X || Y edIm,Isakl,gfaetITMag operand X b¤k¾ Y minesμIsUnü.RbsinebI X mantMélmin
esμIsUnüenaHmanEt X mYyb:ueNÑaHRtUv)anvaytMélnigtMélrbs; expression KWesμI 1 ebImindUcenHeT Y
RtUv)anvaytMélnigtMélrbs; expression KWesμI 1 RbsinebI Y minesμIsUnüb¤sUnüRbsinebI Y KWesμIsUnü.
-18-
vCBk
Gñksresr !X edIm,Isakl,gfaetI X KWesμIsUnü. RbsinebI X KWesμisUnütMélrbs; expression KWesμI 1
ebImindUcenHeTtMélKWesμIsUnü.
2.8 RbmaNviFI Bitwise (Bitwise Operations)
C pþl;eGaykarIR)aMmYysMrab;;karcat;Ecg bit TaMgenHGacRtwmEtGnuvtþelI operand cMnYnKt; EdlvaCa
char, short, int, nig long eTaHCa signed b¤ unsigned.

& bitwise AND
| bitwise inclusive OR
^ bitwise exclusive OR
<< left shift
>> right shift
~ one's complement (unary)
Gñksresr X & Y edIm,IbegáItTRmg; bitwise AND éntMélrbs; X nig Y. bit

nimYyénlT§plKWRtUv)an kMnt;RbsinebI bit RtUvKañTaMgkñúg X nig Y RtUv)ankMnt;.
Gñksresr X | Y edIm,IbegáItTRmg; bitwise Edlman OR éntMélrbs; X nig Y. bit
nimYy²énlT§pl KWRtUv)ankMnt;RbsinebI bit RtUvKñarbs; X k¾)anb¤ Y k¾)ankMnt;.
bitwise exclusive OR karI ^ kMnt;mYykñúg bit pÞúyKñanimYy²EdlkEnøg operand rbs;vaman bit
xusKñanig sUnüEdlkEnøgBYkvaKWdUcKña.
karIbgçit (shift) << nig >> bgçit bit eTAenAxageqVgnigeTAxagsþaMedaycMnYnTItMag bit
RtUv)anpþl;eday right operand EdlRtUvEtminEmnCacMnYnGviC¢man. dUcenH x << 2 bgçit (shift)
tMélrbs; x edaykEnøgBIrbMeBjkEnøgEdleFIVeGayTMenreday bit sUnü enHKWesμIeTAnigkarKuNeday
4. karbgçit (shift) eTAxagsþaMcMnYn unsigned EtgEteFIVkarbMeBj bit edaysUnü. kar shift
eTAxagsþaMcMnYn signed nwgRtUvbMeBjedaysBaØa bit (bit sign) (“ shift énelxKNit ”)

elIviFIedaHRsaymYycMnYnnig 0-bits (“shift tkáviC¢a logical shift”) epSg²eTot.
karI unary ~ pþl;eGay one's complement éncMnYnKt;FmμCati integer enHKWvapøas;bþÚr 1-bit
nimYy²eTACa 0-bit ehIynigpÞúyeTAvij.

Table: Bitwise operators
& AND
OR
XOR
-19-
vCBk
One's Compliment
<< Left shift

>> Right Shift
kMuRcLM & nig && : & KWCa bitwise AND && logical AND . RsedogKñaenHEdlsMrab;; | nig ||.
KWCakarI unary (unary operator) vaCakarIEtmYyKt;elI argument mYyBIxagsþaMkarI.
karIbgçit (shift) cat;Ecg shift RtwmRtUvedaykarIenAxagsþaMeTAkarIenAxageqVg. karIenAxagsþaM
RtUvEtCacMnYn viC¢man. bit EdlRtUv)anvaytMélKWRtUvbMeBjedaysUnü (i.e. vamin)anbiTCMuvijeT).
]TahrN_ : x << 2 rMkil (shift) bits enAkñúg x eday 2 kEnøgeTAxageqVg.
dUecñH :
if x = 00000010 (binary) or 2 (decimal)
then:
x>>2=>00000000 or 0 (decimal)
k¾dUcCa: RbsinebI x = 00000010 (binary) or 2 (decimal)

x<<2=>00001000 or 8 (decimal)
ehtudUcenHehIy shift left KWesμIeTAnwgKuNeday 2.

RsedogKñaenH shift right KWesμIeTAnigkarEckeday 2
cMNMa : Shift KWelOinCagkarKuNelxBitR)akd (*) b¤karEck (/) eday 2. dUcenHRbsinebIGñkcg;eFIV
elxKuNb¤Ecknwg 2 )anelOneRbI shift.
eKalbMNgkmμviFI CeRcInBnül;GnuKmn_enH :
for loop not used for simple counting operation
x >>=1 => x = x >> 1
for loop will repeatedly shift right x until x becomes 0
use expression evaluation of x & 01 to control if
-20-
vCBk
x & 01 masks of 1st bit of x if this is 1 then count++
2.9RbmaNviFIkMenIn
C pþl;eGaynUvkarI2minFmμtasMrab;;karbEnßmnigbnßyGBaaØt.karIbEnßm ++ bEnßm 1 eTA operand
rbs; vaxN³EdlkarIbnßy -- dk 1. eyIg)aneRbICajwkjab;nUv ++ edIm,IbegáInGBaaØtþi dUcCakúñg

if (c == '\n')
++nl;
TidæPaBminRtwmRtUvKWfa ++ nig –- GacRtUv)aneRbIR)as;karIenAxagmuxk¾)an (muneBlGBaaØtdUckñuúg

++n) b¤k¾karIenAxageRkay (xageRkayGBaaØt : n++). kñúgkrNITaMgBIrenHRbsiT§iPaBKWedIm,IkMenIn n.
b:uEnþ expression ++n kMenIn n muntMélrbs;vaRtUv)aneRbI xN³Edl n++ kMenIn n

eRkaytMélrbs;vaRtUv )aneRbI. enHmann½yfaenAkñúgbribTEdlkEnøgtMélRtUv)ancab;epþImminRtwm
EtmanRbsiT§iPaB++n nig n++ KWxusKña. RbsinebI n esμI 5 enaH x = n++ kMnt; x esμInig 5
b:uEnþ x = ++n kMnt; x eTAesμInig 6. kñúgkrNITaMgBIr n køauyCaesμI 6.
karIbEnßmnigbnßyGacRtUv)anGnuvtþelIGBaaØt expression dUcCa (i+j)++ KWRtwmRtUv.
2.10RbmaNviFIepÞrnigkenSam
Expression dUcCa
i = i + 2
kñúgGBaaØtEdlenAEpñkxageqVgRtUv)aneFIVmþgeToty:agrh½senAEpñkxagsþaM GacRtUv)ansresrkñúgTRmg;
bRgYm.
i += 2
karI += KWRtUv)anehAkarIepÞr.
karI binary CaeRcIn (dUcCakarI + EdlmanenAxageqVgnigxagsþaM operand) mankarIepÞrtMélEdlRtUvKañ
op= EdlkEnøg op KWmYyén
+ - * / % << >> & ^ |
vaKWsamBaØaNas;Edlman expression dUcCa : i = i + 3 or x = x*(y + 2)

TaMgGs;enHGacRtUv)ansresrkñúgPasa C (CaTUeTA) kñúgTRmg;kat;dUcenH :
expr1 op= expr2
EdlvaesμIKñaeTAnwg (b:uEnþmanRbsiT§iPaBCag):
-21-
vCBk
expr1 = (expr1) op (expr2)
dUcenHeyIgGacsresr i=i+3 Ca i += 3
nig x = x*(y + 2) as x *= y + 2.
cMNaM : Edl x *= y + 2 mann½yfa x = x*(y + 2) ehIy cMNaM x = x*y + 2.

2.11 lMdab;énGTiPaB
vamansar³sMxan;edayRbugRby½tñGtßn½yrbs; expression dUcCa a + b * c . eyIgGaccg;RbsiTi§
)ankenSam
(a + b) * c
k¾kenSamb¤
a + (b * c)
RKb;karImanGaTiPaBehIykarImanGaTiPaBx<s;KWRtUv)anvaytMélmunkarImanGTiPaBTab.karImanGaTiPa
B esμIKñaKWRtUv)anvaytMélBIeqVgeTAsþaM dUcenH
a - b - c
RtUv)anvaytMélCa
( a - b ) - c
dUcEdlGñkcg;)an
BIGaTiPaBx<s;eTAGaTiPaBTablMdab;sMrab;;RKb;karI C (eyIgmin)anCYbBYkvaTaMgGs;enAeLIyeT) KW :
() [] -> . (left ->right)
! ~ ++ -- + - * (type) sizeof (right -> left)
* / % (left ->right)
+ - (left ->right)
<< >> (left ->right)
< <= > >= (left ->right)
== != (left ->right)
& (left ->right)
^ (left ->right)
| (left ->right)
&& (left ->right)
|| (left ->right)
?: (right -> left)
-22-
vCBk
= += -= *= /= %= &= ^= |= <<= >>= (right -> left)
, (left ->right)
dUcenH
a < 10 && 2 * b < c
RtUv)anbkERbCa
( a < 10 ) && ( ( 2 * b ) < c )
nig
a =
b =
spokes / spokes_per_wheel
+ spares;
Ca
a =
( b =
( spokes / spokes_per_wheel )
+ spares
);
lMhat;
sresrkmμviFI C edIm,IbegáItRbtibtþikarxageRkam.
Exercise 2-1
bBa©Úl2cMnYnehIyeFIVkargarbUktMélrbs;va KNnamFümPaK nigplbUkrbs;kaeréncMnYn.

Exercise 2-2
karbBa©ÚlnigbeBa©jeQμaHrbs;Gñk Gas½ydæannigGayueTAnwgrcnasm<½n§smrmü.
Exercise 2-3
karsresrkmμviFIEdledaHRsaytMélFMbMputnigtUcbMputBIsMnuM 10 cMnYnEdl)anbBa©Úl.
Exercise 2-4
-23-
vCBk
sresrkmμviFIedIm,IGan "float" bgðajcMnYnénGgSa Celsius nige)aHBum<Ca "float" nUvsItuNðPaBesμIKña
enAkñúgGgSa Fahrenheit. e)aHecjlT§plkñúgTRmg;dUcCa 100.0 GgSa Celsius pøas;bþÚreTACa 212.0
GgSa Fahrenheit.
Exercise 2-5
sresrkmμviFIedIm,Ie)aHecjbnÞat;mYycMnYn (dUcCaeQμaHnigGas½ydæanrbs;Gñk). GñkGaceRbIXøa printf

mYycMnYn tYGkSr newlineenAkñúgvab¤ printf mYYyCamYy newline mYycMnYnkñúg string.
Exercise 2-6
sresrkmμviFIedIm,IGancMnYnKt;FmμCatiya:gticesμI 3 ehIye)aHecjRKb;karpøas;bþÚrEdlGacénbIcMnYnKt;
FmμCativiC¢manticCagb¤esμItMélenH.
Exercise 2-7
sresrkmμviFIedIm,IGancMnYnrgVas;énRbEvg ( float) ehIye)aHecjRkLaépÞrbs;rgVg;énkMaenaH. snμt;fa

tMélrbs; pi KW 3.14159 (karRbkasRtwmRtUvnwgRtUv)anpþl;eGayGñknUv ceilidh – eRCIserIskarkMnt;).
kare)aHecjrbs;GñknwgykTRmg; : RkLaépÞrbs;rgVg; (circle) énkaM (radiu) ... ÉktaKW .... Ékta.
RbsinebIGñkcg;køayCaGñkqøatehIynig)anemIlmunenAkñúgkMnt;cMnaMe)aHecjsarkMhus : tMélGviC¢man
minGunBaØat.RbsinebIbBa©ÚltMélGviC¢man.
Exercise 2-8
pþl;eGayCakarbBa©ÚlcMnYnek,ós (real) cMnYnénsg;TIEm:Rt ¬s>m¦ e)aHecjcMnYnesμICa feet (integer)

nig inch (floating, 1 decimal) CamYynig inch )anpþl;eGaynUvPaBRtwmRtUvénTItaMgelxTsPaKmYy.
snμt; 2.54 s>mkñúg1 inchehIy 12 inches kñúg1 foot.
RbsinebIbBa©ÚltMélesμInig 333.3 TRmg;e)aHecjnwgeTACa :
333.3 s>m esμIrnig 10 feet 11.2 inches.
Exercise 2-9
pþl;eGayCakarbBa©ÚlcMnYnKt;FmμCatiéncMnYnvinaTI. e)aHBum<ecjCaeBlevlaem:agnaTInigvinaTI. kar

ENnaMTRmg;e)aHecjKWGVIEdldUc 7322 vinaTIesμInig 2 em:ag 2 naTI 2 vinaTI.
Exercise 2-10
-24-
vCBk
cUrsresrkmμviFIedIm,IGanBIrcMnYnKt;FmμCatiedayCak;lak;dUcxageRkam.
tMélcMnYnKt;TImYybgðajem:agrbs;éf¶kñúgnaLika 24 em:agdUcenH 1245 bgðajxVH !% naTIem:ag !
éf¶Rtg; ]TahrN_ .
cMnYnKt;TI2bgðajry³evlaem:agkñúgviFIRsedogKñaenH dUcenH 345 bgðaj #em:agnig 45 naTI.

ry³eBlenHKWRtUv)anbUkbEnßmeTAem:agTImYynige)aHecjliT§iplkñúgkMnt;cMnaMdUcKñakñúgkrNIenH 1630
EdlCaeBlevlaesμInig 3 em:agnig 45 naTIeRkaymk 12.45.

CaTUeTAkare)aHecjGaccab;epþImKW 1415 . ry³evlaKå 50. em:agbBa©b;KW 1505 . vamanBinÞúbEnßm
tictYcsMrab;;sMKal;.
eBlcab;epþImKW 2300. ry³evsaKW 200. eBlbBa©b;KW 100.
WWWW±XXXX
-25-
vCBk
CMBUkTI 3 l½kçx½NÐ
Conditionals
-26-
vCBk
emeronenHedaHRsayCamYyviFIepSg²Edl C GacRtYtBinitülMhUréntkáviC¢aenAkñúgkmμviFI. karpøas;bþÚr
EbøkBIKñabnþicbnþÜcBYkvaKWRsedogKñaeTAnigPasad¾éTeTot.
dUceyIg)aneXIjkarItkáviC¢axageRkammanenAkñúg C:
= =, !=, ||, &&.
karImYyepSgeTotEdlrYmKña - vamanRtWmEtmYy argument b:ueNÑaH - not !.

karITaMgenHKWRtUv)aneRbIkñúgkarCYbKñaCamYyXøaxageRkam.
3.1 Xøanigbøúk
Expression dUcCa x = 0 b¤ i++ b¤ printf(...) køayCaXøaenAeBlenABIeRkayedaycuc
ek,ós (semicolon) dUcxageRkam

x = 0;
i++;
printf(...);
enAkñúg C semicolon CaGñkbBa©b;XøaminEmnCaGñkbMEbkXøadUcvaenAkñúgPasa Pascal eT.

Braces { nig } RtUv)aneRbIedIm,Idak;karRbkasCaRkumnigXøarYmKñaeTAkñúgXøapSM (compound
statement)b¤ bøúk dUcenHBYkvaKWcat;EcgesμIeTAnwgXøaEtmYy. Braces EdlrMuXøarbs;GnuKmn_KWman
]TahrN_Cak;Esþg braces enACMuvijXøaeRcInbnÞab;mk if, else, while, b¤ for

KWmYyepSgeTot.vaminman semicolon enAxageRkayEpñkxagsþaM brace EdlbBa©b;bøúkeT.
3.2 Xøa if
Xøa if-else RtUv)aneRbIedIm,IbgðajkarsMerc. vaküsB½Þ (syntax) rbs;vaKW :

if (expression)
statement1
else
statement2
EdlkEnøg else CaEpñkEdlmank¾)anGt;k¾)an. Expression KWRtUv)anvaytMél RbsinebIvaBit
(RbsinebI expression mantMélminsUnü) statement KWRtUv)anRbtibtþi. RbsinebIvaminBit (expression
1
KWesμIsUnü) nigRbsinebImanEpñk else statement KWRtUv)anRbtibtþiCMnYs. karBnül;enH

2
manenAkñúg]TahrN_xageRkam
#include <stdio.h>
void main()
{
-27-
vCBk
int num1, num2, sub, add;
printf(“Input two numbers");
scanf("%d %d", &num1, &num2);
if(num1>num2)
{
sub=num1 - num2;
printf(“addition = %d\n", sub);
}
else
{
add= num1 + num2;
printf(“subtraction = %d\n", add);
}
}
cab;tMagBI if sakl,gtMélCaelxén expression karsresrkUdTRmg;kat;BitR)akdKWGaceFIV)an.

Cak;EsþgCagenHKWkarsresr
if (expression)
instead of
if (expression != 0)
eBlxøHvaFmμtanigc,as; enAeBlepSgeTotvaGacmanGaf’kM)aMg.eRBaHEpñk else én if-else

KWGacmank¾)anGt;k¾)an vamann½yminc,as;enAeBl else if RtUv)anlubBIlMdab;bnþKñarbs; if.
enHKWedaHRsayedaykarcUlrYmBI else CamYYynig if BImunEdlKμan else. ]TahrN_kñúg
if (n > 0)
if (a > b)
z = a;
else
z = b;
else cUleTAxagkñúg if dUceyIg)anbgðajedaykarkMnt;sMKal;.
RbsinebIvaminCaGIVEdleyIgcg;)an braces RtUvEt)aneRbIedIm,IbgçMeGaymankarcat;EcgRtwmRtUv :
if (n > 0) {
if (a > b)
z = a;
}
else
z = b;
karbegáIt
if (expression)
statement
else if (expression)
statement
statement
statement
-28-
vCBk
else
statement
ekIteLIgCajwkjab;EdlvamantMélbMEbkkarBiPakSa.enaHCalMdab;bnþbnÞab;énXøa if KWCaviFITUeTA
bMputénkarsresrdMeNaHRsaysMerccitþeRcIn. Expressions KWRtUv)anvaytMéltamlMdab; RbsinebI
expression BitXøaP¢ab;CamYyvaRtUv)anRbtibtþiehIyvabBa©b;nUvkarRbtibtþiTaMgmUlenH. Canic©Cakal
kUdsMrab;;XøanimYy²KWXøaEtmYyk¾)anb¤RkuménXøaedayenAkñúg bracesk¾)an. Epñk else

cugeRkaybMputedaHRsay “minRtUvl½kçx½NÐénl½kçx½NÐxagelI ” b¤krNITUeTA (default) EdlKμanl½kçx½NÐ
epSgeTotRtUv)anbMeBjtaml½kçx½NÐ. eBlxøHvaminmanskmμPaBBitR)akdsMrab;; default enAkñúgkrNI
enaHXøaenAxageRkam
else
statement
GacRtUv)anlubb¤vaGacRtUv)aneRbIR)as;sMrab;;karrkemIlkMhusedIm,Icab;l½kçx½NÐEdlminnwksμandl;.
]TahrN_ :-
#include <stdio.h>
void main()
{
int score;
printf(“Input point"); scanf("%d ", &score);
if (score >= 90) printf(“A”);
else if (score >= 80) printf(“B”);
else if (score >= 70) printf(“C”);
else if (score >= 60) printf(“D”);
else printf(“F”);
}
3.3 RbmaNviFI ?
karI ? (ternary condition) KWCaTRmg;manRbsiT§iPaBCagsMrab;;bgðajXøa if Fmμta.
vamanTMrgdUcxageRkam :
expression1 ? expression2: expression3
vamansPaBFmμta :
if expression1 then expression2 else expression3
]TahrN_edIm,IkMnt;tMélFMbMputén a nig b eTAeGay z:

z = (a>b) ? a : b;
-29-
vCBk
EdldUcCa :
if (a>b)
z = a;
else
z=b;
3.4Xøa switch
C switch KWRsedogKñaeTAnigXøa case rbs;Pasa Pascal nigvaGnuBaØatnUvkareRCIserIleRcInénEpñk
rbs;vtßúenAkMritmYyénl½kçx½NÐEdlvaCaviFIRbesIrCagkarsresrXøa if eRcIndg :
switch (expression) {
case item1:
statement1;
break;
case item2:
statement2;
break;
case itemn:
statementn;
break;
default:
statement;
break;
}
krNInimYy²KWRtUv)aneFVICapøak (label) eday 1b¤eRcIntMélcMnYnKt;b¤tMél expression.
RbsinebIkrNImYyCaKUnigtMél expression karRbtibtþicab;epþImenAkrNIenaH. RKb;krNITaMgGs;
expression RtUvEtxusKña. krNIpøak (label) default RtUv)anRbtibtþiRbsinebIminmankrNIepSg
eTotRtUv)anbMeBj. default KWmank¾)anGt;k¾)an RbsinebIvaminmanenATIenaHehIy

RbsinebIminmankrNIKU minmanskmμPaBNamYyRtUv)anRbtibtþi. krNIeRcInnigGnuRbeyaK default
GacCYbRbTHkñúgkarbBa¢amYycMnYn.
enAkñúgkrNInimYy²tMélrbs;vtßú RtUvEtCatMélefr GefrKWminRtUv)anGnuBaØat.
break KWRtUvkarCacMa)ac;RbsinebIGñkcg;bBa©b; switch eRkayBIRbtibtþikarénkareRCIserIsmYy.
BMuenaHeTkrNIbnÞab;nigRtUv)anvaytMél. cMNaM : enHKWmindUceTAnigPasad¾éTepSgeToteT.
eyIgk¾GacmanXøa null edayRKan;EtrYmbBa©Úl a b¤GnuBaØateGayXøa switch Føak;tamkrNInimYy²
edaylubXøaxøH (emIl e.g. xageRkam).
-30-
vCBk
Xøa break bNþaleGaymankarcakecjPøam²BI switch. BIeRBaHkrNIeGayRKan;EtCa label
eRkaymkkUdsMrab;;krNImYyRtUv)aneFIV RbtibtþikarFøak;eTAkrNIbnÞab;luHRtaEtGñkykskmμPaBCak;
lak;edIm,Icakecj. break nig return KWCaviFIsamBaØabMputedIm,Icak;ecjBI switch. Xøa
break k¾GacRtUv)aneRbIR)as;edIm,IbgçMeGaycakecjPøamBI while, for, nig do loops,
dUcEdlnwgelIkykmkBiPakSaelIkeRkay
]TahrN_ :
switch (letter)
{
case À':
case È':
case Ì':
case Ò':
case Ù':
numberofvowels++;
break;
case ` ':
numberofspaces++;
break;
default:
numberofconstants++;
break;
}
enAkñúg]TahrN_xagelIRbsinebItMélrbs;GkSrKW À', È', Ì', Ò' b¤ Ù' enaH

numberofvowels RtUv)anekIneLIg.
RbsinebItMélénGkSrKW ‘’ enaH numberofspaces RtUv)anbEnßm.RbsinebIminmanNamYyénGkSr

TaMgenHBitenaHl½kçx½NÐ default RtUv)anRbtibtþienaHKW numberofconstants RtUv)anbEnßm.
lMhat;
Exercise 3-1
cUrsresrkmμviFIedIm,IGantYGkSr2nige)aHecjtMélrbs;vaenAeBlbkERbCacMnYneKal16 2cMnYn.
TTYlykGkSrFMsMrab;;tMélBI 10 dl; 15.
Exercise 3-2
cUrGantMélcMnYnKt;FmμCati integer. snμt;favaCacMnYnrbs;ExénqñaM e)aHecjeQμaHrbs;ExenaH.

Exercise 3-3
-31-
vCBk
pþl;eGaynUvkarbBa©ÚlbIcMnYnKt;bgðajkalbriecäTCaéf¶ Ex qñaM e)aHecjcMnYnéf¶ Ex nigqñaMsMrab;;
karbriecäTrbs;éf¶xageRkam.
CaFmμtakare)aHcUl : 28 2 1992 karbBa©ÚlCaFmμta : karbriecäTxageRkam 28:02:1992 KW 29:02:1992
Exercise 3-4
cUrsreskmμviFIGantMélcMnYnKt;2. RbsinebITImYyticCagTIBI e)aHecjsarxagelI .RbsinebITIBItic

CagTImYye)aHsarxageRkam RbsinebIcMnYnesμIKña e)aHecjsaresμI RbsinebImankMhusGanTinñn½y
e)aHecjsarmanBakü Error and perform exit( 0 ).
WWWW±XXXX
-32-
vCBk
CMBUkTI 4
CMu nig kareFIVeLIgvij
Looping and Iteration
-33-
vCBk
enAkñúgemeronenHnwgRkeLkemIlviFIedaHRsayrbs; C sMrab;;karRtYBinitü loop nigkareFIVeLIgvij
(iteration). ebImindUcenHeTmYycMnYnénviFIedaHRsayTaMgenHGacemIleTARsedognigtamkarBitnwgRbti
btþienAkñúgsþg;daKMrUesÞIrEtRKb;eBl. cMNaM : manlkçN³minsþg;damYycMnYnKWGacRtUv)aneRbIEdr.

4.1 kenSamBakübgÁab; for
Xøa for rbs; C manTRmg;dUcxageRkam :

for (expression1; expression 2; expression3)
statement;
or {block of statements}
expression1 tMélcab;epþIm (initializes); expression KWbBaÄb;karsakl,g ; expression

2 3
KWBaküEkERb (EdlGaceRcInCagkMenInFmμta);
EpñkdMbUg Cakarcab;epþIm expression RtUv)aneFIVmþg munnwg loop RtwmRtUv)aneFIVGIVmYy. EpñkTI2
1
expression RtUv)ansakl,gb¤l½kçx½NÐEdlRtYtBinitü loop.

2
l½kçx½NÐenHRtUv)anvaytMélRbsinebIvaBitxøÜnrbs; loop RtUv)anRbtibtþi. bnÞab;mkCMhankMenIn

expression RtUv)anRbtibtþiehIyl½kçx½NÐRtUv)anvaytMéleLIgvij. Loop RtUv)anbBa©b;RbsinebI
3
l½kçx½NÐ)ankøayCaminBit.
tamk,ÜnevyükrN_ smasPaBbIrbs; for loop KWCa expression. samBaØaCagenHeTAeTot
expression nig expression KWkMnt;kargarb¤ ehAGnuKmn_nig expression KW expression
1 3 2
TMnak;TMng. NamYyrbs;EpñkTaMgbIGacRtUv)anlub eTaHbIy:agNa semicolon RtUvEtrkSaTuk.

RbsinebI expression b¤ expression RtUv)anlub vaRtUv)anlubecaledaysamBaØaBI
1 3
expansion. Rbsin ebIkarsakl,g expression min)anbgðaj vaRtUv)anyktMélBitCaGciéRnþy

2
dUcenH
for (;;) {
...
}
eKGacsμanTukCamun)anfaCa loop minkMnt; (infinite loop) GaccakecjBICMu break b¤ return.
cMNaM: CamUldæan C cat;TukXøa for dUcRbePT while loop
]TahrN_ :
-34-
vCBk
main()
{
int x;
for (x=3;x>0;x-)
{
printf("x=%d\n",x);
}
}
...outputs:
x=3
x=2
x=1
...to the screen
xageRkamTaMgGs;enHKWRtwmRtUvsMrab;;Xøa for enAkñúgPasa C. RbtibtþikarGnuvtþrbs;XøadUcenHmin

mansar³sMxan;enATIenHeT eyIgRKan;EtBnül;lkçN³Biessrbs;Pasa C EdlGacman RbeyaCn_ :
for (x=0;((x>3) && (x<9)); x++)
for (x=0,y=4;((x>3) && (y<9)); x++,y+=2)
for (x=0,y=4,z=4000;z; z/=10)
]TahrN_TIBIbgðajfa expression eRcInGacRtUv)anbMEbk a . enAkñúg]TahrN_TI 3 loop nwgbnþedIm,I

eFIVeLIgvijmþgeTotrhUtdl; z esμI 0
4.2 kenSamBakübgÁab; while
Xøa while KWRsedogeTAnwgGIVEdl)aneRbIR)as;TaMgenaHkñúgPasaepSgeTot eTaHbIy:agNak¾eday

eRcInCagenHeTAeTotGacRtUv)aneFIVCamYyXøa expression -- lkçN³sþgdarbs;Pasa C.
while manTRmg; :
while (expression)
statement
Expression RtUv)anvaytMél. RbsinebIvaminsUnü XøaRtUv)anRbtibtþinig expression RtUv)anvaytMél

mþgeTot. kareFIVenHecHEtbnþrhUtdl;l expression esμIsUnüenAeBlEdlbMNgRbtibtþikareFIVteTA
eTotbnÞab;BIXøa.
]TahrN_ :
main()
-35-
vCBk
{
int x=3;
while (x>0)
{ printf("x=%d\n",x);
x--;
}
}
...outputs:
x=3
x=2
x=1
...to the screen.
BIeRBaH while loop GacTTYl expression minRtwmEtl½kçx½NÐ xageRkamKWRtwmRtUv :

while (--);
while (x=x+1);
while (x+=5);
kareRbIR)as;RbePTenHrbs; expression RtwmEtenAeBllT§plén x--, x=x+1, b¤ x+=5,

vaytMélesμI 0 nwgl½kçx½NÐ while minBitehIy loop RtUv)ancakecj.
eyIgGacenAEteFIVnigbegáIt RbtibtþikareBjeljCamYynwg while expression:
while (i++ < 10);
while ( (ch = getchar()) != `q')

putchar(ch);
]TahrN_TImYyrab;BI i eLIgeTA 10. ]TahrN_TI2eRbIsþg;daGnuKmn_ ligrary C getchar() –

GantYGkSrBI keyboard - nig putchar() – sresrGkSrEdleGayeTAeGRkg;. Loop while
nwgRbtibtþi edIm,IGanBI keyboard ehIyepÞrGkSreTAeGayeGRkg;rhUtdl;tYGkSr 'q' RtUv)anGan.
cMNaM : RbePTénRbtibtþikarenHKWRtUv)aneRbICaeRcInenAkñúgPasa C
nigminRtwmEtCamYykarGantYGkSreT !!.
4.3 kenSamBakübgÁab; do-while
do-while sakl,genAxageRkameRkayBIeFIVkarqøgkat;tamxøÜn loop RKb;elIk xøÜnEtgEtRtUv)an
Rbtibtþiy:agticmþg.
Xøa do-while rbs; C manTRmg; :
do
statement;
while (expression);
-36-
vCBk
XøaRtUv)anRbtibtþi bnÞab;mk expression RtUv)anvaytMél. RbsinebIvaBitXøaRtUv)anvaytMélmþg
eTotehIybnþeTAeTot. enAeBl expression køayeTACaminBit loop enaHRtUv)anbBa©b;.
vaRsedogeTAnwg repeat ... until rbs;Pasa PASCAL b:Enþ do while expression KWBit.
]TahrN_ :
main()
{
int x=3;
do {
printf("x=%d\n",x--);
}
while (x>0);
}
..outputs:-
x=3
x=2
x=1
cMNaM : bc©y½xageRkay x—RbmaNviFIEdleRbItMélkMBugEtmanrbs; x xN³EdlkMBuge)aHecj
nigbnÞab;mkbnßytMél x.
4.4 break nig continue
C pþl;XøabBa¢a2edIm,IRtYtBinitürebobEdleyIgeFIV loop:
break – cakecjBI loop or switch.

continue -- rMlgkareFIVeLIgvij 1CMu
RtYtBinitü]TahrN_xageRkamEdleyIgGantMélcMnYnKt;FmμCati integer nigRbtibtþiBYkvaGaRs½ytam
l½kçx½NÐxageRkam. RbsinebItMélEdleyIg)anGanCatMélGviC¢man eyIgcg;e)aHBum<sarkMhusnigcak;
ecjBI loop. RbsinebItMélEdlGanKWFMCag 100 eyIgcg;minTTYldwgvaehIybnþeTAtMélbnÞab;kñúg
Tinñn½y. RbsinebItMélenaHCatMélsUnüeyIgcg;bBa©b; loop.
while (scanf( ``%d'', &value ) == 1 && value != 0)
{
if (value < 0) {
printf(`Ìllegal value\n'');
break; /* Abandon the loop */
}
if (value > 100) {

printf(`Ìnvalid value\n'');
continue;/* Skip to start loop again */
-37-
vCBk
}
/* Process the value read */

/* guaranteed between 1 and 100 */
....;
....;
} /* end while value != 0 */
lMhat;
Exercise 4-1
cUrsresrkmμviFIedIm,IGan 10 cMnYnnigKNna mFüm tMélFMbMputnig tUcbMput.

Exercise 4-2
cUrsresrkmμviFIedIm,IGancMnYnrhUtdl;cMnYn -999 RtUv)anbBa©Úl. plbUkénRKb;cMnYnEdlGanrhUtdl;

cMnunenHnwgRtUv)ane)aHecj.
Exercise 4-3
cUrsresrkmμviFIEdlnwgGantMél integer sMrab;;CamUldæanbnÞab;mkGancMnYnviC¢man integer RtUv)an

sresreTAmUldæannige)aHecjtMélrbs;va.
GantMél integer TIBI mYytYGkSrmYydg rMlgkarnaMeTAdl;GkSrminRtwmRtUvNamYy (i.e.
minEmntYelxrvagsUnünig “mUldæan-1”) bnÞab;mkGantYGkSrRtwmRtUvrhUtdl;tYGkSrminRtwmRtUvmYy
RtUv)anbBa©Úl.
Input Output
========== ======
10 1234 1234
8 77 63 (the value of 77 in base 8, octal)
2 1111 15 (the value of 1111 in base 2, binary)
mUldæannwgticCagb¤esμIeTAnwg 10.
Exercise 4-4
GankñúgbItMélbgðajEterog²xøÜn
plbUkedImTun (cMnYnKt; integer rbs; pence),
GaRtakarR)ak;CaPaKry (float),
nigcMnYnqñaM (integer).
-38-
vCBk
KNnatMélrbs;plbUkedImTunCamYynwgGRtakarR)akpSMbUkbEnßmelIkMLúgqñaM.
GRtakarR)akrbs;qñaMnimYy²RtUv)anKNnaCa
interest = capital * interest_rate / 100;
ehIyRtUv)anbUkbEnßmeTAplbUkedImTuneday
capital += interest;
e)aHecjtMélluyCa pounds (pence / 100.0) eTogTat;eTAeday2ek,óseRkayxÞúg.

e)aHecjtMélek,óssMrab;;tMélCamYyGaRtakarR)ak;pSMsMrab;;qñaMnimYy²eLIgrhUtdl;cugbBa©b;rbs;
kMLúgeBlenH.
e)aHecjqñaMedayqñaMkñúgTRmg;dUcCa :
Original sum 30000.00 at 12.5 percent for 20 years
Year Interest Sum

----+-------+--------
1 3750.00 33750.00
2 4218.75 37968.75
3 4746.09 42714.84
4 5339.35 48054.19
5 6006.77 54060.96
6 6757.62 60818.58
7 7602.32 68420.90
8 8552.61 76973.51
9 9621.68 86595.19
10 10824.39 97419.58
Exercise 4-5
GantMélcMnYnKt;viC¢mannigKNnalMdab;bnþbnÞab;xageRkam : RbsinebIcMnYnCacMnYnKU EckvaCaBIr Rbsin

ebIvaCacMnYnessKuNnwg 3 ehIybUkbEnßm 1. eFIVRbtibtþikarenHeLIgrhUtdl;tMél 1 e)aHecjtMél
nimYy². cugbBa©b;e)aHecjb:unμandgénRbtibtþikarTaMgenHEdlGñk)anbegáIteGaymaneLIg.
CaFmμtakare)aHecjGacCa :
Inital value is 9
Next value is 28
Next value is 14
Next value is 7
Next value is 22
Next value is 11
Next value is 34
Next value is 17
Next value is 52
Next value is 26
Next value is 13
Next value is 40
Next value is 20
-39-
vCBk
Next value is 10
Next value is 5
Next value is 16
Next value is 8
Next value is 4
Next value is 2
Final value 1, number of steps 19
RbsinebIkare)aHecjtMélticCag 1 e)aHBum<sarpÞúkBakü
Error
nigcat;Ecg
exit( 0 );
Exercise 4-6
cUrsresrkmμviFIedIm,Irab;RsHnigGkSrenAkñúgGtßbTmineRKagTukRtUv)anpþl;eGayCasþg;dabBa©Úl.
GanGtßbTmYytYGkSmYymþgrhUtdl;GñkCYbRbTHcugbBa©b;rbs;Tinñn½y.
bnÞab;mke)aHecjcMnYnénkarCYbRbTHnigRsHnimYy² a, e, i, o nig u enAkñúgGtßbT cMnYnsrubrbs;GkSr
nigRsHnimYy²CaPaKrycMnYnKt;FmμCatirbs;GkSrsrub.
esñITRmg;e)aHecjCa :
Numbers of characters:
a 3 ; e 2 ; i 0 ; o 1 ; u 0 ; rest 17
Percentages of total:
a 13%; e 8%; i 0%; o 4%; u 0%; rest 73%
GantYGkSrdl;cugbBa©b;rbs;Tinñn½ykareRbIR)as;karbegáItdUcCa
char ch;
while(
( ch = getchar() ) >= 0
) {
/* ch is the next character */ ....
}
edIm,IGantYGkSrmYykñúgmYyeBleRbIR)as; getchar() rhUtTal;;EttMélGviC¢manRtUv)anepÞr.
WWWW±XXXX
-40-
vCBk
CMBUkTI 5
Arrays nig Strings
Arrays and Strings
-41-
vCBk
CaeKalkarN_ array enAkñúgPasa C KWRsedogeTAnwgGIVEdlrkeXIjenAkñúgPasaepSg²eTot.
dUceyIgnwgeXIjenAeBlbnþiceTot array KWRtUv)ankMnt;xusKñabnþicbnþÚcehIyvamankareRbIR)as;CaeRcIn
xusKñaedayehtuTMnak;TMngsñiT§rvag array nig pointer. eyIgnwgemIleGaykan;Etl¥itl¥n;elITMnak;TMng
rvag pointer nig array enAelIkeRkay.
5.1 Array mYyvimaRtnigeRcInvimaRt
GnuBaØateGayeyIgemIldMbUgelIrebobkMnt; array kñúg C. karRbkas

int listofnumbers [50];
Rbkas listofnumbers Ca array 50 FatuéncMnYnKt;snÞsSn_én array cab;epþImBIelx 0 enAkñúg C

listofnumbers[0], listofnumbers[1], ..., listofnumbers[49].
snÞsSn_GacCakenSaméncMnYnKt; kñúgenaHrab;bBa©ÚlTaMgGefr nig efr cMnYnKt; .
RbugRby½tñ : snÞsSn_ Array enAkñúgPasa C cab;epþImBI 0 nigbBa©b;edaycMnYntUcCagTMhM array

cMnYnmYy. ]TahrN_enAkñúgkrNIxagelIsnÞsSn_EdlRtwmRtUvcenøaHcab;BI 0 dl; 49.
enHCaPaBxusKñad_FMrvag Pasa C nigPasad_éTeTot ehIyRtUvkarkarGnuvtþbnþicedIm,IeGayyl;c,as;.
FatuGacRtUv)aneRbIenAkñúgviFIxageRkam :
thirdnumber=listofnumbers[2];
listofnumbers[5]=100;
Array eRcInvimaRt (Multi-dimensional arrays) GacRtUv)anRbkasdUcxageRkam :

int tableofnumbers[50][50];
sMrab;;2vimaRt.
sMrab;;eRcInCagenHCaFmμtabEnßm [ ] eRcIn :
int bigD[50][50][40][30]......[50];
FatuGacRtUv)aneRbIkñúgviFIxageRkam :
anumber=tableofnumbers[2][3];
tableofnumbers[25][16]=100;
-42-
vCBk
5.2 Strings
kñúgPasa C Strings KWRtUv)ankMnt;Ca arrays éntYGkSr. ]TahrN_ kareGayniymn½yxageRkam

string én 50 tYGkSr :
char name[50];
C minmankarsg;bEnßmPaBgayRsYlsMrab;;edaHRsay string
eTehIydUcenHkUdxageRkamKWminRtwmRtUv :
char firstname[50],lastname[50],fullname[100];
firstname= "Arnold"; /* Illegal */

lastname= "Schwarznegger"; /* Illegal */
fullname= "Mr"+firstname+lastname; /* Illegal */
EteTaHCay:agNak¾edayvamanbNÑal½yBiessénTMlab;edaHRsay string EdleyIgnwgsikSaenAelIk

eRkay. edIm,Ie)aH string eyIgeRbI printf CamYyGkSrRtYtBinitüBiess %s :
printf(``%s'',name);
cMNMa : eyIgRKan;EtRtUvkarpþl;eQμaHrbs; string.

kñúgeKalbMNg;edIm,IGnuBaØatRbEvgGBaaØt string tYGkSr \0 RtUv)aneRbIedIm,IbgðajcugbBa©b;rbs; string.
dUcenHRbsinebIeyIgman string, char NAME[50]; ehIyeyIgrkSaTuk “DAVE” enAkñúgva
karbMeBjrbs;vanwgmanlkçN³dUcenH :
lMhat;
Exercise 5-1
sresrkmμviFI C edIm,IGantam array énRbePTNamYy.sresrkmμviFI C scan tam array enH

edImI,rktMélCak;lak;.
Exercise 5-2
GanGtßbTFmμtamYytYGkSrmYymþgBIsþg;dae)aHbBa©Úlrbs;kmμviFIehIye)aHvaCamYybnÞat;bRBa©as;
nimYy²BIeqVgeTAsþaM. GanrhUtTal;EtGñkCYbcMnuncugbBa©b;rbs;Tinñn½y (emIlxageRkam).
GñkGaccg;sakl,gkmμviFIedayvay
-43-
vCBk
prog5rev | prog5rev
edIm,IemIlRbsinebIkarcmøgRtwmRtUvénkarbBa©ÚledImKWRtUv)anbegáItmþgeTot.
edIMm,IGantYGkSrenAcugbBa©b;rbs;Tinñn½y kareRbIR)as; loop dUcCaTaMg
char ch;
while( ch = getchar(), ch >= 0 ) /* ch < 0 indicates end-of-data */
b¤k¾
char ch;
while( scanf( "%c", &ch ) == 1 ) /* one character read */
Exercise 5-3
cUrsresrkmμviFIedIm,IGanGtßbTPasaGg;eKøsdl;cugbBa©b;rbs;Tinñn½y (vay control-D
edIm,IbgðajcugbBa©b;rbs;Tinñn½yenAcugbBa©b; emIlxageRkamsMrab;;kareFIVeGaydwgva)nige)aHecjcMnYn
énRbEvgBakü i.e. cMnYnsrubrbs;Bakürbs; length 1 Edl)anCYbRbTH cMnYnrbs; length 2 ehIy
bnþbnÞab;eTot.
kMnt;BaküedIm,I)anCaGkSrtamlMdab;GkçRkm. GñkKYrGnuBaØatsMrab;;RbEvgBakürhUtdl; 25 GkSr.
kare)aHecjCaTUeTAKYrCaEbbenH :
length 1 : 10 occurrences
....
edIMm,IGanGkSrdl;cugbBa©b;énTinñn½yemIlsMnYrxagelI.
WWWW±XXXX
-44-
vCBk
CMBUkTI 6
GnuKmn_ Functions
-45-
vCBk
enAkñúgPasa C GnuKmn_KWesμIeTAnig subroutine b¤ function enAkñúgPasa Fortran b¤ procedure b¤
function enAkñúgPasa Pascal. Function pþl;eGayviFIEdlsmrmüedImI,eFIV encapsulate
karKNnamYycMnYnEdl GacRtUv)aneRbIenAeBleRkayedayKμankarRBYy)armÖGMBIkarGnuvtþn_rbs;va.
CamYynigkarerobcMGnuKmn_d¾RtwmRtUvvaGaceFIVCamindwgBIrebobkargarEdleFIVnigcMeNHdwgGIVEdleFIVEdl
RKb;RKan;.
6.1 mUldæanRKwHrbs;GnuKmn_
C begáIt the sue én functions gayRsYl smrmünigmanRbsiT§iPaB GñknwgCajwkjab;eXIjkarkMnt;
GnuKmn_xøInig)anehAmþg BIeRBaHvaeFIVeGayc,as;EpñkmYycMnYnrbs;kUd.dUcenHeyIg)aneRbIGnuKmn_
dUcCa printf, getchar nig putchar Etb:ueNÑaHEdl)anpþl;sMrab;;eyIg \LÚvvadl;eBledIm,I
sresrGnuKmn_mYycMnYnpÞal;xøÜnrbs;eyIg. edaysar C minmanniTsSnþkmμdUcCa ** rbs; Fortran
GnuBaØateGayeyIgBnül;viFIedaHRsayénniymn½yGnuKmn_edaysresr function power(m,n)
edIm,IelIkcMnYnKt; integer m eTAcMnYnviC¢man integer sV½yKuN n. enaHCatMélrbs; power(2,5)
esμI32. GnuKmn_enHminGnuvtþtamTmøab;niTsSnþkmμedaysarvaedaHRsayRtwmEtsV½yKuNcMnYnviC¢man
rbs;cMnYnKt;tUc b:uEnþvaBi)aklμmsMrab;;Bnül;. (sþg;da librarypÞúkGnuKmn_ pow(x,y)EdlKNna xy)
enHCaGnuKmn_ power ehIynigkmμviFI main edIm,IeRbIR)as;vadUcenHGñkGacemIlkmμviFITaMgmUl
Etmþg.
#include <stdio.h>
int power(int m, int n);
/* test power function */
main()
{
int i;
for (i = 0; i < 10; ++i)
printf("%d %d %d\n", i, power(2,i), power(-3,i));
return 0;
}
/* power: raise base to n-th power; n >= 0 */

int power(int base, int n)
{
int i, p;
p = 1;
for (i = 1; i <= n; ++i)
p = p * base;
return p;
}
karkMnt;Gtßn½yGnuKmn_ (Function definition) manTRmg;EbbenH :
return-type function-name(parameter declarations, if any)
{
declarations
statements
-46-
vCBk
}
karkMnt;Gtßn½yGnuKmn_ (Function definition) GacelceLIgkñúgTRmg;NamYyehIykñúg source file
mYyb¤eRcIn eTaHCay:agNaminmanGnuKmn_GacRtUv)anbMEbkrvag file epSgKñaeT. RbsinebIkmμviFI
edImmanenAkúñg file mYycMnYneKGacniyayfaeKRtUvkareBlevlaeRcInedIm,I compile nig load va
CaCagGnuKmn_TaMgGs;fitkñúg file EtmYyb:uEnþTaMgGs;enHvaCabBaðarbs;RbB½n§RbtibtþikarminEmnPasa
kMnt;eGayeT. sMrab;;eBlenHeyIgnwgsnμt;faGnuKmn_TaMgBIrenAkñúg file EtmYydUcenHGVIk¾edayGñk)an
eronGMBIrkardMeNIrkarkmμviFI C nwgEtbnþdMeNIrkar.
GnuKmn_ power RtUv)anehABIrdgeday main, kñúgbnÞat;enH
printf("%d %d %d\n", i, power(2,i), power(-3,i));
karehAnimYy²bBa¢Ún2 argument eTA power Edlkñúg1elIkepÞrtMél integer Edl)ankMnt;ehIynig

e)aHBum<ecj. enAkñúg expression power(2,i) KWCa integer dUcCa 2 nig i. bnÞat;dMbUgrbs;
power xøÜnvapÞal;
Rkas;RbePT)a:ra:EmRtnigeQμaHehIynigRbePTénlT§plEdlGnuKmn_epÞr.
eQμaHEdleRbIeday power sMrab;;)a:ra:EmRtrbs;vaKWCa local )a:ra:ERmtrbs;GnuKmn_ power
nigminGaceRbI)anedayGnuKmn_d¾éTeTot : GnuKmn_epSgeTotGaceRbIeQμaHdUcKñaedayKμanRcLMKña.
vak¾BitdUcCakareRbIR)as;GBaaØt i nig p Edl : GBaaØt i enAkñúgGunKmn_ power
KWminmanTMnak;TMngnigGBaaØt i enAkñúg main eT.
eyIgnwgeRbI)a:ra:ERmtTUeTAsMrab;;eQμaHGBaaØtenAkñúgkarkt;RtaTukkñúgrgVg;Rkckrbs;GnuKmn_.Bakü
formal argument nig actual argument KWeBlxøH)aneRbIsMrab;;eKaedAdUcKña. tMélEdlGnuKmn_
power KNnaRtUv)anepÞreTAGnuKmn_ main edayXøa return. Expression

NamYyGacenABIeRkay return:
return expression;
GnuKmn_minRtUvkarepÞrtMél Xøa return EdlKμan expression
bNþaleGaymankarRtYtBinitüb:uEnþminman tMélsMxan;EdlRtUvepÞreTAeGayGñkehA
-47-
vCBk
EdleFIVenAcugbBa©b;rbs;GnuKmn_eday)anCYbnwg brace cugxagsþaM. ehIykarehAGnuKmn_GacRtUv
)anTat;ecaltMélepÞredayGnuKmn_.
GñkGacmankMnt;cMnaMEdlmanXøa return mYyenAxagcugrbs; main. edaysar main
CaGnuKmn_dUceTAnwgGnuKmn_epSgeTot vaGacepÞrtMéleTAGñkehArbs;vaEdlvamanRbsiT§iPaB
enAkñúgmCÄdæanEdlkmμviFIRtUv)anRbtibtþi. CaTUeTAkarepÞrtMélsUnükMnt;fakarbBa©b;edayFmμta
tMélminsUnükMnt;faminFmμtab¤karbBa©b;kñúgl½kçx½NÐmankMhus.enAkñúgGRtakarR)ak;énPaBgayeyIg
)anlubXøa return BIGnuKmn_ main rbs;eyIgrhUtmkdl;eBlenHb:uEnþeyIgnwgrYmbBa©Úl
vaBIeBlenHeTAdUcCakarcMnaMfakmμviFIKYrepÞr status eTAeGaymCÄdæanrbs;va.
karRbkas
int power(int base, int n);
muneBlGnuKmn_ main faGnuKmn_ power CaGnuKmn_Edlnwgman argument BIrCaRbePT int
nigepÞrtMélCaRbePT int. karRbkasenHEdlRtUv)anehACa function prototype RtUvEtRtUvKañnwg
niymn½ynigkareRbIR)as;rbs;GnuKmn_ power. vaKWmankMhusRbsinebInimyn½yrbs;GnuKmn_b¤
kareRbIR)as;NamYyrbs;vaminRtwmRtUvCamYyKMrUrbs;va.
eQμaH)a:ra:ERmtmincMa)ac;RtUvKñaeT. tamBiteQμaH)a:ra:ERmtKWdak;k¾)anmindak;k¾)anenAkñúgGnuKmn_KMrU
(function prototype) dUcenHKMrU (prototype) eyIgGacsresr
int power(int, int);
eTaHCay:agNak¾edayeQμaHEdleRCIserIs)anläKWCaÉksal¥dUcenHeyIgjwkjab;nwgeRbIva
kMnt;cMaNaMrbs;RbvtþisaRsþpøas;bþÚrrvag ANSI C nigkMENfμIelIkmun (earlier versions) KWCarebob
GnuKmn_EdlRtUv)anRbkasnigeGayGtßn½y. enAkñúgkareGayGtßn½yedImrbs; C GnuKmn_ power
nwgRtUv)ansresrdUcenH :
/* power: raise base to n-th power; n >= 0 */
/* (old-style version) */
power(base, n)
int base, n;
{
int i, p;
p = 1;
for (i = 1; i <= n; ++i)
p = p * base;
return p;
}
-48-
vCBk
)a:ra:EmRtRtUv)aneGayeQμaHcenøaHrgVg;RkckehIyRbePTrbs;vaKWRtUv)anRbkasmun karebIk brace
xageqVg )a:ra:EmRtEdlminRbkasKWRtUv)anykCaRbePT int. (xøÜnrbs;GnuKmn_maneQμaHdUcBImun)
karRbkasrbs;GnuKmn_ power enAeBlcab;epþImrbs;kmμviFInwgmanlkçN³dUcenH :
int power();
minman)a:ra:EmRtRtUv)anGnuBaØatdUcenH compiler GacminTan;RtYtBinitüfa power RtUv)ancab;epþIm

ehA)anRtImRtUvb¤eT. tamBitedaysarCaTUeTAGnuKmn_ power nwgRtUv)ansnμt;CafaepÞrCaRbePT
int karRbkasTMagmUlGacRtUv)anlubGacCakarlä.
vaküsm<½n§fμIrbs;GnuKmn_KMrU (function prototype) eFIVvaeGaykan;EtgayRsYlsMrab;; compiler

edIm,IeFIVeGaysÁal;kMhuskñúgcMnYnrbs; argument b¤RbePTrbs;BYkva. rcnabfcas;énkarRbkas
nigenAEtkMnt;Gtßn½ykargarkñúg ANSI C y:agticsMrab;;karbBa¢Únl½kçx½NÐ b:uEnþeyIgsUmENnaMeday
sgát;F¶n;faeyIgeRbITRmg;fμIenAeBleyIgman compiler EdlGaceRbIva)an.
cUrRkeLkemIenA]TahrN_edIm,IrkmFümén2cMnYnKt;FmμCati :
float findaverage(float a, float b)
{ float average;
average=(a+b)/2;
return(average);
}
eyIgnwgehAGnuKmn_dUcxageRkam :
main()
{ float a=5,b=15,result;
result=findaverage(a,b);
printf("average=%f\n",result);
}
cMnaM : Xøa return bBa©Ún lT§plRtLb;eTAeGaykmμviFI main .

GnuKmn_ void pþl;eGayviFIénkarRbNaMgRbECg PASCAL RbePT procedure.
RbsinebIGñkmincg;epÞrtMélGñkRtUveRbIRbePTepÞr void ehIybM)at;ecalXøa return :
void squares()
{ int loop;
for (loop=1;loop<10;loop++);
printf("%d\n",loop*loop);
-49-
vCBk
}
main()
{ squares();
}
cMNMa : eyIgRtUvEtman () eTaHCaminman)a:ra:EmRtmindUcPasamYycMnYnk¾eday.

6.2 Arguments - Call by Value
RTg;RTaymYyrbs;GnuKmn_ C RbEhlCamindUceTAnwgkarsresrkmμviFIEdlRtUv)aneRbIcMeBaHPasamYy
cMnYnCaBiessPasa Fortran. enAkñúgPasa C RKb; argument GnuKmn_RtUv)anbBa¢ÚnedaytMél “by
value” enHmann½yfaGnuKmn_EdlehARtUv)anpþl;tMélén argument rbs;vakñúgGBaaØtGciéRnþyCaCag
GBaaØtedIm. enHnaMdl;kmμsiTi§xusKñamYycMnYnEdlRtUv)aneXIjeday “call by reference” PasadUcCa

Fortran b¤edayGBaaØt var enAkñúgPasa Pascal EdlenAkñúgkarehAGnuKmn_)aneRbI argument
edImminEmn argument cmøg local eT.

Call by value KWCa asset EteTaHCay:agNak¾edayminmanPaBTTYlxusRtUv. vaEtgEtnaMeTAdl;kar
RBmeRBogkmμviFIeRcInCamYyGBaaØtxageRkAbnþibnþÜceRBaH)a:ra:EmRtGacRtUv)ancat;TukCaGBaaØt local
Edlcab;epþImedayRtwmRtUvkñúgkarehAGnuKmn_. ]TahrN_ enHKWCakMENfμIrbs;GnuKmn_ power
EdleRbIR)as;lkçN³enH.
/* power: raise base to n-th power; n >= 0; version 2 */
{
int p;
for (p = 1; n > 0; --n)
p = p * base;
return p;
}
)a:ra:EmRt n RtUv)aneRbIR)asCaGefrbeNþaHGasnñ nigRtUv)anrab;fy ( for loop
EdlRbtibtþiRtLb;eRkay) rhUtTal;EtvaesμIsUnüvaminmancaM)ac;eToteTsMrab;;GBaaØt i.
GVIk¾edayEdl)aneFIVcMeBaH n xagkñúg power minmanb:HBal;dl; power )anehABIedImCa

mYyenHeT. enAeBlcaM)ac;vaGacerobcMsMrab;;GnuKmn_edIm,IEktMrUvGBaaØtkñúgkarehAGnuKmn_.
GñkehARtUvEtpþl; address énGBaaØtEdlRtUv)ankMnt; (tambec©keTs pointer cg¥úleTAGBaaØt)
nigGnuKmn_EdlRtUv)anehARtUvEt)anRbkas)a:ra:EmRtCa pointer nigeRbIGBaaØtedaypÞal;tamry³va.
eyIgnigelIkyk pointer mksikSaelIkeRkay. erOgravKWxusBI array. enAeBleQμaHrbs; array
RtUv)aneRbICa argument tMélEdl)anbBa¢ÚneTAGnuKmn_KWCaTItaMgb¤ address énTItMagdMbUgrbs; array –
-50-
vCBk
vaminmankarcmøgénFatu array . edaysnÞsSn_tMélenHGnuKmn_GaceRbInigpøas;bþÚr argument
NamYyrbs; array. enHCaRbFanbTenAEpñkbnÞab;.

6.3GnuKmn_nig Arrays
Array mYyvimaRtGacRtUv)anbBa¢ÚneTAGnuKmn_dUcxageRkam :
float findaverage(int size,float list[])

{ int i;
float sum=0.0;
for (i=0;i<size;i++)
sum+=list[i];
return(sum/size);
}
enHKWCakarRbkas float list[ ] R)ab; C fa list enHCa array mYyRbePTCa

float. cMNaMeyIgminbBa¢ak;vimaRtrbs; array enAeBlvaCa)a:ra:EmRtrbs;GnuKmn_.
Array eRcInvimaRtGacRtUv)anbBa¢ÚneTAGnuKmn_dUcxageRkam :
void printtable(int xsize,int ysize,

float table[][5])
{ int x,y;
for (x=0;x<xsize;x++)
{ for (y=0;y<ysize;y++)
printf("\t%f",table[x][y]);
printf("\n");
}
}
enH float table[][5] R)ab; C fa table Ca array EdlmanvimaRt N * 5 én

float. cMnaMeyIgRtUvkMnt;vimaRtTIBI (ehIy lMdab;bnÞab;) rbs; array b:uEnþminEmnCavimaRt
TI1eT.
6.4 KMrUedImGnuKmn_
muneBleyIgeRbIGnuKmn_ C RtUvmancMeNHdwgGMBIrRbePTEdlvaepÞrnigRbePT)a:ra:EmRtEdlGnuKmn_nwg
eRbI.
sþg;da ANSI rbs; C ENnaMrebobfμI (RbesIrCag) énkareFIVenHCakMEN (versions) munrbs; C. (cMNaM:
RKb;kMENfμITaMgGs;rbs; C \LÚvRtUvKñanwgsþg;da ANSI )
sar³sMxan;énKMrUKWBIry:ag :
-51-
vCBk
vabegáIteGaymanrcnasm<½n§eRcInnigdUcenHvagayRsYlCagedIm,IGankUd.
vaGnuBaØateGay C compiler RtYtBinitüvaküs½BÞ (syntax )rbs;GnuKmn_EdlehA.
etIvaeFIVy:agdUcemþckñúgTMhMkargarrbs;GnuKmn_.
CamUldæanebIsinCaGnuKmn_RtUv)ankMnt;muneBlvaRtUv )aneRbI ( )anehA)
enaHGñkRKan;Etyl;RBmeRbIGnuKmn_.
RbsinebIminmanenaHGñkRtUvEtRbkasGnuKmn_. karRbkasGnuKmn_CaFmμtaKWRbkasRbePTtMélEdl
GnuKmn_epÞrnigRbePTrbs;)a:ra:EmRtEdleRbIedayGnuKmn_.
vaCaTUeTA (ehIynigdUcenHlä) GnuvtþKMrURKb;GnuKmn_enAeBlcab;epþImrbs;kmμviFI eTaHbIy:agNak¾
edayvaenHminCaRtUvkarxøaMeBkeT.
edIm,IRbkasKMrUGnuKmn_ (function prototype) CaFmμtaRbkasRbePTtMélEdlGnuKmn_epÞreQμaH
GnuKmn_nigenAkñúgvg;Rkck (bracket) RbePTrbs;)a:ra:EmRtEdlmankñúgkarkMnt;Gtßn½yGnuKmn_
(function definition)
e.g.
int strlen(char []);
sPaBenHEdlGnuKmn_)anehA strlen epÞrtMél integer nigTTYl string EtmYyCa)a:ra:ERmt.

cMNaM : GnuKmn_GacCaKMrUnigGBØatiEdlkMnt;enAkñúgkUd. enHRtUv)aneRbIR)as;kan;EtmanRbCaRbiyeRcIn
eLIgenAkñúgeBlmun ANSI C edaysarEtGunKmn_EtgEteRbIKMrUEterog²xøÜnenAeBlcab;epþImrbs; kmμviFI.
eTaHCay:agenHk¾edayvaenAEtRtImRtUv : kñúgbMNgBYkvaelceLIgkñúgGtßn½yGnuKmn_.
e.g.
int length, strlen(char []);
length CaGBaaØt strlen CaGnuKmn_dUcelIkmun.

lMhat;
Exercise 6-1
cUrsresrGnuKmn_CMnYsEdlyk pointer eTA string Ca)a:ra:EmRtEdlCMnYsRKb;dkXøaenAkñúg string
enHedaydkEtmYyehIyykcMnYnrbs;dkXøaCMnYsva.
-52-
vCBk
dUcenH
char *cat = "The cat sat";
n = replace( cat );
nwgkMnt;
cat to "The-cat-sat"
ehIy
n to 2.
Exercise 6-2
sresrkmμviFIEdlnwgGankñúgkmμviFIedImrbs; C BIsþg;dabBa©Úlnige)aHecjsBaØapáayRKb;BaküxageRkam
EdleFIVsßitixageRkamsMrab;;kmμviFI (TaMgGs;CacMnYnKt; integer). (cMnaMkarBnül;elIGkSr tab
xagcugénkarbBa¢ak;eGayc,as;enH)
e)aHecjtMéldUcxageRkam :
Lines:
* The total number of lines
* The total number of blank lines
(Any lines consisting entirely of white space should be
considered as blank lines.)
The percentage of blank lines (100 * blank_lines / lines)
Characters:
* The total number of characters after tab expansion
* The total number of spaces after tab expansion
* The total number of leading spaces after tab expansion
(These are the spaces at the start of a line, before any visible
character; ignore them if there are no visible characters.)
The average number of
characters per line
characters per line ignoring leading spaces
leading spaces per line
spaces per line ignoring leading spaces
Comments:
* The total number of comments in the program
* The total number of characters in the comments in the program
excluding the "/*" and "*/" thenselves
The percentage of number of comments to total lines
The percentage of characters in comments to characters
Identifiers:
We are concerned with all the occurrences of "identifiers" in the
program where each part of the text starting with a letter,
and continuing with letter, digits and underscores is considered
to be an identifier, provided that it is not
in a comment,
or in a string,
or within primes.
Note that
"abc\"def"
the internal escaped quote does not close the string.
Also, the representation of the escape character is
'\\'
and of prime is
-53-
vCBk
'\''
Do not attempt to exclude the fixed words of the language,
treat them as identifiers. Print
* The total number of identifier occurrences.
* The total number of characters in them.
The average identifier length.
Indenting:
* The total number of times either of the following occurs:
a line containing a "}" is more indented than the preceding line
a line is preceded by a line containing a "{" and is less
indented than it.
The "{" and "}" must be ignored if in a comment or string or
primes, or if the other line involved is entirely comment.
A single count of the sum of both types of error is required.
cMNaM : RKb;GkSr tab ('') kñúgkare)aHbBa©ÚlKYrEtRtUv)anbkERbCadkXøaeRcInedayeRbIR)as;c,ab;enH :

"move to the next modulo 8 column"
where the first column is numbered column 0.
col before tab | col after tab
---------------+--------------
0 | 8
1 | 8
7 | 8
8 | 16
9 | 16
15 | 16
16 | 24
edIm,IGankare)aHcUlGkSrenAeBlmYyTRmg;mankUdcUlrYmedIm,IGanmYybnÞat;kñúg1elIksMrab;;GñkeRbI
R)as;
char ch;
ch = getchar();
EdlnwgykGkSrBitR)akddUcEdlGan. GnuKmn_ "getline" enaHdak;bBa©ÚlRtwmEtXøaEdlGankñúg

array TaMgmUlrbs;GkSr "linec" null RtUv)anbBa©b;ehIyykRbEvgrbs;Xøab¤tMélGviC¢manRbsin
ebIcugbBa©b;rbs;Tinñn½yRtUv)anrab;bBa©Úl.
GñkGacrkemIlGkSredayRKan;EtGanCamYy (]TahrN_)
switch( linec[0] ) {
case ' ': /* space ..... */
break;
case '\t': /* tab character .... */
break;
case '\n': /* newline ... */
break;
....
} /* end switch */
cugbBa©b;rbs;Tinñn½yRtUv)anbgðajeday scanf minyktMél 1.
kare)aHecjrbs;GñkGacnwgRtUv)ane)aHecjkñúgrebobxageRkam :
Total lines 126
Total blank lines 3
Total characters 3897
-54-
vCBk
Total spaces 1844
Total leading spaces 1180
Total comments 7
Total chars in comments 234
Total number of identifiers 132
Total length of identifiers 606
Total indenting errors 2
GñkGacRbmUlfakmμviFIxagelI (rYmbBa©ÚlKñaCamYyBaküminEmnCapáay)
TRmg;TUeTArbs;EpñkénkarbegáIt RbB½n§eFIVkarrbs;Gñk! cUreFIV bit
dMbUgeGayRsYlnigTukeGayvaenATIenaHRbsinebITRmg;mYycMnYneFIVeGay GñkBi)ak.
RtLb;mkrk´RbsinebIGñkKitfadMeNaHRsayrbs;´ (b¤karCak;lak;enH) xus! enHKWGaceRcIn!
Exercise 6-3
vaCaGRtakarR)ak;énkarbg;mþg²!
Loop eFVIRbtibtþikarxageRkamkñúgkmμviFIrbs;Gñk :
GantMél integer BIr bgðajGRtakarR)ak;Edlbg; (pence kñúg1em:ag) ehIycMnYnénem:ag. e)aHecjTwk
R)ak;bg;srubeday40em:agRtUvbg;nUvGRtaFmμta BI40-eTA60em:agbg;nUvGaRta1knøHénGaRtaFmμta
ehIyelIsBI60em:agbg;BIrdgGRtaFmμta. e)aHecjkarbg;R)ak;Ca pound edaymaneRkayek,ósBIr
xÞúg.
bBa©b; loop enAeBlGaRtaR)ak;esμIsUnü)anCYb. enAcugbBa©b;rbs; loop e)aHecjkarbg;srub.
kUcsMrab;;karKNnakarbg;R)ak;BIGaRtakarR)ak;nigem:agKWRtUv)ansresrCaGnuKmn_.
kare)aHecjKYrmanTRmg;dUcGIVxageRkamenH:
Pay at 200 pence/hr for 38 hours is 76.00 pounds
Total pay is 928.80 pounds
lkçN³rbs;kmμviFIRtYtBinitütMélCak;EsþgdUcCa40nig60EdlmaneLIgmþgCa #define b¤karkMnt;tMél

dMbUgrbs;GBaaØt. enHbgðajkarsresrkmμviFIEdllä.
WWWW±XXXX
-55-
vCBk
CMBUkTI 7
RbePTTinñn½yBisþabEnßm
Further Data Types
-56-
vCBk
emeronenHBiPakSalMGitCagmunBIRbePTTinñn½ynigrcnasm<½n§GacRtUv)anbegáItehIyeRbIenAkúñgkmμviFI
C.
7.1 GBaaØtsV½yRbvtþi nig GBaaØtxageRkA
kmμviFI C manpÞúknUvsMnMuén object xageRkAEdlGBaaØtk¾edayGnuKmn_k¾eday. KuNnam “external”

KWRtUv)aneRbIpÞúynig `ìnternal'' EdlBiBN’naBI arguments nigGBaaØtEdlkMnt;enAkñúg GnuKmn_.
GBaaØtxageRkA (external variable) KWRtUv)ankMnt;enAxageRkArbs;GnuKmn_mYycMnYnehIydUcenH
EdlGacrk)anedayskþanuBleTAGnuKmn_CaeRcIn. GnuKmn_xøÜnvaEtgEtenAxageRkA (external) BIeRBaH
C minGnuBaØateGayGnuKmn_RtUv)ankMnt;enAxagkñúgGnuKmn_epSgeToteT. CaTUeTAGBaaØtxageRkAnig
GnuKmn_mankmμsiTi§EdlsMGagelIvaTaMgGs;edayeQμaHdUcKañeTaHbIBIGnuKmn_EdlRtUv)an compile
enAdac;²BIKñak¾edayKWsMGageTAvtßúEtmYydUcKña. (sþg;daehAkmμsiTi§enH external linkage.)
enAkñúgn½yenHGBaaØtxageRkAKWRsedogeTAnwg Fortran COMMON bøúkb¤GefrenAkñúgbøúkeRkA
eKbMputkñúg Pascal. eyIgnwgeXIjenAelIkeRkaynUvrebobkMnt;GBaaØtxageRkAnigGnuKmn_EdleRbI
)anEtenAkñúg file edImEtmYy.
BIeRBaHGBaaØtxageRkAKWGaceRbICaTUeTABYkvapþl;eGaykarpøas;bþÚreTACa argument rbs;GnuKmn_nigepÞr
tMélsMrab;;karTMnak;TMng;Tinñn½yrvagGnuKmn_. GnuKmn_NamYyGaceRbIGBaaØtxageRkAedaykarsMGag
eTAvaedayeQμaHRbsinebIeQμaHRtUv)anRbkas. mindwgy:agem:cRbsinebIcMnYnFMrbs;GBaaØtRtUvEt)an
EckcaykñúgcMeNamGnuKmn_GBaaØtxageRkAKWsmrmüCagnigmanRbsiT§iPaBCagbBa¢I argument Edl
Evg. EteTaHCay:agNak¾edayehtuplenHnwgRtUv)anGnuvtþCamYykardas;etOnsMrab;;vaGacmanpl
b:HBal;GaRkk;enAkñúgrcnasm<½n§kmμviFIehIynaMdl;karsresrkmμviFICamYykarP¢ab;Tinñn½yCaeRcInrvag
GnuKmn_.
GBaØaixageRkAk¾manRbeyaCn_EdreRBaHTMhMkargarrbs;vaFMCagnigry³eBlRbtibtþirbs;va.
edaysV½yRbvtþiGBaaØtKWenAxagkñúgGnuKmn_vamkCamanenAeBlGnuKmn_RtUv)anbBa©ÚlnigminmanenA
eBlva)ancakecj . GBaaØtxageRkAmüa:gvijeTotCaGBaaØtGciéRnþdUcenHvaGacTuk
tMélBIGnuKmn_mYyEdlcg;)aneTAGnuKmn_bnÞab;. dUcenHRbsinebIGnuKmn_BIrRtUvEtEckrMELkTinñn½y
mYycMnYn eTaHCa)anehAb¤k¾minTan;)anehAenAeLIyvaCajwkjab;KWRtwmRtUvRbsinebITinñn½yEdl)anEck
rMElkRtUv)anrMlgenAkñúgGBaaØtxageRkACaCagbBa¢ÚnvaeTAkñúgnigeTAeRkAtamry³ arguments.
cUrBinitüdMeNaHRsayenHCamYy]TahrN_FMmYy.bBaðaKWedIm,IsresrkmμviFIKNnaEdlpþl;karI +, -, *
nig /. BIeRBaHvakan;EtgayRsYlkñúgkarGnuvtþ GñkKNnanwgeRbIkMnt;cMnaMbRBa©as Polish (reverse
-57-
vCBk
Polish notation) CMnYskarbNþúHKMnit. (Reverse Polish notation RtUv)aneRbIedayGñkKNnakrNI
mYycMnYnnigenAkñúgPasadUcCa Forth nig Postscript.)
enAkñúgkMnt;cMnaMbRBa©as Polish RbmaNviFIxageRkay operand rbs;vabNþúHKMnit expression dUc
(1 - 2) * (4 + 5)
RtUv)anbBa©ÚlCa
1 2 - 4 5 + *
)a:ra:EmRtKWminRtUvkar kMnt;cMnaMEd;lmann½yc,as;las;dUceyIg)andwgCayUrmkehIyetIman operands

b:unμanEdlnwgmanenAkñúgRbmaNviFInimYy². karGnuvtþKWsamBaØ. Operand nimYy²RtUvrujcUlkñúg stack
enAeBlRbmaNviFImYymkdl;cMnYnsmrmürbs; operand (2 sMrab;;RbmaNviFI binary) RtUv)anykecj
RbmaNviFIRtUv)anGnuvtþelI operand enaHehIylT§plRtUv)anrujcUleTAkñúg stack vij.
enAkñúg]TahrN_xagelIsMrab;;tMél 1nig 2 RtUv)anrujcUleTA stack bnÞab;mkCMnYsedayPaBxus
Kñarbs;va -1 bnÞab;mk 4 nig 5 RtUv)anrujbBa©ÚlehIybnÞab;mkCMnYsedayplbUkrbs;vaesμI 9.
plKuNrbs; -1 nig 9 EdlesμInig -9 RtUv)anCMnYsBYkvaenAkñúg stack. tMélenAkñúgkMBUlrbs; stack
RtUv)andkykeRbIehIyRtUv)ane)aHecjenAeBlcugbBa©b;énXøae)aHcUlRtUv)anCYb. rcnasm<½n§rbs;
kmμviFIKWdUcenH loop EdleFIVRbtibtþikarRtwmRtUvenAelIRbmaNviFInimYy²nig operand dUcva)an
ekIteLIg.
while (next operator or operand is not end-of-file indicator)
if (number)
push it
else if (operator)
pop operands
do operation
push result
else if (newline)
pop and print top of stack
else
error
RbtibtþikarrujnigTajykrbs; stack mYyKWFmμtab:uEnþedayeBlrkeXIjkMhusnigrk)anmkvijnUvrbs;

Edl)at;KWRtUv)anbUkbEnßm vaEvglμmEdlvaRbesIredaybB©aÚlFatunimYy²enAkñúgGnuKmn_epSgdac;BIKña
eCosCagsrsrkUddEdl²kñúgkmμviFITaMgmUl. ehIyvanwgmanGnuKmn_dac;edayELksMrab;;naMeTA
RbmaNviFIe)aHbBa©Úlb¤ operand bnÞab;. karerobcMvinic½äycm,gEdlmin)anBiPakSaenAeLIyKWkEnøg
-58-
vCBk
Edl stack enA EdlvaCaGunKmn_eRbIvaedaypÞal; **. lT§PaBKWedIm,IrkSavaenAkñúg main ehIybBa¢Ún
stack nigTItMagEdlkMBugsßitenArbs; stack eTAGnuKmn_Edlruj (push) nigTajyk (pop) va. b:uEnþ
main minRtUvkardwgGMBIGBaaØtEdlRtYtBinitü stack eT vaeFIVRtwmEtRbmaNviFI push nig pop .
dUcenHeyIgRtUv EtsMerccitþrkSaTuk stack nigBt’manP¢ab;mkCamYyvaenAkñúgGBaaØtxageRkA (external

variable) GaceRbI)anedayGnuKmn_ push nig pop b:uEnþminEmnCa main.
bkERbrKMeragenHeTACa kUd KWminsUvBi)akeT. RbsinebIeBlenHeyIgKitGMBIkmμviFIdUcEdlmanenAkñúg

file edImvanwgeXIjdUcenH :
#includes
#defines
function declarations for main
main() { ... }
external variables for push and pop
void push( double f) { ... }
double pop(void) { ... }
int getop(char s[]) { ... }
routines called by getop
bnÞab;mkeyIgnwgBiPakSaGMBIrrebobGacbMEbkeTACaBIrb¤eRcIn file edIm. GnuKmn_ main KWCa loop pÞúk

switch enAkñúgRbePTénRbmaNviFIb¤ operand enHKWCakareRbI switch d¾samBaØmYy.
#include <stdio.h>
#include <stdlib.h> /* for atof() */
#define MAXOP 100 /* max size of operand or operator */
#define NUMBER '0' /* signal that a number was found */
int getop(char []);
void push(double);
double pop(void);
/* reverse Polish calculator */
main()
{
int type;
double op2;
char s[MAXOP];
while ((type = getop(s)) != EOF) {
switch (type) {
case NUMBER:
push(atof(s));
break;
case '+':
push(pop() + pop());
break;
case '*':
push(pop() * pop());
break;
case '-':
op2 = pop();
push(pop() - op2);
break;
case '/':
op2 = pop();
if (op2 != 0.0)
push(pop() / op2);
else
-59-
vCBk
printf("error: zero divisor\n");
break;
case '\n':
printf("\t%.8g\n", pop());
break;
default:
printf("error: unknown command %s\n", s);
break;
}
}
return 0;
}
BIeRBaH + nwg * KWCaRbmaNviFIEdlpøas;bþÚr lMdab;EdlenAkñúg operand EdlrujcUl stak

RtUv)anbBa©Úl KñaKWenAdac;BIKñab:uEnþsMrab;; - nwg / enAxageqVgnwgxagsþaM perand RtUv)anEckdac;BIKña.
kñúg
push(pop() - pop()); /* WRONG */
lMdab;EdlkarehABIrdgén pop RtUv)anvaytMélkñúglMdab;minkMnt;. edIm,IFana)annUvlMdab;xagsþaMva

KWcMa)ac;kñúgkar pop tMéldMbUgcUlkñúgGBaøØatiGciéRnþydUcEdleyIg)aneFIVenAkñúg main.
#define MAXVAL 100 /* maximum depth of val stack */
int sp = 0; /* next free stack position */
double val[MAXVAL]; /* value stack */
/* push: push f onto value stack */
void push(double f)
{
if (sp < MAXVAL)
val[sp++] = f;
else
printf("error: stack full, can't push %g\n",
f);
}
/* pop: pop and return top value from stack */
double pop(void)
{
if (sp > 0)
return val[--sp];
else {
printf("error: stack empty\n");
return 0.0;
}
}
GBaaØtmYyCaGBaaØtxageRkARbsinebIvakMnt;enAxageRkAGnuKmn_NamYy. dUcenH stack nigsnÞsSn_

stack EdlRtUvEtmancMENkedayGnuKmn_ push nwg pop KWRtUv)ankMnt;xageRkAGnuKmn_TaMgenH.
b:uEnþ main xøÜnvaminyktam stack b¤TItaMg stack – karbgðajGacRtUv)anlak;.

\LÚvcUreyIgRtLb;eTAkarGnuvtþn¾én getop GnuKmn_EdlnaMykmkRbmaNviFIbnÞab;b¤ operand .
karRBwtþieTAKWgayRsYl. rMlgecalTITMenrnig tab . RbsinebItYGkSrbnÞab;minEmnCaelxb¤elxkñúg
-60-
vCBk
RbB½n§eKal16 epÞrva. ebImindUcenHkarRbmUl string énelx (EdlGacrab;bBa©ÚlcMnYneKaldb;)
ehIynig return NUMBER CasBaØNEdlcMnYnRtUv)anRbmUl.
#include <ctype.h>
int getch(void);
void ungetch(int);
/* getop: get next character or numeric operand */
int getop(char s[])
{
int i, c;
while ((s[0] = c = getch()) == ' ' || c == '\t');
s[1] = '\0';
if (!isdigit(c) && c != '.')
return c; /* not a number */
i = 0;
if (isdigit(c)) /* collect integer part */
while (isdigit(s[++i] = c = getch()));
if (c == '.') /* collect fraction part */
while (isdigit(s[++i] = c = getch()));
s[i] = '\0';
if (c != EOF)
ungetch(c);
return NUMBER;
}
GIVeTACa getch nig ungetch? vaCakrNIjwkjab;EdlkmμviFIminGackMnt;fava)anGankare)aHcUl

RKb;RKan;rhUt;dl;va)anGaneRcIn. tMélmYyRbmUltYGkSrmYyEdlbegáItCacMnYn : rhUtdl;minmantMél
elxenAeGRkg;cMnYnmineBjelj. b:uEnþbnÞab;mkkmμviFI)anGanmYytYGkSrpgEdrGkSrmYyEdlvamin
)anerobcMsMrab;;bBaðanwgRtUv)anedaHRsayRbsinebIvaGacminGantYGkSrEdlmincg;)an. bnÞab;mkRKb;
eBlkmμviFIGanmYytYGkSreRcIndgvaGacrujvaRtLb;eTAkare)aHcUlvij. dUcenHEpñkenAsl;rbs;kUd
GacmanRbRBwtþdUcRbsinebIvaminEdl)anGan. CaP½BVl¥vagayRsYledIm,IeFIVeGayGkSrEdlBi)akTTYl
ykGacTTYlyk edayeFIVkarsresrKUrénGnuKmn_EdlshkarKña.
getch RbKl;eGaykare)aHcUlbnÞab;RtUv)anRtYtBinitü ungetch nwgepÞrtMélmunkarGanbBa©Úl
tMélfμI. rebobEdlBYkvaeFIVkarCamYYyKñaKWFmμta. ungetch dak;GkSEdldak;RtLb;eTAvijkñúg

buffer EbgEck (shared buffer) -- array rbs;tYGkSr. getch GanBI buffer
RbsinebImanGIVepSgeTotehA getchar RbsinebI buffer enATMenr. vak¾RtUvEtCaGBaaØtsnÞsSn_

Edlkt;RtaTItaMgrbs;GkSrEdlkMBugsßitenAkñuúg buffer. edaysar buffer nigsnÞsSn_RtUv
)anEbgEckeday getch nig ungetch nwgRtUvEtrkSatMélrbs;varvagkarehABYkvaRtUvEtCa
GnuKmn_enAxageRkATaMgBIr. dUcenHeyIgGacsresr getch, ungetch, nigGBaaØtEdlEbgEckCa :
#define BUFSIZE 100
char buf[BUFSIZE]; /* buffer for ungetch */
int bufp = 0; /* next free position in buf */
-61-
vCBk
int getch(void) /* get a (possibly pushed-back) character
*/
{
return (bufp > 0) ? buf[--bufp] : getchar();
}
void ungetch(int c) /* push character back on input */
{
if (bufp >= BUFSIZE)
printf("ungetch: too many characters\n");
else
buf[bufp++] = c;
}
sþg;da library rYmmanGnuKmn_ ungetch Edlpþl;mYytYGkSrénkarrujRtLb; pushback
eyIgnwgBiPakSavaenAkñúgemeroneRkay. eyIg)aneRbIR)as; array sMrab;; pushback CaCagGkSrEtmYy
edIm,IBnül;eGay)ankan;EtTUeTAEfmeTot.
7.2 GBaaØt Static
GBaaØt sp nwg val enAkñúg stack.c, nwg buf nwg bufp enA getch.c
KWsMrab;;kareRbIR)as;pÞal;rbs;GnuKmn_enAkñúg file edImerogxøÜnrbs;vanwgminmann½yCakareRbIR)as;
edayGVIepSgeToteT.karRbkasCa static GnuvtþnelIGBaaØtxageRkA (external variable)
b¤GnuKmn_kMnt;RBMEdnTMhMkargarrbs; object enHeTAEpñkenAsl;rbs; file edImEdlRtUv)an compile.
External static dUcenHviFIlakeQμaHdUcCa buf nwg bufp enAkñúg getch-ungetch
rYmbBa©ÚlKñaEdlRtUv)aneRbIxageRkAdUcenHBYkvaGacRtUv)anEbgEck EdlkarEbgEcknwgGñkeRbIminGac
eRbIGnuKmn_ getch nig ungetch.
karrkSaTuk static KWRtUv)ankMnt;edaykardak;buBVbTkarRbkasFmμtaCamYyBakü static. RbsinebI
GnuKmn_BIrnwgGBaaØtBIrRtUv)an compile kñúg file mYy dUckñúg
static char buf[BUFSIZE]; /* buffer for ungetch */
static int bufp = 0; /* next free position in buf */
int getch(void) { ... }
void ungetch(int c) { ... }
enaHminmanGunKmn_epSgeTotGacRtUv)aneRbI buf nwg bufp ehIyeQμaHTMagenHnwgminRcLMKñaeday

eQμaHdUcKañkñúg file epSgKñakñúgkmμviFIEtmYy kñúgviFIEtmYy GBaaØtEdl push nig pop eRbIsMrab;;
cat;Ecg stack GacRtUv)anlak; edaykarRbkas sp nwg val Ca static. karRbkas static
enAxageRkAKWCajwkjab;RtUv)aneRbIR)as;sMrab;;GBaaØt b:uEnþvaGacRtUv)anGnuvtþelIGnuKmn_dUcKña.
CaTUeTAeQμaHGnuKmn_KWTaMgGs; global GaceRbI)anedayEpñkNamYyénkmμviFITMagmUl. RbsinebI
-62-
vCBk
GnuKmn_RtUv)anRbkas. RbsinebIGnuKmn_RtUv)anRbkasCa static EteTaHCay:ageQμaHrbs;vaKW
minGaceRbI)anenAxageRkA file EdlvaRtUv)anRbkasenaHeT.
karRbkas static k¾GacRtUUv)anGnuvtþn_CaGBaaØtxagkñúg (internal variable). GBaaØt static
xagkñúgCa local eTAnigGnuKmn_Cak;lak;dUcnigGBaaØtsV½yRbvtþiEdl b:uEnþmindUcGBaaØtsV½yRbvtþiBYk
vaenArkSakñúgGtßiPaBCaCagtMélcUlnigecjRKb;elIkGnuKmn_RtUv)aneFIVskmμPaB. vamann½yfaGBaaØt
static xagkñúgpþl;eGayCaÉkCnkarrkSaTukCaGciéRnþyxagkñúgGnuKmn_EtmYy.
GBaaØt static Ca local cMeBaHGnuKmn_Cak;lak;. EteTaHCay:agNak¾edayvaRtwmEtkMnt;tMélcab;

epþImmþg (enAkñúgkarehAGnuKmn_dMbUg).
k¾dUctMélrbs;GBaaØtenAeBlcakecjBIGnuKmn_enAEtrkSatMélKμanxUcxat. enAkñúgkarehAbnÞab;eTA
GnuKmn_GBaaØt static mantMéldUcKñaxN³Edlcakecj.
edIm,IkMnt;GBaaØt static CaFmμtabuBVbTkarRbkasGBaaØtCamYy static keyword.
]TahrN_ :
void stat(); /* prototype fn */
main()
{ int i;
for (i=0;i<5;++i)
stat();
}
stat()
{ int auto_var = 0;
static int static_var = 0;
printf( `àuto = %d, static = %d\n'',

auto_var, static_var);
++auto_var;
++static_var;
}
e)aHecjKW :
auto_var = 0, static_var = 0
-63-
vCBk
c,as;Nas;GBaaØt auto_var RtUv)anbegÁItral;elIk. static_var RtUv)anbegáItmþgnigcgcaM

tMélrbs;va.
7.3 GBaaØt Register
karRbkas register ENnaM compiler faGBaaØtkñúgsMnYnnwgRtUv)aneRbIy:agF¶n;. KMnitenH

KWfaGBaaØt register RtUv)anCMnYskñúg register rbs;m:asIunEdlGacniglT§plkñúgkmμviFImanTMhM
tUcCagnigelOnCag. b:uEnþ compiler KWgaynwgbMepøckarENnaM.
karRbkas register emIleTAdUcenH
register int x;
register char c;
ehIynwgbnþbnÞab;karRbkas register GacRtwmEtGnuvtþelIGBaaØtsV½yRbvtþinig formal parameter

rbs;GnuKmn_. enAkñúgkrNIelIkeRkayvaemIleTAdUcenH
f(register unsigned m, register long n)
{
register int i;
...
}
enAkñúgkarGnuvtþmankarkat;bnßyelIGBaaØt register karKitBitR)akdelI hardware EdleRbI. man

EtGBaaØtBIrbIb:ueNÑaHkñúgGnuKmn_nimYy²GacRtUv)anrkSakñúg registerehIymanEtRbePTCak;lak;eT
EdlRtUv)anGnuBaØat. karRbkaselIs register minmankMhulGIVeTEteTaHCay:agNak¾edaycab;taMgBI
Bakü register RtUv)anmineGIeBIdwgBIcMnYnelIsb¤minGnuBaØatkarRbkas. ehIyvaminGacTTYl
Gas½ydæanrbs;GBaaØt register KμanKitdl;eTaHCaGBaaØtBitCa)anTukenAkñúg register.
karkMnt;karCak;lak;elIcMnYnnigRbePTrbs;GBaaØt register ERbRbYlBIm:asIunmYyeTAm:asIunmYyeTot.
7.4 karRKb;RKgTMhMkargar
GnuKmn_nigGBaaØtxageRkAEdlbegáIteLIgedaykmμviFI C mincMa)ac;RtUv)an compile enAeBlEtmYy.

GtßbTedImrbs;kmμviFIGacRtUv)anrkSaTukkñúg file epSg²KñaehIykar compile TukBImunGacRtUv)anykBI
library mkeRbI. kñúgcMeNamsMnYrEdlcab;GarmμN_KW :
etIkarRbkasRtUv)ansresrdUcemþcdUcenHGBaaØtRtUv)anRbkasCaFmμtakñúgkMLúgeBl compile?
etIkarcat;EcgRbkasy:agdUcemþcdUcenHRKb;EpñkTaMgGs;nwgRtUv)anP¢ab;edayRtWmRtUvenAeBlkmμviFI
RtUv)anykmkeRbI?
-64-
vCBk
etIrebobcat;EcgkarRbkasy:agdUcemþcdUcenHvamanRtwmEtkarcmøgEtmYyb:ueNÑaH?
etIrebobGBaaØtxageRkARtUv)ankMnt;tMély:agdUcemþc?
cUreyIgBiPakSaRbFanbTTaMgGs;enHedaycat;EcgkarKNnakmμviFIeLIgvijenAkñúg file eRcIn. dUcbBaða
EdlGnuvtþkarKNnaKWvatUceBkedIm,IbMEbkb:uEnþvaCakarBnül;Edll¥rbs;dMeNaHRsayEdlelIkeLIg
kñúgkmμviFIFM.
TMhMkargarrbs;eQμaHKWCaEpñkmYyrbs;kmμviFIxagkñúgEdleQμaHGacRtUv)aneRbI.sMrab;;GBaaØtsV½yRbvtþi
karRbkasenAeBlcab;epþImrbs;GnuKmn_ TMhMkargarKWCaGnuKmn_EdleQμaHRtUv)anRbkaskñúgGnuKmn_.
GBaaØt local éneQμaHdUcKñakñúgGnuKmn_xusKñaKWminmanTMnak;TMng. kardUcKñaKWBitR)akdrbs;)a:ra:EmRt
énGnuKmn_EdlmanenAkñúgRbsiT§iPaBGBaaØt local . TMhMkargarrbs;GBaaØtxageRkAb¤GnuKmn_eRkay
bMputBIcMnucEdlvaRtUv)anRbkaseTAdl;cugbBa©b;rbs; file RtUv)ancab;epþIm compile. ]TahrN_
RbsinebI main, sp, val, push, nwg pop RtUv)ankMnt;enAelI file kñúgeKalbMNgbgðajxagelI
EdlenaHCa
main() { ... }
int sp = 0;
double val[MAXVAL];
void push(double f) { ... }
bnÞab;mkGBaaØt sp nwg val GacRtUv)aneRbIkñúg push nwg pop y:agsamBaØedaykareGay

eQμaHBYkvakarRbkasminmanGVIeRcInCagenHEdlcaM)ac;eT. b:uEnþeQμaHTaMgenHminGaceRbIkñúg main,
minTaMg push nig pop pg.
mü:agvijeTotRbsinebIGBaaØtxageRkARtUv)ansMGagelIImuneBlvaRtUv)ankMnt;b¤RbsinebIvaRtUv)ankMnt;
kñúg file edImxus²KñaBIkEnøgmYyEdlvaRtUv)aneRbIenaHkarRbkas extern KWcMa)ac;. vamansar³
sMxan;kñúgkarsÁal;eGayc,as;rvagkarRbkasénGBaaØtxageRkAehIynigniymn½yrbs;va.
karRbkaspSaykmμsiT§irbs;GBaaØt (CadMbUgrbs;RbePT) niymn½yk¾bNþaleGaykarrkSaTukRtUv)an
kMnt;enAEpñkmçageTot. RbsinebIXøa
int sp;
double val[MAXVAL];
-65-
vCBk
elceLIgenAxageRkArbs;GnuKmn_NamYyBYkvaeGayniymn½yGBaaØtxageRkA sp nwg val
bNþaleGaykarrkSaTukkMnt;enAEpñkmçageTotehIyk¾eGayCakarRbkassMrab;;Epñksl;rbs; file
edImenH. müa:gvijeTotXøaTaMgenaH
extern int sp;
extern double val[];
Rbkas sMrab;;Epñksl;rbs; file edImEdl sp CacMnYnRbePT int ehIyEdl val CaRbePT

double array (EdlTMhMrbs;vaRtUv)ankMnt;enAkEnøgd¾éT) b:uEnþBYkvaminbegáItGBaaØtb¤bMrugTukkEnøg
rkSaTuksMrab;;BYkva. vaRtUvEtmanniymn½yEtmYyKt;énGBaaØtxageRkAkñúgcMeNamRKb; file

TaMgGs;EdlbegáIt kmμviFIedIm file epSgeTotGacrkSaTukkarRbkas extern edIm,IeRbIva.
(vak¾GacCakarRbkas extern enAkñúg file EdlpÞúkniymn½y) TMhM array
RtUvEt)ankMnt;Cak;lak;edayniymn½yb:uEnþkar RbkasGacdak;k¾)anmindak;k¾)anCamYy extern .
karkMnt;tMélcab;epþImrbs;GBaaØtxageRkAeFVICamYyEtniymn½yb:ueNÑaH. eTaHbIvamindUckarcat;Ecg
sMrab;;kmμviFIenHGnuKmn_ push nwg pop GacRtUv)ankMnt;enAkñúg file mYyehIyGBaaØt val nwg sp
)aneGayniymn½ynwgkMnt;tMélcab;epþImkñúg file mYyepSgeTot. bnÞab;mkniymn½yenHnigkarRbkas
nwgmansar³sMxan;edIm,IcgBYkvabBa©ÚlKña :
in file1:
extern int sp;
extern double val[];
void push(double f) { ... }
in file2:
int sp = 0;
double val[MAXVAL];
BIeRBaHkarRbkas extern enAkñúg file1 EdlepþkeTAmunehIyenAxageRkAniymn½yGnuKmn_ BYkva

GnuvtþeTARKb;GnuKmn_eTAmYysMnuMénkarRbkasRKb;RKan;sMrab;;RKb; file1. kar cat;EcgdUcKñaenHk¾Gac
nwgcaM)ac;RbsinebIkarkMnt;rbs; sp nwg val EdltamkareRbIrbs;BYkeKkñúg file mYy..
7.5 Structures
Structure KWCakarRbmUlpþúMGBaaØtmYyb¤eRcInGaceGaymanRbePTxus²)an CaRkumrYmKñaeRkameQμaHmYy
sMrab;;edaHRsaybBaðaedayRtwmRtUv. (Structure KWRtUv)anehA “records”
enAkñúgPasamYycMnYnCaBiess Pascal.) Structure CYykñúgkarRKb;RKgTinñn½yEdlsaMjaMú CaBiesskñúg

kmμviFIFM BIeRBaHvaGnuBaØateGayRkuménGBaaØtEdlmanTMnak;TMngKñaRtUv)ancat;TukCamYyÉktaCMnYs
eGayGBaaØtdac;BIKñaTMagmUl.
-66-
vCBk
]TahrN_Fmμtarbs; structure KWkt;RtabBa¢IR)ak;Ex : buKþlikmñak;RtUv)anBt’naedaysMnuMrbs; attribute
dUcCaeQμaH Gas½ydæan elxGtþsBaØaNb½Rt R)ak;Ex.l. mYycMnYnrbs;vaTMagenHGackøayCa
structure : eQμaHmansmasPaBCaeRcIn dUcCaGas½ydaænnigsUm,IEtR)ak;Ex. ]TahrN_mYyepSgeTot
CatYy:ag sMrab;; C mkBIRkahVic : cMnucKWCakUGredaen ctuekaNEkgKWCa1KUéncMnucehIybnþbnÞab;eTot.

main eFIVkarpøas;bþÚredaysþg;da ANSI KWedIim,IkMnt;karepÞrtMél structure – structures
GacRtUv)ancmøgehIy epÞreTA bBa¢ÚneTAGnuKmn_ ehIyepÞrtMéledayGnuKmn_. enaHRtUv)anKMaRTeday

compiler CaeRcInsMrab;;eRcInqñaMmkenH b:uEnþkmμsiT§i\LÚvKWRtUv)ankMnt;y:agCak;lak;. Structures nwg
arrays sV½yRbvtþik¾GacRtUv)ankMnt;tMélcab;epþIm.
GnuBaØateGayeyIgbegáIt structure smrmüsMrab;;RkahVic. Object RKWHKWcMnuc EdleyIgnwgsnμt;faman

kUGredaen x ehIynigkUGredaen y TaMgBIrCacMnYnKt;FmμCati. smasPaBBIrGacRtUv)anCMnYskñúg
structure EdlRbkasdUcenH :
struct point {
int x;
int y;
};
Keyword struct bgðajBIkarRbkas structure EdlCa list énkarRbkasbiTenAkñúg brace.

eQμaHmank¾)anGt;k¾)an)anehAfa structure tag GacenABIeRkayBakü struct (dUcCa point
enATIenH). eQμaH tag RbePTenHKWCa structure ehIyGaceRbIR)as;CabnþbnÞab;CaTRmg;xøIsMrab;;Epñkén
karRbkasenAkñúg braces.
eQμaHGBaaØtenAkñúg structure RtUv)anehAfaCasmaCik (members). Structure member b¤ tag
nwgGBaaØtFmμta (i.e.minEmnCasmaCik (non-member)) GacmaneQμaHdUcKñaedayminmanRcLMKña
edayBYkvaEtgEtRtUv)anEckdac;BIKñaedaybribT. CagenHeTAeTotsmaCikmaneQμaHdUcKañGacCYb
RbTHkñúg structure epSgBIKña eTaHCay:agNak¾edaybBaðaénRbePTmYynwgCaFmμtaeRbIeQμaHdUcKñasMrab;;
Et object EdlmanTMnak;TMngCitsñiT§b:ueNÑaH.
karRbkas struct kMnt;RbePTGtßn½y. Brace xagsþaMEdlbBa©b; list énsmaCikGacenABIeRkay
eday list rbs;GBaaØtdUcEtRbePTRKwHNamYy. enaHKW
struct { ... } x, y, z;
-67-
vCBk
CakarerobcMRsedogKña
int x, y, z;
enAkñúgcitþkarRbkasXøanimYy² x, y nWg z CaGBaaØténeQμaHRbePTnigmUlehtudkXøaCakarkMnt;mçag

BIBYkva.
karRbkas structure EdlminenABIeRkayeday list énGBaaØtminbMrugkEnøgrkSaTukvaRKan;EtCakar
BiBN’naxñatKMrUb¤RTgRTayrbs; structure. RbsinebIkarRbkasKWCa tag EteTaHCay:agNak¾eday tag
GacRtUv)aneRbIR)as;enAeBleRkaykúñgniymn½yéntMélefrrbs; structure. ]TahrN_karRbkas
point xagelI
struct point pt;
kMnt;GBaaØt pt EdlCa structure énRbePT struct point. Structure GacRtUv)ankMnt;tMél

cab;epþImedayniymn½yrbs;vaxageRkamCamYy list éntMélEdlkMnt; expression efrnimYy² :
struct maxpt = { 320, 200 };
Structure sVV½yRbvtþik¾GacRtUv)ankMnt;tMélcab;epþImedaykarepÞrtMélb¤edaykarehAGnuKmn_EdlepÞr
structure énRbePTxagsþaM. smaCikén structure Cak;lak;KWsMGagelI expression edaykarsagsg;
énTRmg;.
structure-name.member
RbmaNviFIsmaCikrbs; struture “.” P¢ab;eQμaH structure nigeQμaHsmaCik.

edIm,Ie)aHecjkUGredaenrbs;cMnuc pt ]TahrN_
printf("%d,%d", pt.x, pt.y);
Structures GacRtUv)anbnþKña)ankarbgðajmYyrbs;ctuekaNKWCacMnucBIrEdlkMnt;tamviCÄekaNRCug
pÞúyKña :
struct rect {
struct point pt1;
struct point pt2;
};
rect structure pÞúk structure point cMnYnBIr. RbsinebIeyIgRbkas screen Ca
struct rect screen; enaH
screen.pt1.x
-68-
vCBk
eyageTAelIkUGredaen x rbs; pt1 smaCikrbs; screen.
RbtibtþikarRtWmRtUvEtmYyb:ueNÑaHenAelI structure KWcmøgvab¤karepÞrtMéleTAvaCaÉkta karyk

Gas½ydæaneday & nigkareRbIsmaCikrbs;va. cmøgnigkarepÞrtMélrYmmankarepÞrGBaaØteTAGnuKmn_nig
karepÞrtMélBIGnuKmn_k¾dUcKñaEdr. Structures GacminRtUv)aneRbobeFob. Structure
GacRtUv)ankMnt;tMélcab;epþImeday list éncMnYntMélefr structure sV½yRbvtþik¾GacRtUv)ankMnt;tMél
edayXøaepÞrtMél.
GnuBaØateGayeyIgBinitüelI structure edaysresrGnuKmn_mYycMnYnedIm,IKUcMnucnigctuekaN Ekg.
many:agticNas;bIy:agsMrab;;eRbI Structure : dak;smasPaBpSMdac;²BIKñadak; structure TaMgmUl b¤dak;
pointer eTAva. nimYy²mancMnuclänigcMnucGaRkk;. GnuKmn_dMbUg makepoint nwgykcMnYnKt;BIr
ehIyepÞr point structure:

/* makepoint: make a point from x and y components */
struct point makepoint(int x, int y)
{
struct point temp;
temp.x = x;
temp.y = y;
return temp;
}
cMNaMfavaminmankarRcLMrvageQμaH argument nigsmaCikEdlmaneQμaHdUcKñatamBitkareRbIR)as;

eLIgvijéneQμaHbBa¢ak;BITMnak;TMng. makepoint \LÚvGacRtUv)aneRbIedIm,IkMnt;tMélcab;epþIm
structure ERbRbYlNamYy b¤edIm,Ipþl;eGay structure argument eTAGnuKmn_ :
struct rect screen;

struct point middle;
struct point makepoint(int, int);
screen.pt1 = makepoint(0,0);
screen.pt2 = makepoint(XMAX, YMAX);
middle = makepoint((screen.pt1.x + screen.pt2.x)/2,
(screen.pt1.y + screen.pt2.y)/2);
CMhanbnÞab;KWkarkMnt;rbs;GnuKmn_edIm,IeFIVRbmaNviFIKNitelIcMnuc ]TahrN_
/* addpoints: add two points */
struct addpoint(struct point p1, struct point p2)
{
p1.x += p2.x;
p1.y += p2.y;
return p1;
}
-69-
vCBk
enHCa argument TMagBIrnigepÞrtMélCa structure . eyIgbegáInsmasPaBenAkñúg p1 CaCageRbIGBaaØt

GciéRnþy_pÞal;edIm,IbBa¢ak;fa)a:r:aEmRt structure KWRtUv)anbBa¢ÚnedaytMélduUcGBaaØtepSg²eTot.
]TahrN_mYyepSgeTot GnuKmn_ ptinrect sakl,gfaetIcMnucenAxagkñúgCactuekaNEkg Edl
eyIgyl;RBmsnμt;faCactuekaNEkgrYmmanEpñkxageqVgnig)atb:uEnþminmanEpñkxagelInigxagsþaM :
/* ptinrect: return 1 if p in r, 0 if not */
int ptinrect(struct point p, struct rect r)
{
return p.x >= r.pt1.x && p.x < r.pt2.x && p.y >= r.pt1.y
&& p.y < r.pt2.y;
}
enHsnμt;factuekaNEkgEdl)anbgðajenAkñúgTRmg;sþg;daEdlkUGredaen pt1 tUcCagkUGredaen

pt2. GnuKmn_xageRkamRtUv)anFanafaepÞrCactuekaNEkgRtUv)anEbgEckCakñúgTRmg; :
#define min(a, b) ((a) < (b) ? (a) : (b))

#define max(a, b) ((a) > (b) ? (a) : (b))
/* canonrect: canonicalize coordinates of rectangle */
struct rect canonrect(struct rect r)
{
struct rect temp;
temp.pt1.x = min(r.pt1.x, r.pt2.x);
temp.pt1.y = min(r.pt1.y, r.pt2.y);
temp.pt2.x = max(r.pt1.x, r.pt2.x);
temp.pt2.y = max(r.pt1.y, r.pt2.y);
return temp;
}
7.6 kMnt;RbePTTinñn½yfμI
typedef k¾GacRtUv)aneRbICamYy structures. xageRkamenHKWCakarbegáItRbePTfμI gun EdlCa
RbePT struct gun nwgGacRtUv)ankMnt;CaFmμta :
typedef struct gun
{
char name[50];
int magazinesize;
float calibre;
} agun;
agun arnies={"Uzi",30,7};
enHCa gun enAEteFIVskmμPaB tag eTAnwg struct ehIyGacmank¾)anGt;k¾)an.

tamBitedaysareyIg)ankMnt;RbePTTinñn½yfμIvaminsUvCa)aneRbIR)as;eRcIneT agun CaRbePTTinñn½y
fμI. arnies KWCaGBaaØténRbePT agun EdlCaRbePT structure.
-70-
vCBk
C k¾GnuBaØateGayman arrays én structures:
typedef struct gun
{
char name[50];
int magazinesize;
float calibre;
} agun;
agun arniesguns[1000];
pþl;eGay arniesguns a 1000 guns . GacRtUv)aneRbIR)as;kñúgviFIxageRkam:

arniesguns[50].calibre=100;
pþl;eGay Arnie's gun cMnYn 50 a calibre of 100mm, nig

itscalibre=arniesguns[0].calibre;
kMnt; calibre én Arnie's gun dMbUg itscalibre .
-71-
vCBk
7.7 Unions
union CaGBaaØtEdlGacpÞúk (enAeBlxus²Kña) objects énTMhMxus²nigRbePT. C eRbIXøa union
edIm,IbegáIt unions ]TahrN_ :
union number
{
short shortnumber;
long longnumber;
double floatnumber;
} anumber
kMnt; union )anehAcMnYnnigtMélrbs;va)anehA anumber . number Ca union tag nwg

eFIVkúñgviFIdUc KñaCa tag sMrab;; structure.
smaCikGacRtUv)aneRbIkñúgviFIxageRkam :
printf("%ld\n",anumber.longnumber);
karbgðajy:agc,as;nUvtMélrbs; longnumber. enAeBl compiler C KWkMnt; memory sMrab;;

unions vanwgEtgEtbMrugTuk room RKb;RKan;sMrab;;cMnYnFMCageKbMput (enAkñúg]TahrN_xagelIenaHKW 8
bytes sMrab;; double). kñúgeKalbMNgEdlkmμviFIGacrkSadanénRbePTGBaaØt union

EdlRtUv)aneRbIenAeBlpþl;eGay vaCaFmμtaedIm,I)an structure (eday union bgáb;kñúgva)
nigGBaaØtEdl flags RbePT union : ]TahrN_ :
typedef struct
{ int maxpassengers;
} jet;
typedef struct
{ int liftcapacity;
} helicopter;
typedef struct
{ int maxpayload;
} cargoplane;
typedef union
{ jet jetu;
helicopter helicopteru;
cargoplane cargoplaneu;
} aircraft;
typedef struct
{ aircrafttype kind;
int speed;
aircraft description;
} an_aircraft;
-72-
vCBk
]TahrN_enHkMnt;Gtßn½yRKwH union ynþehaHEdlGacCaynþehaHRbtikmμ ]T§mÖacRk
b¤uynþehaHdWkTMnij. enAkñúg an_aircraft structure manRbePTsmaCikEdlbgðaj structure
Edl cab;epþImeFIVenAeBlEtmYy.
7.8 Coercion b¤ Type-Casting
C KWCaPasamYykñúgcMenamPasaBIrbIedIm,IGnuBaØat coercion EdlvaykcitþTukdak;elIGBaaØtmYyén
RbePTmYy CaRbePTmYyepSgeTot. C GnuBaØatkareRbIR)as;RbmaNviFI cast()enH. dUcenH

int integernumber;
float floatnumber=9.87;
integernumber=(int)floatnumber;
kMnt; 9 (CaEpñkRbPaKEdlminyk) eTAeGay integernumber.
nig:
int integernumber=10;
float floatnumber;
floatnumber=(float)integernumber;
kMnt; 10.0 eTAeGay floatnumber.

karbgçitbgçMGacRtUv)aneRbICamYYyRbePTTinñn½ysamBaØNamYyrYmmanRbePT char dUcenH :
int integernumber;
char letter='A';
integernumber=(int)letter;
kMnt; 65 ( ASCII code sMrab;; À') eTAeGay integernumber.

mYycMnYnRtUv)aneFIVedaysV½yRbvtþi – vaKWsMxan;CamYycMnYnKt;FmμCatiRtUvKña. c,ab;Edllä
typecasting
EdlyktamKW : RbsinebIkñúgkrNIsgS½y. kareRbIR)as;mYyepSgeTotKWeFIVkarEbgEckskmμPaBeGay

R)akdxN³EdlRtUvkar : RbsinebIeyIgmancMnYnKt; integer BIr internumber nig anotherint
ehIyeyIgcg;eqøIyCa float enaH :
e.g.
floatnumber =
-73-
vCBk
(float) internumber / (float) anotherint;
nwg)anplEckCacMnYnsniTan b¤cMnYnek,ós (float) .
7.9 RbePT Enumerate

RbePT enumerated pÞúknUv list éntMélefrEdlGacRtUv)anbBa¢ak;tMélcMnYnKt; integer .
eyIgGacRbkasRbePTnigGBaaØtdUcxageRkam.
enum days {mon, tues, ..., sun} week;
enum days week1, week2;
cMNaM : CamYy array eQμaH enumerated snÞsSn_dMbUgmantMél 0. dUcenH mon mantMél 0, tues
mantMél 1, nwgbnþbnÞab;. week1 nig week2 KWCaGBaaØt.
eyIgGackMnt;tMélepSg² :
enum escapes { bell = `\a',
backspace = `\b', tab = `\t',
newline = `\n', vtab = `\v',
return = `\r'};
eyIgk¾GacTat;ecaltMélcab;epþIm 0:
enum months {jan = 1, feb, mar, ......, dec};
enHvaRtUv)anGnuvtþn_Edl feb = 2 .l.

lMhat;
Exercise 7-1
cUrsresrkmμviFIeRbIRbePT enumerated EdlenAeBlpþl;eGaynUvkalbriecäTrbs;éf¶nwge)aHecjkar

briecäTéf¶Es¥kkñúgéf¶TI 31st January, ]TahrN_.
Exercise 7-2
cUrsresrkmμviFI database FmμtamYyEdlnwgrkSaTukCIvRbvtþiBisþardUcCa age, date of birth,
address .l..
WWWW±XXXX
-74-
vCBk
CMBUkTI 8
Pointers
-75-
vCBk
Pointer KWCaEpñkRKwHrbs;Pasa C .RbsinebIGñkminGaceRbIR)as; pointers )anRtWmRtUvenaHGñkCa
mUldæan)at;bg;TaMgGs;nUvPaBxøaMgnigbt;EbnEdlPasa C GnuBaØat. PaBGaf’kM)aMgrbs; C KWsßitenA
elIkareRbIR)as; pointers.
C eRbIR)as; pointers CaeRcIn : ehtuGIV?
vaKWCaviFIEtmYyedIm,IbgðajkarKNnamYycMnYn.
vaeFIVeGaykUdtUcnigmanRbsiT§iPaB.
vapþl;eGaynUv]bkrN_EdlmanRbsiT§iPaBxøaMg.
C eRbIR)as; pointer edayCak;c,as;CamYy :
Arrays,
Structures,
GunKmn_ (Functions)
cMnaM : Pointer RbEhlCaEpñkEdlBi)akyl;xaø Mg. karGnuvtþrbs;Pasa C KWxusKñabnþicbnþÜcxusBIPasa
d¾éTeTot.
8.1 GIVeTACa Pointer?
Pointer KWCaGBaaØtEdlpÞúkGas½ydæanenAkñúg memory rbs;GBØaatiNamYYy. eyIgGacman pointer
cMeBaHRbePTGBaaØtNamYy.
karI unary b¤ monadic & pþl;nUv “Gas½ydæanrbs;GBaaØt ”.
karI indirection b¤ dereference pþl;eGay “nUvGIVEdlmanenAkñúg object )ancg¥úleTAeday pointer”.
edIm,IRbkas pointer mYyCaGBaaØtRtUveFIV :
int *pointer;
cMnaM : eyIgRtUvP¢ab; pointer eTARbePTCak;lak;eyIgminGackMnt;Gas½ydæanrbs; short int eTA long

int, ]TahrN_.
BinitüelIRbsiT§iPaBkUdxageRkam :
int x = 1, y = 2;
-76-
vCBk
int *ip;
ip = &x;
y = *ip;
x = ip;
*ip = 3;
vamantMél edayBicarNaGIVEdlnwgbnþenAkñúgkMritm:asIunkñúg memory edIm,Iyl;faetI pointer

eFIVkary:agdUcemþc. rUb 8.1. snμt;CamunedIm,ICaKuNRbeyaCn_énkarBiPakSaEdlGBaaØt x sßitenAkñúg
memory TItaMg 100, y enATItaMg 200 nwg ip enATItaMg 1000.
cMnaM : pointer KWCaGBaaØtehIydUcenHtMélrbs;vaRtUv)anrkSaTukenAkénøgepSg. vaCaFmμtarbs;

tMél pointer EdlCatMélfμI.
rUb. 8.1 Pointer, Variables nig Memory \LÚvenHepÞrtMél x = 1 nig y = 2

Cak;EsþgeRbItMélTaMgenHenAkñúgGBaaØt. ip KWRtUv)anRbkasCa pointerkñúgRbePTCacMnYnKt;FmμCati
ehIykMnt;enAGas½ydæanrbs; x (&x). dUcenH ip )aneRbICamYytMél 100. bnÞab;mk
y )ankMnt;eTAnwgGVIEdlmanenAkñúg ip. enAkñúg]TahrN_enH ip kMBugEtcg¥úl;eTATItMag memory 100
– TItMagrbs; x. dUcenH y )ankMnt;eTAtMélrbs; x – EdlesμInig 1. eyIgeXIjehIyfa C
minBi)akkñúgkarkMnt;tMélénRbePTxusKña. dUcenHmanPaBRtwmRtUvCak;lak; (eTaHbIminTaMgGs;enaHmin

samBaØa) edIm,IkMnt;tMéledImrbs; ip eTA x. tMélrbs; ip enAxN³enHKWesμI 100.
cugbBa©b;eyIgGackMnt;tMéleTAnigGVIEdlmanenAkñúg pointer (*ip).
-77-
vCBk
sar³sMxan;: enAeBl pointer RtUv)anRbkasvamincg¥úleTAkEnøgNamYyeT.

GñkRtUvEtkMnt;eGayvacg¥úleTAkEnøgNamYymuneBlGñkeRbIva.
dUcenH>>>>>>
int *ip;
*ip = 100;
nwgbegáItnUvkMhus (kmμviFI KaMg!!).

kareRbIR)as;RtwmRtUvKW:
int *ip;
int x;
ip = &x;
*ip = 100;
eyIGaceFIVRbmaNviFIKNitviTüaelI pointer:
float *flp, *flq;
*flp = *flp + 10;
++*flp;
(*flp)++;
flq = flp;
cMnMa: eTAGBaaØtRbePTNamYyKWCaGas½ydæankñúg memory EdlvaCaGas½ydæancMnYnKt;

pointer
integer. Pointer BitR)akdminEmnCacMnYnKt;FmμCati integer. ehtuplEdleyIgP¢ab; pointer
mYyeTARbePTTinñn½ymYyKWvadwgcMnYn byte b:unμanEdlTinñn½yRtUv)anrkSaTuk. enAeBleyIgbEnßm cMnYn

pointer mYyeyIgbegáIn pointer edaymYy memory bøúk.
dUcenHsMrab;; pointer GkSr (character pointer) ++ch_ptr bUkbEnßm 1 byte eTAGas½ydæan.

sMrab;;cMnYnKt;FmμCati (integer) b¤cMnYnTsPaK (float) ++ip b¤ ++flp bUkEnßm 4 bytes eTAGas½ydæan.
BinitüelIGBaaØtek,ós (float variable (fl)) nig pointer eTA float (flp)
duUc)anbgðajkñúgrUb 8.2
-78-
vCBk
rUb 8.2 Pointer Arithmetic snμt;fa flp cg¥úleTA fl enaHRbsinebIGñkbegáIn pointer ( ++flp)
vapøas;bþÚrTItaMgbgðajeTAelI 4 bytes. RbsinebImüa:gvijeToteyIgbUkbénßm 2 eTA pointer
enaHvapøas;bþÚreTATItMag float 2 (float positions) i.e 8 bytes dUcbgðajkñúgrUb.
8.2 Pointer nig GnuKmn_ Functions
cUrBiinitü\LÚvelITMnak;TMngCitsñiT§rvag pointer nigEpñksMxan;epSg²eTotrbs; C . eyIgnwgcab;epþImCa

mYyGnuKmn_.
enAeBlPasa C bBa¢Ún argument eTAGnuKmn_vabBa¢ÚnBYkvaedaytMél (passes by value)..
mankrNICaeRcInenAeBleyIgcg;pøas;bþÚr argument EdlbBa¢ÚnenAkñúgGnuKmn_nigTTYltMélfμIEdl
RtT,b;eTAkEnøgedImvij1dgeTAGnuKmn_Edl)anbBa©b;.PasaepSgeToteFIVdUcenH (e.g.
var )a:ra:EmRtkñúg PASCAL). C eRbI pointer edayCak;c,as;kñúgkareFIVenH.

PasaepSgeTotk¾lak;kM)aMg karBitEdl pointer lak;bBa¢ak;karGunvtþrbs;vaenH.
viFIEdlRbesIrbMputkñúgkarsikSaenHKWRtUvemIl]TahrN_EdleyIgRtUvEtGacTTYl)annUvkarpøas;bþÚr)a:ra:
EmRt.
cUrBüayamsresrGnuKmn_edIm,Ipøas;bþÚreTAvijeTAmk?
karehAGnuKmn_Fmμta:
swap(a, b) nwgmindMeNIrkar.
Pointer pþl;eGaynUvdMeNaHRsay : bBa¢Ún address rbs;GBaaØteTAGnuKmn_ehIyeRbIr address
rbs;GnuKmn_.
dUcenHkarehA function kñúgkmμviFIrbs;eyIgnwgmanlkçN³EbbenH :
swap(&a, &b)
kUdkñúgkarpøas;bþÚrKWgayyl;Etmþg
-79-
vCBk
void swap(int *px, int *py)
{ int temp;
temp = *px;
/* contents of pointer */
*px = *py;
*py = temp;
}
eyIgGacepÞr pointer BI function.]TahrN_samBaØmYyKWenAeBlkarbBa¢Únrcnasm<½n§RtLb;.

typedef struct {float x,y,z;} COORD;
main()
{ COORD p1, *coord_fn();

/* declare fn to return ptr of COORD type */
....
p1 = *coord_fn(...);
/* assign contents of address returned */
....
}
COORD *coord_fn(...)
{ COORD p;
.....
p = ....;
/* assign structure values */
return &p;
/* return address of p */
}
enHeyIgepÞr pointer EdlGIVEdlmanenAkñúgvaKWRtUv)anebIky:agqab;rh½seTAkñúgGBaaØt. eyIgRtUvEteFIV

edayRtg;eq<aHeTAGBaaØtEdleyIg)ancg¥úleTACakEnøgNamYyrbs;GnuKmn_Edl\LÚv)anbBa©b;. vaman
n½yfaGas½ydæanTMenrKWTMenrehIyGacRtUv)ansresrCan;BIelI.
vanwgminRtUv)ansresrCan;edaypÞal;bnÞab;BIGnuKmn_ ha squit dUcenHmansuvtßPaB100PaKry.
8.3 Pointers nig Arrays
Pointers nig arrays KWmanTMnak;TMng;y:agsñiT§kñúgPasa C.
-80-
vCBk
karENnaM: KitelIFatu array Edl)ankMnt;lMdab;kñúgTItMag memory bnþbnÞab;Kña.
BinitüxageRkamenH:
int a[10], x;
int *pa;
pa = &a[0]; /* pa pointer to address of a[0] */
x = *pa; /* x = contents of pa (a[0] in this case) */
rUb 8.3 Arrays nig Pointers

edIm,IeTAkEnøgNamYyenAkñúg array (rUb 8.3) edayeRbIR)as; pointer eyIgGaceFIV :
pa + i = a[i]
Baküdas;etOn: minmankarBinitüRBMEdnsMrab;; arrays nig pointers dUcenHGñkGacgayRsYl

eroneTAputBI array memory nigsresrCan;elIGIVepSgeTot. EteTaHCay:agNak¾eday C
KWRbsb;CagkñúgkarP¢ab;TMnak;TMngrbs;varvag arrays nig pointers.
]TahrN_eyIgRKan;EtGacvay
pa = a;
CMnYs
pa = &a[0]
nig a[i] GacRtUv)ansresrCa *(a + i) .

i.e. &a[i] = + i.
eyIgk¾GacbgðajGas½ydæanrbs; pointer dUcenH :

pa[i] =*(pa + i).
-81-
vCBk
EteTaHCay:agNak¾eday pointers nwg arrays KWxusKña :
pointer CaGBaaØt. eyIgGacsresr pa = a nig pa++.
Array minEmnCaGBaaØt a = pa nig a++ KWminRtwmRtUv.

kardak;cUlenHKWmansar³sMxan;Nas;. R)akdfaGñkyl;va. eyIgnwgeXIjvaCaeRcIn.
eyIg\LÚvGacyl;rebobEdl array RtUv)anbBa¢ÚneTAGnuKmn_. enAeBl array
RtUv)anbBa¢ÚneTAGnuKmn_GVIEdl)anbBa¢ÚneTABitR)akdKWCaTItaMgFatudMbUgenAkñúg memory. dUcenH
strlen(s) = strlen(&s[0])
enHKWehtuplEdleyIgRbkasGnuKmn_:
int strlen(char s[]);
karRbkasesμIKñaKW : int strlen(char *s); edaysar char s[] char *s.
strlen() KWCa standard library function EdlepÞrRbEvgrbs; string mYYy.

cUremIlelIrebobEdleyIgsresrGnuKmn_ :
int strlen(char *s)
{ char *p = s;
while (*p != `\0);

p++;
return p-s;
}
\LÚvcUrsresrGnuKmn_edIm,Icmøg string mYyeTA string mYyepSgeTot. strcpy() Ca

standard library function EdleFIVkarcMlgenH.
void strcpy(char *s, char *t)
{ while ( (*s++ = *t++) != `\0);}
enHkareRbI pointers nigkarkMnt;tMél.

cMNaM : kareRbIR)as;Xøa Null CamYYy while.
8.4 Arrays én Pointers
eyIgGacman array Ca pointer edaysar pointer CaGBaaØt.

]TahrN_kareRbIR)as; :
-82-
vCBk
XøaxøIrbs;GtßbTénRbEvgxusKña.
cMnaM : GtßbT (text) minGacRtUv)anpøas;bþÚrb¤eRbobeFobenAkñúgRbtibtþikarEtmYYy.
Arrays én CaRbePTTinñn½yEdlbgðajfanwgéllkedaHRsayedaymanRbsiT§iPaB
Pointers
nigedaysmrmüCamYYyRbEvg XøaGkSrrbs;GBaaØt.
etIeyIgeFIVvaedayrebobNa?:
rkSaGkSrFMcugbnÞat;eTAcugbnÞat; (end_to_end) kúñg char array FMmYy (rUb. 8.4). \n
nwgcuHbnÞat;.
rkSa pointer kñúg array epSgKñaEdl pointer nimYy²cg¥úleTAGkSrTImYyénbnÞat;fμInimYy².
eRbobeFobbnÞat;BIredayeRbIGnuKmn_ strcmp() én standard library function.
RbsinebIbnÞat;BIrxuslMdab;cUrbþÚr (swap) pointer eTACa pointer array (minEmnCaGtßbT).
rUb. 8.4 Arrays én Pointers (]TahrN_kartMerob String (String Sorting Example) )

kareRbI pointer array GacbM)at;ecal
rebobRKb;RKgkarrkSaTukEdlsμúksμaj
karhYsmaDénkarpøas;bþÚrbnÞat;
8.5 array eRcInvimaRt nig pointers
eyIgKYrKitBIr array eRcInvimaRtkñúgviFIepSgKñakñúgPasa C:

-83-
vCBk
array BIrvimaRtKWtamBitCa array mYyvimaRtEdlFatumYy²rbs;vaCa array xøÜnvapÞal;
ehtuenHeKsresr
a[n][m]
Fatu array RtUv)anrkSTukCaCYr².

enAeBleyIgbBa¢Ún array BIrvimaRteTAGnuKmn_eyIgRtUvEtkMnt;cMnYnénCYrQrnigcMnYnénCYredkEdl
minTak;TgKña.
CafμImþgeTotehtuplsMrab;; pointer enHKW : C RtUvkardwgCacMa)ac;nUvcMnYnCYrQrb:unμankñúgeKal
bMNgEdlvaGacelatBICYredkmYyeTACYredkmYyeTotkñúg memory.
BinitüelI int a[5][35] RtUv)aneTAeGayGnuKmn_:
eyIgGacsresr:
f(int a[][35]) {.....}
or even:
f(int (*a)[35]) {.....}
eyIgRtUvkarrgVg;Rkck (*a) edaysar [] manGaTiPaBx<s;Cag *

dUcenH :
int (*a)[35]; Rbkas pointer Ca array én 35 ints.
int *a[35]; Rbkas array Ca 35 pointerén ints.
\LÚvcUrRbeLkemIl (PaBRbsb;) xusKñarvag pointers nig arrays . Strings
KWCakarGnuvtþn_samBaØrbs;vaenH.
Binitü: char *name[10];
char Aname[10][20];
eyIgGacsresredayRtWmRtUv name[3][4] nig Aname[3][4] kñúg C.

EteTaHCay:agNak¾eday
-84-
vCBk
Aname KWBitCa 200 Fatu 2D char array.
kareRbIR)as;FatueTAtam 20*row + col + base_address kñúg memory.
name man 10 Fatu pointer.
cMnaM: RbsinebI pointer nimYy²kñúg name RtUv)ankMnt;eGaycg¥úleTA array 20 FatuenaHnwg 200 chars
RtUv)ankMnt;Ek,r (+ 10 Fatu).
plRbeyaCn_énGkSrKWfa pointernimYy²cg¥úleTA array EdlmanRbEvgxus²Kña.
Binitü:
char *name[] = { “no month”, “jan”,”feb”, ... };
char Aname[][15] = { “no month”, “jan”,”feb”, ... };
rUb. 8.5 Arrays BIrvimaRtnig Arrays én Pointers

8.6 Static Initialisation én Pointer Arrays
karkMnt;tMélcab;epþImrbs; arrays én pointers KWCakarGnuvtþEdll¥sMrab;; static array xagkñúg.

some_fn()
{ static char *months = { “no month”,”jan”, “feb”, ...};
}
static rkSaTuk bit rbs;)a:ra:EmRtpÞal;kñúg memory.
-85-
vCBk
8.7 Pointersnig Structures
TaMgenHKWgayyl;niggaykMnt;Gtßn½y. BinitüxageRkam:
struct COORD {float x,y,z;} pt;
struct COORD *pt_ptr;
pt_ptr = &pt; /* assigns pointer to pt */
karI Æ GnuBaØateGayeyIgeRbI member rbs; structure Edl)ancg¥úleday pointer:

pt_ptrÆx = 1.0;
pt_ptrÆy = pt_ptrÆy - 3.0;
]TahrN_: Linked Lists

typedef struct { int value;
ELEMENT *next;
} ELEMENT;
ELEMENT n1, n2;
n1.next = &n2;
rUb. 8.6 TMnak;TMng Node BIr cMnaM: eyIgGacRbkas next Ca pointer eTAFatu.
eyIgminGacmanFatuénRbePTGBaaØtdUcEdlnwgkMnt;niymn½y recursive EdlminRtUv)anGnuBaØat.
eyIgRtUv)anGnuBaØateGaykMnt; pointer sMGageday 4 bytes KWtMnt;Ek,rsMrab;; pointer
NamYy.
kUdxagelIP¢ab; node n1 eTA n2 (rUb. 8.6) eyIgnwglMGitenAbBaðaenHenAkñúgemeroneRkay.
BinitükarsresrkmμviFIedIm,Irab;karCYbRbTHén C keyword nimYy². eyIgRtUvkar array én character
strings edIm,IpÞúkeQμaH nig array én integers sMrab;;karrab;. lT§PaBEdlGacmYyKWedIm,IeRbI array
dUcKñaBIr keyword nig keycount, dUckñúg

char *keyword[NKEYS];
-86-
vCBk
int keycount[NKEYS];
b:uEnþkarBitNas;Edl arrays RsbesñIkarcat;EcgxusKña array én structure . BakünimYy²KWCaKU :

char *word;
int cout;
nigman array CaKU. karRbkasrcnasm<½n§

struct key {
char *word;
int count;
} keytab[NKEYS];
karRbkasRbePTrcnasm<½n§ key kMnt; array keytab énrcnasm<½n§énRbePTenHehIykMnt;Ek,rkar

rkSaTuksMrab;;va. FatunimYy²sMrab;; array KWCa structure. enHGacRtUv)ansresr
struct key {
char *word;
int count;
};
struct key keytab[NKEYS];
edaysar structure keytab pÞúktMélGacERbRbYlrbs;eQμaH vagayRsYlbMputedIm,IbegáItGBaaØtxag

kñúgehIykMnt;tMélcab;epþImvaEtmþgnigsMrab;;RKb;eBlEdlvaRtUv)ankMnt;.
karkMnt;rcnasm<½n§cab;epþImdMbUgKWRsedogeTAnwgGIVmYydMbUg - niymn½yRtUv)ankMnt;tameday
bBa¢Irbs;GñkkMnt;enAkñúg brace Edl)anbiTCit :

struct key {
char *word;
int count;
} keytab[] = {
"auto", 0,
"break", 0,
"case", 0,
"char", 0,
"const", 0,
"continue", 0,
"default", 0,
/* ... */
"unsigned", 0,
"void", 0,
"volatile", 0,
"while", 0
};
GñkkMnt;tMéldMbUgRtUv)ankt;CaKUedayTTYlxusRtUvelI structure member . vaKYrCak;lak;CagenHkñúg

karbiTGñkcab;epþImkMnt;sMrab;;CYrnimYy²b¤ structure enAkñúg brace dUcCa
{ "auto", 0 },
-87-
vCBk
{ "break", 0 },
110
{ "case", 0 },
...
b:uEnþ brace kñúg brace KWminmansar³sMxan;enAeBlGñkkMnt;tMélcab;epþImCaGBaaØtFmμtab¤GkSr string
ehIyenAeBlGIVTaMgGs;RtUv)anbgðaj.
8.8 eRKaHfñak; Pointer Fmμta
enHeyIgnwgelIkykmknUvkMhusFmμtaBIrEdlbegáIteday pointer.
cMNaMkarepÞrtMél pointer eTA memory address munkareRbIR)as;va.
int *x;
*x = 100;
eyIgRtUvkar physical location GBa©wg: int y;

x = &y;
*x = 100;
vaRbEhlCalM)akedIm,IbBaÄb;. minEmnCakMuhusrbs; COMPILER eT. x
GacmanGas½ydæanécdnüenAeBlkMnt;tMéldMbUg.
9 TisedAminRtwmRtUv (Illegal direction)
snμt;faeyIgmanGnuKmn_ malloc() EdlBüayamedIm,IkMnt;karbt;Ebn memory
(enAeBldMeNIrkar) nigepÞr pointer eTAbøúkrbs; memory Edl)anRtUvkarRbsinebIC½yCMnHb¤ NULL
pointer ebImindUcenHeT.
char *malloc() -- standard library function ( eXIjenAelIkeRkay).

cUrkMnt; pointer: char *p;
Binitü:
*p = (char *) malloc(100); /* request 100 bytes of memory */
*p = `y';
kMhusxagelIenH. etICaGIV?
minman * kñúg
-88-
vCBk
*p = (char *) malloc(100);
Malloc epÞr pointer. k¾dUc p mineFIVkarcg¥úleTAGas½ydæanNamYy.

kUdRtImRtUvnwgCa:
p = (char *) malloc(100);
RbsinebIkUd)anEttRmUvbBaðamYyKWRbsinebIminman memory RKb;RKan;nig p KW NULL .

dUcenHeyIgminGacsresr : *p = `y';.
kmμviFI C Edll¥nwgRtYtBinitüsMrab;;bBaðaenH :
p = (char *) malloc(100);
if ( p == NULL)
{ printf(“Error: Out of Memory \n”);
exit(1);
}
*p = `y';
lMhat;
Exercise 8-1
sresrkmμviFI C edIm,IGan array énRbePTNamYyedayeRbI pointer . sresrkmμviFI C
edImI,bBa©ÚltMéleTA array nigedIm,IrktMélCak;lak;.

Exercise 8-2
sresrkmμviFIedIm,IrkcMnYnrbs;eBlevlaEdl)anpþl;eGaynUvBakü(i.e. string xøI²) CYbRbTHenAkñúg

RbeyaK (i.e.string Evg !).
GanTinñn½yBIsþg;dae)aHbBa©Úl. bnÞat;dMbUgCaBaküEtmYy EdlenABIeRkayedayGtßbTTUeTAenAbnÞat;TI
BIr. GanbnÞat;TaMgBIrrhUtdl;GkSr newline ehIyEnßmkarbBa©b; null enABImunkarRbtibtþi.
CaTUeTAkare)aHecjKYrCa :
The word is "the".
The sentence is "the cat sat on the mat".
The word occurs 2 times.
-89-
vCBk
Exercise 8-3
sresrkmμviFIEdlTTYlykbIGBaaØt (a, b, b) tamlMdab;)a:ra:EmRtnigqøas;tMélEdlrkSarTukdUcenaH

tMéleTACa b, eTA c nig c eTA a.
WWWW±XXXX
-90-
vCBk
CMBYkTI 9
Dynamic Memory Allocation and Dynamic
Structures
-91-
vCBk
karkMnt;kEnøgedaybt;EbnKWCalkçN³EdlläEtmYyKt;rbs;Pasa C (kñúgcMenamPasa high level ).
vaCYyeyIgedIm,IbegáItRbePTTinñ½ynigrcnasm<½n§énTMhMnigRbEvgNamYyedIm,IsmnigkmμviFIrbs;eyIgRtUv
karkñúgkarsresrkmμviFI.
eyIgnwgkarGnuvtþEdlsamBaØBIrenH:
dynamic arrays
dynamic data structure e.g. linked lists
9.1 Malloc, Sizeof, and Free
GnuKmn_ malloc RtUv)aneRbIy:agsamBaØbMputedIm,IBüamcab;ykcMENkbnþbnÞab;rbs; memory .

vaRtUv)ankMnt;eday:
void *malloc(size_t number_of_bytes)
enaHKWedIm,IniyayfavaepÞr pointer énRbePT void * E;dl)ancab;epþImkñúg memory

éncMENkbMrugTukrbs;TMhM number_of_bytes. RbsinebI memory minGacRtUv)ankMnt; NULL
pointer RtUv)anepÞr.
edaysar void * RtUv)anepÞrlkçN³sþg;da C Edl pointer enHGacRtUv)anpøas;bþÚreTARbePTNa

mYy. RbePT argument size_t RtUv)ankMnt;kñúg stdlib.h nigRbePT unsigned .
dUcenH:
char *cp;
cp = malloc(100);
Büayamyk 100 bytes nigkMnt;Gas½ydæancab;epþImeTA cp.

dUcKñaenHEdrvaCaFmμtaedIm,IeRbI sizeof()GnuKmn_edIm,IkMnt;cMnYnCak;lak;rbs; byte:
int *ip;
ip = (int *) malloc(100*sizeof(int));
C compiler mYycMnYnGacRtUvkarkat;elxrbs;RbePTEdlpøas;bþÚr. (int *) mann½yfakarbgçitbgçM

eGayeTACa pointer integer. karbgçitbgçMedIm,IEkrtMrUvRbePT pointer KWmansar³sMxan;
Nas;edIm,IeFIVeGayR)akdfaRbmaNviFIBiCKNit pointer KWGacRtUv)anKNna edayRtwmRtUv.
édayxøÜn´pÞal;eRbIvaCaGtßn½yénkareFIVeGayR)akdfa´BitCaRtwmRtUvkñúgkarsresrkUdrbs;éhIy
eRbIkarkat;ecalelxmYycMnYyRKb;eBl.
-92-
vCBk
vaCakarGnuvtþRbesIrmYyedIm,IeRbI sizeof() eTaHCaGñkdwgBITMhMBitEdlGñkcg;)an— vabegáIteLIg
sMrab;;kUd (code) ÉkraCü. sizeof GacRtUv)aneRbIedIm,IkMnt;TMhMrbs;RbePTTinñn½yNamYyb¤
structure. karpþl;CaFmμtamYyénRbePTTinñn½yTaMgBIrenHCa argument rbs;GnuKmn_.
dUcenH:
int i;
struct COORD {float x,y,z};
typedef struct COORD PT;
sizeof(int), sizeof(i),
sizeof(struct COORD) and
sizeof(PT) are all ACCEPTABLE
kñúgEpñkxagelIeyIgGaceRbITMnak;TMngrvag pointers nig arrays edIm,IsnSM memory sMrab; array FM²KW

eyIgeFIVdUcCa:
ip[0] = 100;
b¤
for(i=0;i<100;++i) scanf(“%d”,ip++);
enAeBlGñk)anbBa©b;kareRbIR)as;cMENkrbs; memory GñkCanic©CakalKYrEt free() va.
enHvaGnuBaØateGay memory rYcputedIm,IGaceGayeRbImþgeTotRbEhlCakarBitsMrab;;karehA
malloc() .
GnuKmn_ free() TTYlyk pointer Ca argument ehIyTMenr memory Edl pointer cg¥úleTAelI.
9.2 Calloc and Realloc
manGnuKmn_kMnt;TItaMg memory BIrbEnßmeTot Calloc() nig

Realloc().KMrUrbs;vamanTRmg;dUc xageRkam:
void *calloc(size_t num_elements, size_t element_size};
void *realloc( void *ptr, size_t new_size);
Malloc minkMnt;karcab;epþIm memory (eTAsUnü) enAkñúgviFINamYy. RbsinebIGñkcg;cab;epþIm

memory enaHGñkeRbI calloc. Calloc manPaBxusKñabnþicbnþÜcedaykarKNnaGs; memory
eRcInCagb:uEnþvaRtUv)aneRbICajwkjab; gayRsYlCag malloc. bEnßmelIenHcMNaMPaBxusrvagvaküsm<½n§

calloc nig malloc EdlkñúgenaH calloc ykcMnYnFatuEdlcg;)an num_elements nig
element_size, element_size CaGBaaØtpÞal;xøÜn.
dUcenHedIm,IkMnt;cMnYnKt;FmμCati intteger 100 FatuEdlFatuTaMgGs;RtUv)ankMnt;tMélcab;epþImeday

sUnü:
-93-
vCBk
int *ip;
ip = (int *) calloc(100, sizeof(int));
Realloc CaGunKmn_Edlcg;pøas;bþÚrTMhMrbs;karkMnt;bøúk memory BIrmun. TMhMfμIGacFMCagb¤

tUcCagRbsinebIbøúkRtUv)ankMnt;FMCagenaHtMélcas;enAEtrkSatMélminpøas;bþÚrnig memory RtUv)an
bEnßmeTAxagcugrbs;bøúk. RbsinebITMhMRtUv)antUcCagkarkSaTuktMélEdlmanenAkñúgKWminRtUv)anpøas;
bþÚr.
RbsinebITMhMbøúkedImminGacRtUv)ankMnt;eLIgvijenaH realloc nwgBüayamkMnt;bøúkfμIrbs; memory
ehIynwgcmøgtMélEdlmanenAkñúgbøúkcas;. cMNaM pointer fμI (rbs;tMélepSgKña)
nwgRtUv)anepÞrCabnþbnÞab;. GñkRtUvEteRbItMélfμI. Rbsin memory fμIminGacRtUv)ankMnt;eLIgvijenaH
realloc epÞrtMél NULL.
dUcenHkarpøas;bþÚrTMhMrbs; memory én *ip pointer xagelIbøúk array én 50 cMnYnKt;FmμCatiCMnYs

100 eFIVy:agsamBaØ :
ip = (int *) calloc( ip, 50);
9.3 Linked Lists

\LÚvcUrRtLb;eTA]TahrN_ linked list rbs;eyIg :
typedef struct { int value;
*next;
} ELEMENT;
\LÚveyIgGacsakBRgIkbBa¢IDINamic (list dynamically):

link = (ELEMENT *) malloc(sizeof(ELEMENT));
vanwgkMnt; memory sMrab;;TMnak;TMngfμI. RbsinebIeyIgcg;erobcM memory BI pointer eRbIGnuKmn_

free() :
free(link)
emIlkmμviFI]TahrN_ (queue.c) xageRkamnigsakl,gGnuvtþeGay)aneRcInCagenH.
9.4 Full Program: queue.c
queue KWCakrNIRKwHy:agsMxan;rbs; linked list EdlenAelIFaturbs;Tinñn½ycUlrYmenAkñúgbBa¢I (list)
enAcugxageqVgehIycakecjkñúglMdab;KMrUenAcugmçagepSgeTot.
kMnt;RtaeBjeljsMrab;; queue.c KWdUcxageRkamenH:
/* */
/* queue.c */
/* Demo of dynamic data structures in C */
#include <stdio.h>
-94-
vCBk
#define FALSE 0
#define NULL 0
typedef struct {
int dataitem;
struct listelement *link;
} listelement;
void Menu (int *choice);
listelement * AddItem (listelement * listpointer, int data);
listelement * RemoveItem (listelement * listpointer);
void PrintQueue (listelement * listpointer);
void ClearQueue (listelement * listpointer);
main () {
listelement listmember, *listpointer;
int data,choice;
listpointer = NULL;
do {
Menu (&choice);
switch (choice) {
case 1:
printf (“Enter data item value to add “);
scanf (“%d”, &data);
listpointer = AddItem (listpointer, data);
break;
case 2:
if (listpointer == NULL)
printf (“Queue empty!\n”);
else
listpointer = RemoveItem (listpointer);
break;
case 3:
PrintQueue (listpointer);
break;
case 4:
break;
default:
printf (“Invalid menu choice - try again\n”);
break;
}
} while (choice != 4);
ClearQueue (listpointer);
} /* main */
void Menu (int *choice) {
char local;
printf (“\nEnter\t1 to add item,\n\t2 to remove item\n\
\t3 to print queue\n\t4 to quit\n”);
do {
local = getchar ();
if ((isdigit (local) == FALSE) && (local != ‘\n’)) {
printf (“\nyou must enter an integer.\n”);
printf (“Enter 1 to add, 2 to remove, 3 to print, 4 to quit\n”);
}
} while (isdigit ((unsigned char) local) == FALSE);
*choice = (int) local - ‘0’;
}
listelement * AddItem (listelement * listpointer, int data) {
-95-
vCBk
listelement * lp = listpointer;
if (listpointer != NULL) {
while (listpointer -> link != NULL)
listpointer = listpointer -> link;
listpointer -> link = (struct listelement *) malloc (sizeof
(listelement));
listpointer -> link = NULL;
listpointer -> dataitem = data;
return lp;
}
else {
listpointer = (struct listelement *) malloc (sizeof (listelement));
listpointer -> link = NULL;
listpointer -> dataitem = data;
return listpointer;
}
}
listelement * RemoveItem (listelement * listpointer) {

listelement * tempp;
printf (“Element removed is %d\n”, listpointer -> dataitem);
tempp = listpointer -> link;
free (listpointer);
return tempp;
}
void PrintQueue (listelement * listpointer) {

if (listpointer == NULL)
printf (“queue is empty!\n”);
else
while (listpointer != NULL) {
printf (“%d\t”, listpointer -> dataitem);
}
printf (“\n”);
}
void ClearQueue (listelement * listpointer) {

while (listpointer != NULL) {
listpointer = RemoveItem (listpointer);
}
}
Exercises
Exercise 9-1
sresrkmμviFIEdlGancMnYnEdlR)ab;cMnYnKt;FmμCatimanb:unμanRtUv)anrkSaTukkñúg array begáIt array
edIm,ItMrimTMhMBitR)akdrbs;Tinñn½yehIybnÞab;mkGancMnYnTaMgenHeTAkñúg array.
-96-
vCBk
Exercise 9-2
sresrkmμviFIedIm,IGnuvt linked list dUcEdl)anBiBN’naenAkñúgkMnt;cMNaMxagelI.

Exercise 9-3
sresrkmμviFIedIm,ItMeroblMdab;éncMnYnedayeRbIR)as; binary tree (edayeRbI Pointers). Binary tree

KWCarcnasm<½n§ tree manRtwmEtBIrEmk (Gac) BIExñg (node) nimYy² (rUb 9.1).
EmknimYy²enaHbgðajkarsMercxusb¤RtUv.
edIm,ItMerobcMnYnedaysamBaØkMnt;EmkxageqVgedIm,IykcMnYnticCagcMnYnExñg (node) ehIyEmkxagsþaM
ykcMnYnepSgNamYy (FMCagb¤esμIrnig). edIm,I)an list EdlrkSaTuksamBaØmYyEsVgrk tree enAkñúgKMrU
depth first .
rUb. 9.1 ]TahrN_rbs;tMerob binary tree kmμviFIrbs;GñkKYrCa: begáItrcnasm<½n§ binary tree .

begáItGnuKmn_sMrab;;karTajyk tree mkpÞúkedaysmrmü. GancMnYnKt;FmμCati integer
bBa©b;edaysUnü. tMerobcMnYneTACacMnYntamlMdab;ekIn. e)aHecjlT§pltMélEdl)antMerob
e)aHecj10cMnYnkñúg1bnÞat;EvgtamEdlGaceFIV)an.
CaFmμtakare)aHecjGacCa
The sorted values are:
2 4 6 6 7 9 10 11 11 11
15 16 17 18 20 20 21 21 23 24
WWWW±XXXX
-97-
vCBk
CMBYkTI 10
The C Preprocessor
-98-
vCBk
karehAeLIgvijénRbtibtþikarCaCMhanTImYyenAkñúgdMNak;kar compile kmμviFI C – lkçN³enHKWmanEt
mYyKt;edIm,I C compilers.
Preprocessor eRcInb¤ticpþl;eGayPasarbs;vapÞal;EdlGacCa]bkrN_EdlmanGnuPaBxøaMgeTAGñk
sresrkmμviFI. karehAmþgeTotEdlRKb; preprocessor directives b¤ commands TaMgGs;cab;
epþImeday #.
kareRbIR)as; preprocessor manGtßRbeyaCn_edayvaeFIVeGay:
kmμviFIgayRsYlCagedIm,IGPivDÆn_
gayRsYlCagedIm,IGan
gayRsYledIm,IEkERb
C kUdGacykeTAeRbIkñúgm:asIunepSg²Kña.
dUcKñaEdr preprocessor k¾GnuBaØateGayeyIg customise Pasa. ]TahrN_edIm,ICMnYs { ... }
GñkkMnt;RBMEdnbøúkXøaeday PASCAL dUceTAnwg begin ... end eyIgGaceFIV:

#define begin {
#define end }
kñúgkMLúgeBlkarbkRsayRKb;karCYbRbTHrbs; begin nig end TTYlkarCMnYsedayPaBRtYvKña

{ b¤ } nigdUcenHdMNak;karbkRsay C bnþbnÞab;mindwgPaBxusKñaNamYy.
10.1 #define
eRbIedIm,ItMnt;tMélefrb¤karykmkCMnYs macro NamYy. eRbIdUcxageRkam:

#define <macro> <replacement name>
]TahrN_
#define FALSE 0
#define TRUE !FALSE
eyIgGackMnt;GnuKmn_tUcedayeRbI #define. ]TahrN_ max . rbs;BIrGBaaØt:

-99-
vCBk
#define max(A,B) ( (A) > (B) ? (A):(B))
? KWCakarI ternary enAkñúg C.

10.2 #include
Directive rab;bBa©Úl file eTAkñúgkUd.

vamanTRmg;GaceRbI)anBIr:
#include <file>
b¤
#include “file”
<file> R)ab; compiler eGayemIlkEnøgEdlRbB½n§rab;bBa©Úl (system include

files) file RtUv)aneFIVeLIg. CaFmμtaRbB½n§ UNIX rkSaTuk file enAkñúg
\usr\include\directory.
“file” rkemIl enAkñúg directory EdlkMBugsßitenA(EdlkEnøgkmμviFIRtUv)andMeNIrBI)

file
RtUv)anrab;bBa©Úl file CaFmμtapÞúkkmμsiT§i C nigkarRbkasBI header file nigminEmnCakUd

(algorithmic) C . ]TahrN_:
#include <stdio.h>
#include <math.h>
#define MIN -100000
void main()
{
int a1, a2, a3 ;
printf("Input number:"); scanf("%d", &a1);
a2= a1+MIN;
a3=abs(a2);
printf("a1=%d, a2=%d, a3=%d \n", a1, a2, a3);
}
10.3 #undef and #if Conditional inclusion
XøabBa¢ar undef minkMnt; macro. macro RtUvEtminkMnt;munkarcab;epþImkMnt;eLIgvijnUvtMélxusKña.

#if vaytMél expression cMnYnKt;EdlGacERbRbYl. GñkEtgEtRtUvkarcMa)ac; #endif
edIm,IbBa©b;cugrbs;Xøa.
-100-
vCBk
eyIgGacman else.l. k¾dUcCakareRbIR)as; #else nig #elif , else if.
XøabBa¢armYyepSgeToteRbI #if KWCamYy:
#ifdef
-- if defined and
#ifndef
-- if not defined
mansar³RbeyaCn_CaeRcInsMrab;;karRtYtBinitüfaetI macros RtUv)ankMnt;b¤eT – RbEhlmkBI module

kmμviFIxusKñanig header file .
]TahrN_ edIm,IkMnt;TMhMcMnYnKt;FmμCatisMrab;;kmμviFI C EdlGacpøas;bþÚr)anrvag TurboC (on
MSDOS) nig Window(b¤epSgeTot) Operating systems. karehAeLIgvijEdl TurboC eRbI 16
bits/integer nig Window 32 bits/integer.
snμt;faRbsinebI TurboC kMBugdMeNIrkar macro TURBOC nwgRtUv)ankMnt;.

dUcenHeyIgRKan;EtRtUvkarRtYkBinitüsMrab;;dMeNIkarenH:
#ifdef TURBOC
#define INT_SIZE 16
#else
#define INT_SIZE 32
#endif
CamYy]TahrN_mYyepSgeTotRbsinebIkmμviFIdMeNIkarenAelIm:asIun MSDOS eyIgcg;rab;bBa©Úl file

msdos.h ebImindUcenHeT default.h file. macro SYSTEM KWRtUv)ankMnt;edayRbePT
Operating system dUcenHBinitüelIenH:
#if SYSTEM == MSDOS

#include <msdos.h>
#else
#include “default.h”
#endif
10.4 Other Preprocessor Commands
manGBaaØt preprocessor directives d¾éTBIrbIeTot:

#error
text of error message -- begáItsarkMhus compiler smrmü

-101-
vCBk
#ifdef OS_MSDOS
#include <msdos.h>
#elifdef OS_UNIX
#include ``default.h''
#else
#error Wrong OS!!
#endif
# line
cMnYn "string" R)ab; preprocessor EdlcMnYnCacMnYnbnÞab;rbs;bnÞat;énkare)aHcUl.

"string" KWGacmank¾)anminmank¾)annwgeQμaHbnÞat;bnÞab;rbs;karbBa©Úl. enHCanic©CakalRtUv
)aneRbIR)as;Cajwkjab;CamYykmμviFIEdlbkERbPasaepSg²eToteTAPasa C. ]TahrN_sarkMhus
begáIteday C compiler GacsMGagelIeQμaH file nigcMnYnbnÞat;rbs; source file
edImCMnYseGay intermediate C (RtUv)anbkERb) source file .
Exercises
Exercise 10-1
kMnt; preprocessor macro swap(t, x, y) Edlnwgpøas;bþÚr argument BIr x nig y
rbs;RbePTEdl)aneGay t.
Exercise 10-1
kMnt; preprocessor macro edIm,IeRCIserIs:

bit sMxan;cugeRkayBI unsigned char
TI n (karsnμt;sMxan;cugeRkayKW 0) bit BI unsigned char.
WWWW±XXXX
-102-
vCBk
CMBUkTI 11
C, UNIX and Standard Libraries
-103-
vCBk
manTMnak;TMngsñiT§sñalCaxøaMgrvag C nig operating system CaeRcInEdldMeNIrkarkmμviFI C rbs;eyIg.
esÞIrEt UNIX operating system TaMgmYlRtUv)ansresredayPasa C. emeronenHnwgBinitüelIrebob
C nig UNIX RbTak;RbTgKña.
eyIgRtUvEteRbI UNIX edIm,IrkSaTMhM file rbs;eyIg BinitüepÞogpÞat;, compile nig run programs .l..
EteTaHCay:agNak¾eday UNIX KWmansar³sMxan;eRcInCagenH:
11.1 Advantages of using UNIX with C
Portability -- UNIX,b¤PaBxusKñarbs; UNIX KWeRbIenAelIm:asIunCaeRcIn.

kmμviFIEdl)ansresrenAkñúgsþg;da UNIX nig C nwgdMeNIkarNamYYyénBYkvaedaymankarlM)ak
bnþicbnþÜc.
Multiuser / Multitasking – kmμviFICaeRcInGacEbgEckGnuPaBRbtibtþim:asIun.
File handling – RbB½n§ file énzananuRkmCamYyGnuKmn_edaHRsay file CaeRcIn.
Shell Programming -- UNIX pþl;eGayGñkbkERbXøabBa¢ad¾manGnuPaBEdlyl;Xøa
bBa¢a)aneRcInCag 200 ehIyk¾GacdMeNIrkar UNIX nigkmμviFIEdlGñksresr)anbegáIt (user-
defined program) .
Pipe –kEnøgEdle)aHecjrbs;kmμviFIGacRtUv)anbegáItkare)aHcUlénkmμviFImYyepSgeTot.
enHGaceFIVeTA)anBIXøabBa¢ab¤xagkñúgkmμviFI C .
UNIX utilities – mannUvGtßRbeyaCn_eRcInCag 200 EdlGnuBaØateGayeyIgeRbIGnuKmn_Ca
eRcInedaymincaM)ac;sresrkmμviFIfμI. e.g. make, grep, diff, awk, nig GnuKmn_d_éTeTot .
System calls -- UNIX mankarehARbB½n§RbEhl 60 EdlCacMnucsMxan;rbs; operating
system b¤ kernel rbs; UNIX. karehAKWRtUv)ansresredayBitR)akdenAkñúg C.
RKb;BYkvaTaMgGs;GacRtUv)aneRbIBIkmμviFI C . CamUldæan I/0 system clock eRbICa]TahrN_.

GnuKmn_ open() Ca]TahrN_rbs;karehA system .
Library functions – karbUkbEnßmeTAelI operating system.
-104-
vCBk
11.2 Using UNIX System Calls and Library Functions
edIm,IeRbIkarehA system nig library functions enAkñúgkmμviFI C eyIgCaFmμtaehAGnuKmn_ C
Edlsmrmü.
]TahrN_ standard library functions eyIg)anRbTHkarbBa©ÚlGnuKmn_ I/O kMritx<s;Cag fprintf(),
malloc() ...
RbmaNviFIKNitvisaRsþ GñkbegáItcMnYnécdnü -- random(), srandom(), lrand48(), drand48() .l.

ehIykarbMElg C types TaMgLayeTACa string KWCasmaCikrbs; stdlib.h standard library.
RKb;GnuKmn_KNitsaRsþdUcCa sin(), cos(), sqrt() Ca standard KNit library (math.h)
GnuKmn_ehIyepSgeTotyktamKMrURsedogenH.
sMrab;;karehARbB½n§CaeRcInnigGnuKmn_ library eyIgRtUvEtrab;bBa©Úl header file RtwmRtUv. e.g. stdio.h,
math.h
edIm,IeRbIGnuKmn_RtUvR)akdfaGñk)ansresr #includes cUlenAkñúg C file rbs;Gñk. enaHGnuKmn_Gac

RtUv)anehAdUcEdlGIVeyIg)ankMnt;vaedayedayxøÜneyIgpÞal;.
vamansar³sMxan;edayR)akdfa argument rbs;GñkmanRbePTEbbNa)an ebImindUcenHeTGnuKmn_nwg
GacbegáItlT§plEdlminsgÇwmTuk. lint KWBitCal¥eBlRtYtBinitüerOgEbbenH.
emeroneRkayeToteyIgnwgBinitüedaylMGitRTg;RTayCaeRcInrbs; C Standard Library.
WWWW±XXXX
-105-
vCBk
CMBUkTI 12
Integer Functions, Random Number, String
Conversion, Searching and Sorting:
<stdlib.h>
-106-
vCBk
edIm,IeRbIR)as;GuKmn_TaMgGs;enAkúñg library GñkRtUv:
#include <stdlib.h>
manEpñkmUldæanbIrbs;GnuKmn_:
elxKNit (Arithmetic)
cMnYnécdnü (Random Numbers)
karbMElg String (String Conversion)
kareRbIR)as;rbs;GnuKmn_TaMgenHKWmanTMnak;TMngedaypÞal;.eyIgRtwmEtRtYtBinitüBYkvaedaysegçb
CatYnaTIkñúgemeronenH.
12.1 Arithmetic Functions
manGnuKmn_cMnYnKt;RKwH4:
int abs(int number);
long int labs(long int number);
div_t div(int numerator,int denominator);

ldiv_t ldiv(long int numerator, long int denominator);
edaysar³sMxan;manGnuKmn_2CamYycMnYnKt;FmμCatinig long integer EdlRtUvKañ.

abs
GnuKmn_epÞrtMéldac;xatén argument number rbs;;va. ]TahrN_ abs(2) epÞr 2 dUcnwgeFIV abs(-2).
div
TTYlyk2 argument numerator nig denominator nigbegáItlT§plEcknigsMnl;Eckén
karEckcMnYnKt;FmμCati. crnasm<½n§ div_t RtUv)ankMnt; (enAkñúg stdlib.h) dUcxageRkam:
typedef struct {
int quot; /* quotient */
int rem; /* remainder */
} div_t;
(ldiv_t is similarly defined).
dUcenH:
#include <stdlib.h>
....
int num = 8, den = 3;

div_t ans;
-107-
vCBk
ans = div(num,den);
printf("Answer:\n\t Quotient = %d\n\t Remainder = %d\n", \

ans.quot,ans.rem);
begáItkare)aHecjxageRkam:
Answer:
Quotient = 2
Remainder = 2
12.2 Random Numbers
Random number KWmanRbeyaCn_kñúgkmμviFIEdlcMa)ac;edIm,IeFIVeGaydUcRBwtþikarN_écdnü dUcCa games,

kareFIVeGaydUcnigBiesaFkmμ. enAkñúgkarGnuvtþelIGnuKmn_begáItTinñn½yécdnüy:agBit – BYkvabegáIt
cMnYn pseudo-random . TMagenHRtUv)anKNnaTRmg;rUbmnþEdlpþl;eGay (GñkbegáItxusKμaeRbIrUbmnþ
epSgKña) ehIylMdab;cMnYnBYkvabegáItGacRcMEdl. seed KWEtgEtkMnt;TRmg;EdllMdab;RtUv)ancat;Ecg.
dUcenHebIGñkkMnt; seed dUcKñaRKb;eBlkarkMnt;dUcKñanwgRtUv)anKNna.
bec©keTsFmμtamYYyedIm,IENnaMeRcInCagenHPaBécdnüeTAkñúgGñkbegáItcMnYnécdnüKWedIm,IeRbIeBlevla
rbs;éf¶edIm,IkMnt; seed dUcEdlvanwgEtgEtRtUv)anpøas;bþÚr. (eyIgnwgeronsþg;dalibrary GnuKmn_eBl
evsakñúgemeronxageRkay).
mannUv (pseudo) GnuKmn_cMnYnécdnüCaeRcInenAkñúgsþg;da library. BYkvaTaMgGs;RbtibtþielImUldæan
KMnitdUcKñab:uEnþbegáItlMdab;cMnYnepSgKañ (GaRs½yelIGñkbegáItGnuKmn_xus²Kña) elIcenøaHcMnYnxusKña.
sMnuMsamBaØbMputrbs;GnuKmn_KW:
int rand(void);
void srand(unsigned int seed);
rand() epÞrcMnYn pseudo-random EdlbnþKñaenAkñúgcenøaHBI 0 eTA 2 -1. srand()

16
RtUv)aneRbIedIm,IkMnt; seed . ]TahrN_FmμtaénkareRbIR)as;em:agénéf¶edIm,IbBa©Úl seed

fμImYytamkarehA:
srand( (unsigned int) time( NULL ));
kmμviFIxageRkam card.c Bnül;kareRbIR)as;GnuKmn_TaMgenHedIm,IeFIVeGaydUcCakarRbmUlebor

edIm,Icab;epþImsab;:
/*
** Use random numbers to shuffle the "cards" in the deck. The second
** argument indicates the number of cards. The first time this
** function is called, srand is called to initialize the random
-108-
vCBk
** number generator.
*/
#include <stdlib.h>
#include <time.h>
#define TRUE 1
#define FALSE 0
void shuffle( int *deck, int n_cards )

{
int i;
static int first_time = TRUE;
/*
** Seed the random number generator with the current time
** of day if we haven't done so yet.
*/
if( first_time ){
first_time = FALSE;
srand( (unsigned int)time( NULL ) );
}
/*
** "Shuffle" by interchanging random pairs of cards.
*/
for( i = n_cards - 1; i > 0; i -= 1 ){
int where;
int temp;
where = rand() % i;
temp = deck[ where ];
deck[ where ] = deck[ i ];
deck[ i ] = temp;
}
}
manGñkbegáItcMnYnécdnüepSgmYycMnYnGacrk)anenAkñúg standard library.

12.3 String Conversion
manGnuKmn_mYycMnYnEdlmansar³sMxan;edIm,Ipøas;bþÚr strings eTACatMél integer long integer nig

float . man:
double atof(char *string) – pøas;bþÚr string eTACatMélTsPaK.

int atoi(char *string) – pøas;bþÚr string eTACatMélcMnYnKt;FmμCati.
int atol(char *string) -- pøas;bþÚr string eTACatMél long integer .
double strtod(char *string, char *endptr) -- pøas;bþÚr string eTACatMélTsPaK.
long strtol(char *string, char *endptr, int radix) – pøas;bþÚr string eTACa long
integer edayeRbI radix Edlpþl;eGay.
-109-
vCBk
unsigned long strtoul(char *string, char *endptr, int radix) – pøas;bþÚr string
eTACa unsigned long.
PaKeRcInTaMgenHKWeRbIR)as;edayRtg;²Etmþg. ]TahrN_:
char *str1 = "100";
char *str2 = "55.444";
char *str3 = " 1234";
char *str4 = "123four";
char *str5 = "invalid123";
int i;
float f;
i = atoi(str1); /* i = 100 */
f = atof(str2); /* f = 55.44 */
i = atoi(str3); /* i = 1234 */
i = atoi(str4); /* i = 123 */
i = atoi(str5); /* i = 0 */
cMNaM:
naMdl;GkSrTeTrKWrMlg.
knÞúyGkSrminRtwmRtUvKWminRtUv)andwglW.
RbsinebIkarpøas;bþÚrminGacRtUv)aneFIV sUnüRtUv)anepÞrnig errno RtUv)ankMnt;CamYytMél
ERANGE.
12.4 Searching and Sorting

stdlib.h pþl;GnuKmn_mansar³RbeyaCn_2edIm,IGnuvtþkarRsavRCavnigtMerobTinñn½yCaTUeTAmYy
enAelIRbePTNamYy. tamkarBiteyIg)anENnaMrYcehIynUvGnuKmn_ qsort(). sMrab;;PaBeBj
eljeyIgkt;RtaKMrUmþgeTotenATIenHb:uEnþeyageTAelIGñkGaneTAelIemeronmunsMrab;;]TahrN_.
qsort standard library function CaGnuKmn_mansar³sMxan;EdlRtUv)anerobcMedIm,ItMerob array
edaytMélKnøWHénRbePTNamYyeTACalMdab;ekIn k¾dUcCaFaturbs; array RtUv)ankMnt;RbePT.

qsort is prototyped (in stdlib.h):
void qsort(void *base, size_t num_elements, size_t element_size, int
(*compare)(void const *, void const *));
RsedogKñaenHmanGnuKmn_ binary search bsearch() EdlmanKMrU (enAkñúg stdlib.h) dUcCa:

void *bsearch(const void *key, const void *base, size_t nel, size_t size,
int (*compare)(const void *, const void *));
kareRbIrcnasm<½n§ Record dUcKañnwg record_compare GnuKmn_Ca qsort() ]TahrN_:

-110-
vCBk
typedef struct {
int key;
struct other_data;
} Record;
int record\_compare(void const *a, void const *a)

{ return ( ((Record *)a)->key - ((Record *)b)->key );
}
k¾snμt;faeyIgman array én array_length Records )anbMeBjedaysmrmüCamYy

kalbriecäTeyIgGacehA bsearch() dUcenH:
Record key;
Record *ans;
key.key = 3; /* index value to be searched for */

ans = bsearch(&key, array, arraylength, sizeof(Record),
record_compare);
GnuKmn_ bsearch() epÞr pointer eTA field EdlCarbs; key filed RtUv)anbMeBjCamYytMélEdl
RtUvKñaén NULL RbsinebIminKY)anrkeXIj.
cMnaMfaRbePTén key argument RtUvEtdUcKañCaFatu array (Record xagelI) ebIeTaHbICamanEtFatu
key.key mYyb:ueNÑaHRtUv)anRtUvkaredIm,IkMnt;.
Exercises
Exercise 12-1
sresrkmμviFIEdleFIVeGaydUckare)aHRKab;LúkLak;
Exercise 12-2
cUrsresrkmμviFIEdleFVIeGaydUceqñatCati United Kingdom (UK) edayeRCIsykelxcMnYn6

xÞg;enAkñúgcenøaH 1 - 49.
Exercise 12-3
cUrsresrkmμviFIEdlGancMnYnBIXøabBa©ÚlnigbegáItcMnYnécdüTsPaKenAkñúgcenøaH 0 eTA– cMnYnEdl)an

bBa©Úl.
WWWW±XXXX
-111-
vCBk
CMBUkTI 13
Input and Output (I/O):stdio.h
-112-
vCBk
emeronenHnwgbeRgonTRmg;rbs; I/O.
eyIg)anENnaMedaysegçbTRmg;mYycMnYnmunsikSaTRmg;TaMgenHenA kñúglkçN³lMGitenATIenH.
kmμviFIrbs;GñknwgRtUvkarrYmbBa©Úlsþg;da I/O header file dUcenH:
#include <stdio.h>
13.1 Reporting Errors
CaeRcInelIkvamansar³sMxan;kñúgkareFIVr)aykarN_enAkñúgkmμviFI C . sþg;da library perror()

KWedIm,IgayRsYleRbInigGnuKmn_RtwmRtUv. vaRtUv)aneRbIrsMrab;;P¢ab;CamYYy errno nigCYbRbTHCa
jwkjab;nUvkMhusGñkRbEhlGaccg;bBa©b;kmμviFIrbs;Gñkmun. xN³minmanEpñktwgrwugén stdio.h
library eyIgENnaMKMnitrbs; errno nigGnuKmn_ exit() enATIenH. eyIgk¾nwgCYbKMnit
TMagenHenAkñúgEpñkrbs; Standard Library.

perror()
GnuKmn_ perror() KWRtUv)aneFVIKMrUeday:

void perror(const char *message);
perror() begáItsar BN’nakMhusEdl)anCYbcugeRkay epÞrtMéleTA errno (emIlxageRkam)

kñúgkMLúgeBlehAeTARbB½n§b¤ library function. argument string message
RtUv)ane)aHecjdMbUgbnÞab;mksBaØacucBIr (colon) (:) nig TeT enaHsarnig newline. RbsinebI
message KWCa NULL pointer b¤ points eTA null string sBaØa colon (:) RtUv)ane)aHecj.
errno
errno KWCaGBaaØtRbB½n§Biess (system variable) EdlRtUv)ankMnt;RbsinebIkarehARbB½n§min)aneFIV

eFIVkargarrbs;va. vaRtUv)ankMnt;enAkñúg
#include <errno.h>.
edIm,IeRbIR)as; errno enAkñúgkmμviFI C vaRtUv)anRbkaseTAtam

extern int errno;
vaGacRtUv)ankMnt;eLIgvijedayédenAkñúgkmμviFI C
(EteTaHCay:agNak¾edayvaminEmnCakarGnuvtþFmμtaeT)
ebImindUcenHeTvaCaFmμtarkSaTuktMélEdl)anepÞrcugeRkayedaykarehARbB½n§b¤GnuKmn_ library.
-113-
vCBk
exit()
GnuKmn_ exit() CaRtUv)aneFIVKMrUenAkñúg #include <stdlib> eday:

void exit(int status)
Exit edayFmμtabBa©b;karRbtibtþirbs;kmμviFInigepÞrtMélRtLb; exit status eTARbB½n§RbtibtþkarN_.

tMél status RtUv)aneRbIedIm,IbgðajRbsinebIkmμviFIRtUv)anbBa©b;eday RtwmRtUv:
vacak;ecjedaytMél EXIT_SUCCESS enAeBlbBa©b;edayeCaKC½y
vacak;ecjedaytMél EXIT_FAILURE enAeBlbBa©b;edaymineCaKC½y
enAeBlCYbRbTHkMhusGñkGacCajwkjab;ehA exit(EXIT_FAILURE) edIm,IbBa©b;kmμviFIEdlKμan
karbBa©b;Cak;lak;.
13.2 Streams
KWCaviFIEdlGaceRbIkarGannigkarsresrTinñn½y. BYkvapþl;eGaynUvPaBbt;EbnnigmeFüa)ay
Streams
EdlmansmßPaBrbs; I/O.
Stream KWCa file b¤rUbrag]bkrN_ (e.g. printer b¤ monitor) EdlRtUv)ancat;EcgCamYy pointer eTA
stream.
vamanrcnasm<½n§Tinñn½y C Epñkxagkñúg FILE EdlbgðajRKb; stream TaMgGs;nigRtUv)ankMnt;enAkñúg

stdio.h. eyIgCaFmμtaRtUvkareyageTAelIrcnasm<½n§ FILE enAkñúgkmμviFI C enAeBlGnuvtþ I/O
CamYy streams.
eyIgRKan;EtRtUvkarRbkasGBaaØt pointer rbs;RbePTenHkñúgkmμviFIrbs;eyIg.
eyIgmincaM)ac;RtUvkardwgGMBIrkarkMnt;Cak;lak;NamYyeT
eyIgRtUvEtebIk stream muneFIV I/OGIVmYy enaHeRkaymkeRbIvaehIybiTvavij.
Stream I/O KWCa BUFFERED: EdlRtUv)ankMnt;faminERbRbYl ”chunk” KWGanBIb¤RtUv)ansresreTA
file tamtMbn;rkSaTukGciéRnþmYycMnYn (buffer). enHRtUv)anBnül;enAkñúgrUb 12.1. cMNaM file pointer
BitR)akdcg¥úleTA buffer enH.
-114-
vCBk
rUb 13.1 KMrU Stream I/O vanaMeTAdl; I/O EdlmansmtßPaBb:uEnþRbytñ½: Tinñn½yRtUv)ansresreTA

buffer minelceLIgenAkñúg file (b¤]bkrN_) rhUtTal;Et buffer RtUv)ansMGatb¤sresrecj. (\n
eFIVbBaðaenH). karcakecjxusBIFmμtaNamYyrbs;kUdGacbNþaleGayekItbBaða.
9 Predefined Streams
stream EdlkMnt;Tukmun3RtUv)ankMnt;enAkñúg stdio.h:

stdin, stdout, stderr
BYkvaTaMgenHeRbIGtßbT method rbs; I/O.

stdin nig stdout GacRtUv)aneRbIR)as;CamYy files, programs, ]bkrN_ I/O dUcCa keyboard,
console,..l. stderr EtgEteTAtam console b¤ screen.
Console KWCa default sMrab;; stdout nig stderr. keyboard KWCa default sMrab;; stdin.
stream EdlkMnt;Tukmun (predefined stream) KWRtUv)anebIkedaysV½yRbvtþi.
13.3 Basic I/O
vamanGnuKmn_BIrEdlpþl;mUldæanRKWH I/O gayRsYl.

RbEhlCaGVIEdlsamBaØCageKKW: getchar() nig putchar(). BYkvaRtUv)ankMnt;nigeRbIdUcxag
eRkam:
int getchar(void) -- Gan char BI stdin
int putchar(char ch) -- sresr char eTA stdout, epÞrGkSrEdl)ansresr.
-115-
vCBk
int ch;
ch = getchar();
(void) putchar((char) ch);
RKb;elIkeBlvaRtUv)anehA getchar GanGkSrEdlbBa©ÚlbnÞab;BIGtßbT stream (text stream)
ehIyepÞr EdldUcCatMélrbs;va. enaHeRkaymk

ch = getchar();
GBaaØt ch pÞúkGkSbnÞab;Edl)anbBa©Úl. GkSrCaFmμta)anmkBI keyboard.

GnuKmn_ putchar e)aHecjGkSrmYytYRKb;elIkEdlvaRtUv)anehA:
putchar(ch);
e)aHecjnUvGVIEdlmanenAkúñgGBaaØtcMnYnKt;FmμCati c CatYGkSr CaTUeTAenAelI screen. ehAeTA

putchar nig printf GacRtUv)andak;cenøaHTMB½rkare)aHecjnwgRtUvelceLIgenAkúñglMdab;Edl
kar ehARtUv)anCYbRbTH.
GnuKmn_EdlCab;Tak;Tg:
int getc(FILE *stream) : fgetc epÞrGkSrbnÞab;rbs; stream Ca unsigned char
(RtUv)anpøas;bþÚreTACa int) b¤ EOF RbsinebIcugbBa©b;rbs; file b¤kMhusRtUv)anekIteLIg.
int putc(char ch,FILE *stream) : sresrGkS c (pøas;bþÚreTACa unsigend
char) enAelI stream. vaepÞrGkSrEdl)ansresrb¤ EOF sMrab;;kMhus.
ehIy :
char *gets(char *s) : gets Gankare)aHbBa©ÚlbnÞab;eTAkñúg array s vaCMnYskarbBa©b;
newline eday'\0'. vaepÞr s b¤ NULL RbsinebIcugbBa©b;rbs; file b¤kMhusRtUv)anRbTH.
int puts(const char *s) : puts sresr string s nig newline eTA stdout.
vaepÞr EOF RbsinebIkMhusekIteLIg minmantMélGviC¢man ebImindUcenHeT.

13.4 Formatted I/O
eyIg)aneXIj]TahrN_énrebob C eRbIR)as; I/O Edl)ankMnt;RTg;RTayrYcehIy.

cUrsikSalMGitBIvakñúglkçN³Bisþar.
-116-
vCBk
9 Printf
GnuKmn_RtUv)ankMnt;dUcxageRkam:
int printf(char *format, arg list ...) – e)aHecjeTA stdout taragrbs;
arguments GaRs½yeTAtamTRmg; string EdlRtUv)ankMnt;Cak;lak;.
epÞrcMnYnrbs;GkSrEdlRtUv )ane)aHecj.
karkMnt;TRmg; string (format string) manBIrRbePTén object:
ordinary characters – TaMgenHRtUv)ancmøgedIm,Ie)aHecj.
conversion specifications – RtUv)ancg¥úlR)ab;eday % ehIyRtUv)ankt;Tukkñúg tarag 13.1.
tarag: Printf/scanf format characters

Format Spec Type Result
(%)
c char single character
i,d int decimal number
o int octal number
x,X int hexadecimal number
u int unsigned int
s char * print string, terminated by \0
f double/flo format [-]m.ddd...
at
e,E " Scientific Format, [-]m.ddde+/-xx (ex-
1.23e002)
g,G "
e b¤ f NamYyEdlCitbMput
% - print % character
rvag % nigkarkMnt;TRmg; char eyIgGacdak;bBa©Úl:

- (minus sign)
-- tMrwmxageqVg.
integer number
-- TTwg field
m.d
-117-
vCBk
-- m = TTwg field, d = PaBc,as;las;rbs;cMnYnéntYelxxageRkay decimal point b¤cMnYnrbs; chars
BI string.
dUcenH:
#include <stdio.h>
void main()
{
int num1=123; float num2=4.567; long num3=1234567;
printf("num1=%d| |num2=%f\n",num1, num2);
printf("num1=%10d| |num2=%10.5f\n",num1, num2);
printf("num1=%-10d| |num2=%10.1f\n",num1, num2);
printf("num1=%10.3f| |num2=%d\n",num1, num2);
}
kare)aHecjenAelIeGRkg;KW:
num1=123| |num2=4.567
num1= 123| |num2= 4.56700
num1=123 | |num2= 4.7
num1= -0.000| |num2=1074939035
nig:
printf("VAT=17.5%%\n");
... e)aHecj:
VAT=17.5%
TTwgb¤PaBCak;lak;GacRtUv)ankMnt;Ca * EdlkñúgenHkrNItMélRtUv)anKNnaedaykarpøas;bþÚr
argument bnÞab; (EdlRtUvEtCa int). ]TahrN_edIm,Ie)aHecjGkSr max eRcInbMputBI string s,
printf("%.*s", max, s);
karpøas;bþÚrTRmg;eRcInbMputRtUv)anBnül;enAkñúgemerondMbUg.
karelIkElgmYyCaCak;lak;xN³EdlvaCab;Tak;Tg;eTAnig string . taragxageRkambgðajRbsiT§iPaB
éndMeNIrpøas;bþÚrjy²énkarCak;lak;enAkñúgkare)aHecj ``hello, world''(12 tYrGkSr). eyIg)andak;
sBaØa colon (:) xagmux field mYydUcenHGñkGaceXIjva xan;dac;BIKña.
:%s: :hello, world:
:%10s: :hello, world:
:%.10s: :hello, wor:
-118-
vCBk
:%-10s: :hello, world:
:%.15s: :hello, world:
:%-15s: :hello, world :
:%15.10s: : hello, wor:
:%-15.10s: :hello, wor :
dak;eGaydit: printf eRbI argument dMbUgrbs;vaedIm,IsMerccMnYn argument b:unμaneTAtamnigRbePT

BYkvaCaGVI. vanwgRcLMehIyGñknwgTTYl)annUvcMelIyxus RbsinebIminman argument RKb;RKan;Rbsin
ebIBYkvamanRbePTxus.GñkKYEtRbugRby½tñnUvPaBxusKñarvagkarehATaMgBIrenH:
printf(s); /* FAILS if s contains % */
printf("%s", s); /* SAFE */
GnuKmn_ sprintf eFIVkarpøas;bþÚrdUceTAnwg printf eFIVEdr b:uEnþkare)aHecjenAkñúg string:

int sprintf(char *string, char *format, arg1, arg2, ...);
sprintf kMnt;TRmg; arguments kñúg arg1, arg2, .l. GaRs½yeTAtamkarkMnt;TRmg;dUcBImun

b:uEnþdak;lT§plenAkúñg string CMnYssþg;dae)aHecj string RtUvEtFMlμmedIm,ITTYllT§pl.
9 scanf
GnuKmn_RtUv)ankMnt;dUcxageRkam:
int scanf(char *format, args....) – GanBI stdin
nigdak;bBa©ÚlkñúgGas½ydæanrbs;GBaaØtCak;lak;kñúgbBa¢I args . epÞrcMnYnrbs; chars EdlGan.
Format control string RsedogeTAnwg printf
cMNaM: Gas½ydæanrbs;GBaaØtb¤cg¥úleTAGBaaØtEdlRtUvkareday scanf.
scanf(``%d'',&i);
eyIgGacRKan;EteGayeQμaH array b¤ string eTA scanf edaysareQμaHRtUvKañeTAnigGas½ydæancab;

epþImén array/string.
char string[80];
scanf(``%s'',string);
cUlemIl]TahrN_sMrab;;Xøa scanf :
#include <stdio.h>
-119-
vCBk
void main()
{
char ch;
int num;
float f;
printf("Enter a character:"); scanf("%c", &ch);
printf("Enter an intger:");scanf("%d", &num);
printf("Enter a floating point number:"); scanf("%f", &f);
printf("%c\n", ch);
printf("%d\n", num);
printf("%f\n", f);
}
13.5 Files
Files CaTRmg;y:agsamBaØmYyrbs; stream.

vtßúdMbUgeyIgRtUvEteFIVKWkarebIk file. GnuKmn_ fopen() eFIVbBaðaenH:
FILE *fopen(char *name, char *mode)
fopen epÞr pointer eTA FILE. eQμaH string CaeQμaHrbs; file enAelI disc EdleyIgcg;eRbI.
string mode RtYtBinitüRbePTénkareRbIR)as;rbs;eyIg.RbsinebI file minGacRtUv)aneRbIcMeBaHehtu
plNamYy NULL pointer RtUv)anepÞr.

KMrUrYmman: “r” -- read,
“w” -- write and
“a” -- append.
edIm,IebIk file mYyeyIgRtUvEtman stream (file pointer) Edlcg¥úleTArcnasm<½n§ FILE.

dUcenHedIm,IebIk file, RtUv)anehA myfile.dat sMrab;;GaneyIgnwgeFIV:
FILE *stream, *fopen();
/* declare a stream and prototype fopen */
stream = fopen(“myfile.dat”,”r”);
vaCakarGnuvtþEdll¥edIm,IBinitü file RtUv)anebIkedayRtwmRtUvehIyb¤enA :

if ( (stream = fopen( “myfile.dat”, “r”)) == NULL)
{ printf(“Can't open %s\n”, “myfile.dat”);
exit(1);
}
......
-120-
vCBk
9 karGan nig sreesr files

GnuKmn_ fprintf nig fscanf CaFmμtaeRbIedIMm,I access files.
int fprintf(FILE *stream, char *format, args..)
int fscanf(FILE *stream, char *format, args..)
TMagenHKWRsedogeTAnwg printf nig scanf elIkElgEtTinñn½yRtUv)anGanBI stream

EdlRtUvEt)anebIkedayGnuKmn_ fopen().
stream pointer KWekIneLIgedaysV½yRbvtþiCamYyRKb; file read/write functions.
eyIgminman)armÖGMBIrkareFIVenHeT.
char *string[80]
FILE *stream, *fopen();
if ( (stream = fopen(...)) != NULL)

fscanf(stream,``%s'', string);
GnuKmn_epSgeTotsMrab; files:
int getc(FILE *stream), int fgetc(FILE *stream)
int putc(char ch, FILE *s), int fputc(char ch, FILE *s)
enHKWdUcKañnwg getchar, putchar. getc RtUv)ankMnt;Ca preprocessor MACRO enA stdio.h.

fgetc KWCa C library function. GnuKmn_TaMgBIrsMerc)anlT§pldUcKña.
fflush(FILE *stream) -- flushes a stream.

fclose(FILE *stream) -- closes a stream.
eyIgGaceRbI predefined streams CamYYy fprintf .l.

fprintf(stderr,”Cannot Compute!!\n”);
fscanf(stdin,”%s”,string);
9 Stream Status Enquiries
manGnuKmn_Edlmansar³RbeyaCn_BIrbI EdlmanKMrUdUcxageRkam:
int feof(FILE *stream);
int ferror(FILE *stream);
void clearerr(FILE *stream);
int fileno(FILE *stream);
-121-
vCBk
kareRbIR)as;rbs;BYkvaKWsamBaØedayGacERbRbYl:
feof()
-- epÞrBitRbsinebI stream KWkMBugsßitenAcug file . dUcenHedIm,IGan stream,fp,
mYybnÞat;mþg²GñkGaceFIV:
while ( !feof(fp) )
fscanf(fp,"%s",line);
ferror()
-- r)aykarN_enAkñúgdMNak;kalkMhusrbs; stream nigepÞrBitRbsinebIkMhusRtUv)anekIteLIg.
clearerr()
-- karkMnt;eLIgvijkarbgðajkMhussMrab;; stream Edlpþl;eGay.
fileno()
-- epÞr file descriptor cMnYnKt;FmμCatiEdlP¢ab;CamYyeQμaH stream.
13.6 Low Level I/O
TRmg;enHén I/O KWCa UNBUFFERED – karGanb¤sresrnimYy²RtUvkarlT§plkñúgkareRbI disk
(b¤]bkrN_) edaypÞal;edIm,InaMykmkb¤dak;cMnYnCak;lak;rbs; byte.
minmankarkMnt;TRmg;gayRsYl. eyIgkMBugedaHRsayCamYy byte rbs;Bt’man.

enHmann½yfaeyIg\LÚveRbIR)as; binary (ehIyminEmnCaGtßbT) file.
CMnYseday file pointer eyIgeRbI low level file edaHRsayb¤ file descriptors
Edlpþl;eGaycMnYnKt;FmμCatiEtmYyedIm,IkMnt;sMKal; file nimYy².

edIm,IebIk file eRbI:
int open(char *filename, int flag, int perms) – vaepÞr file descriptor b¤ -1
sMrab;;min)an.
flag RtYtBinitü file eRbIehIy)ankMnt;dUcxageRkamenAkñúg fcntl.h:
O_APPEND, O_CREAT, O_EXCL, O_RDONLY, O_RDWR, O_WRONLY + epSgeToteXIj
online TMBr½ man b¤sMGagelIkareFIVedayéd.
perms – dak;tMél 0 sMrab;kmμviFIrbs;eyIgPaKeRcIn.
-122-
vCBk
GnuKmn_:
creat(char *filename, int perms)
k¾GacRtUv)aneRbIR)as;edIm,IbegáIt file.
int close(int handle) -- close a file
int read(int handle, char *buffer, unsigned length)

int write(int handle, char *buffer, unsigned length)
Føab;)aneRbIR)as; read/write edIm,IcMnYnCak;lak;rbs; byte mkBIb¤eTA file (handle)
rkSaTukb¤RtUv)anTukenAkñúgTItaMg memory EdlkMnt;eday buffer.

GnuKmn_ sizeof() KWeRbIR)as;CaFmμtaedIm,IkMnt;RbEvg length.
Gannigsresr epÞrcMnYnrbs; byte Edl)anGanb¤sresrb¤ -1 RbsinebIeFIVxus.
/* program to read a list of floats from a binary file */
/* first byte of file is an integer saying how many */
/* floats in file. Floats follow after it, File name got from */
/* command line */
#include<stdio.h>
#include<fcntl.h>
float bigbuff[1000];
main(int argc, char **argv)
{ int fd;
int bytes_read;
int file_length;
if ( (fd = open(argv[1],O_RDONLY)) = -1)

{ /* error file not open */....
perror("Datafile");
exit(1);
}
if ( (bytes_read = read(fd,&file_length,
sizeof(int))) == -1)
{ /* error reading file */...
exit(1);
}
if ( file_length > 999 ) {/* file too big */ ....}
if ( (bytes_read = read(fd,bigbuff,
file_length*sizeof(float))) == -1)
{ /* error reading open */...
exit(1);
}
}
-123-
vCBk
Exercises
Exercise 13-1
cUrsresrkmμviFIedIm,IcmøgeQμaH file eTAkñúgeQμaH file mYyepSgeTot. eQμaH file
BIrKWRtUv)anpþl;eGayCa argument dMbUgBIreTAeGaykmμviFI.

cmøgbøúk file (512 bytes) enAeBlmYy.
Check: that the program has two arguments
or print "Program need two arguments"
that the first name file is readable
or print "Cannot open file .... for reading"
that the second file is writable
or print "Cannot open file .... for writing"
Exercise 13-2
cUrsresrkmμviFIcugeRkayEdlEdle)aHecj n bnÞat;cugeRkayrbs; file GtßbT eday n nigeQμaH file

KYrRtUv)ankMnt;TRmg;XøabBa¢ae)aHbBa©Úl. eday default n KYrEtesμI 5 b:uWEnþkmμviFIrbs;GñknwgGnuBaØat
eGayman argument k¾)anGt;k¾)andUcenH
last -n file.txt
e)aHecj n bnÞat;cugeRkayEdl n CacMnYnKt;FmμCatiNamYy. kmμviFIrbs;GñkKYrbegáItkareRbI)as;

EdlläbMputrbs;karrkSaTukEdlGacrk)an.
Exercise 13-3
cUrsresrkmμviFIedIm,IeRbobeFob file BInige)aHecjbnÞat;EdlBYkvaxusKña. karENnaM: rkemIl string

RtwmRtUvnig file kareRbIGnuKmn_ library (library routines). vaminKYrCakmμviFIEvgeBkeT.
WWWW±XXXX
-124-
vCBk
CMBUkTI 14
Miscellaneous Functions
-125-
vCBk
Standard library pþl;eGaykarpøas;bþÚry:agTUlayénGnuKmn_enAEpñkenHKWCakarsegçberOgEdlman
GtßRbeyaCn_CaeRcIn.
14.1 String Handling: <string.h>
karehAmþgeTotBIkarBiPakSarbs;eyIgenAelI array Edl strings RtUv)ankMnt;Ca array énGkSrb¤
pointer eTAnwgEpñkrbs; memory pÞúkGkS ASCII . String enAkñúg C KWCalMdab;bnþbnÞab;rbs;sUnü
b¤GkSreRcIntamBIeRkayedayGkSr NULL (\0).
vamanRbeyaCn_kúñgkarkarBarGkSrbBa©b; NULL dUcCa C kMnt;ehIyerobcMRbEvgGBaaØt string

RKb;sþg;daGnuKmn_ standard library C RtUvkarvasMrab;;karRbtibtþieCaKC½y.
CaTUeTAEpñkBIGnuKmn_ length-restricted mYycMnYn ( strncat(), strncmp,() nig strncpy())
Tal;EtGñkbegáIt string edayédGñknwgminCYbRbTHbBaðadUcenHeT. GñkKYrEteRbIGnuKmn_manRbeyaCn_
CaeRcInEdlTak;Tgnwg string ehIyminKYrcMNayeBl\tRbeyaCn_eTAsresrGnuKmn_EdlTak;Tgnwg
string enaHeT.
9 Basic String Handling Functions

RKb;GnuKmn_kareRbI string KWKMrUedIm (prototype) enAkñúg:
#include <string.h>
GnuKmn_samBaØ (common functions) RtUv)anbgðajxageRkam:
char *stpcpy (const char *dest,const char *src) : cmøg string mYyeTAmYYyepSgeTot.
int strcmp(const char *string1,const char *string2) : eRbobeFob string1 nig string2
edIm,IkMnt;lMdab;tamlMdab;GkSr.
char *strcpy(const char *string1,const char *string2) : cmøg string2 eTA stringl.
char *strerror(int errnum) : TTYlyksarkMhusGaRs½yeTAtamelxkMhus Edl)ankMnt;.
int strlen(const char *string) : kMnt;RbEvgén string.
char *strncat(const char *string1, char *string2, size_t n) : bEnßm n tYGkSrBI string2 eTA
stringl.
int strncmp(const char *string1, char *string2, size_t n) : eRbobeFob n tYGkSrdMbUgrbs; string
BIr.
-126-
vCBk
char *strncpy(const char *string1,const char *string2, size_t n) : cmøg n tYGkSrdMbUgén string2
eTA stringl .
int strcasecmp(const char *s1, const char *s2) : krNIminRbkan;tYGkSr (case insensitive version)
én strcmp().
int strncasecmp(const char *s1, const char *s2, int n) : krNIyminRbkan;tYGkSr (case
insensitive version)én strncmp().

kareRbIR)as;rbs;GnuKmn_PaKeRcInKWRtg;² ]TahrN_:
char *str1 = "HELLO";
char *str2;
int length;
length = strlen("HELLO"); /* length = 5 */

(void) strcpy(str2,str1);
cMnaMfaTaMg strcat() nig strcopy() epÞrtMélcMlgrbs; argument dMbUgrbs;BYkvaEdlCaeKaledA array.
cMnaMlMdab;én argument KWCaeKaledA array enABIeRkayeday source array
EdlmaneBlxøHgayRsYlTTYl)annUvkMhusenAeBlsresrkmμviFI.
GnuKmn_ strcmp() eRbobeFobkarbBa©Úl string BIrnigepÞrtMél:
tUcCagsUnü
-- RbsinebI string1 manRbEvgtUcCagsUnü
sUnü
-- RbsinebI string1 nig string2 manRbEvgesμIKña
FMCagsUnü
-- RbsinebI string1 manRbEvgFMCag string2
enHk¾GaceFIVeGayGñkeTIbEtcab;epþImsresrkmμviFInigGñkmanbTBiesaFn_sresrkmμviFIePøcvaEdr.
GnuKmn_cMlg strncat(), strncmp,() nig strncpy() KWCa string Edlkat;bnßyCMnan; (restricted version
)énvtßúEdlCaKUrKñaTUeTACaeRcInrbs;BYkva. BYkvaGnuvtþkargarRsedogKñab:uEnþRtwmEteTAdl; n
tYGkSrdMbUg. cMnaM NULL EdlbBa©b;tMrUvkarGacTTYlkarbMBanenAeBlkareRbIGnuKmn_TaMgenH
]TahrN_:
char *str1 = "HELLO";
char *str2;
int length = 2;
(void) strcpy(str2,str1, length); /* str2 = "HE" */
-127-
vCBk
str2 is NOT NULL TERMINATED.
9 String Searching
library k¾pþl;eGaynUvGnuKmn_ string searching mYycMnYnEdr:
char *strchr(const char *string, int c) : rkkarCYbRbTHdMbUgrbs;GkSr c enAkñúg string.
char *strrchr(const char *string, int c) : rkkarCYbRbTHcugeRkayrbs;GkSr c enAkñúg string.
char *strstr(const char *s1, const char *s2) : kMnt;TItaMgkarCYbRbTHdMbUgrbs; string s2 enAkñúg
string s1.
char *strpbrk(const char *s1, const char *s2) : epÞr pointer eTAkarCYbRbTHdMbUgenAkñúg s1
énGkSrNamYyBI string s2 b¤ null pointer RbsinebIminmanGkSrBI s2 manenAkñúg s1

size_t strspn(const char *s1, const char *s2) : epÞrcMnYnénGkSrrbs;GkSrenAxagedImrbs; s1
EdlKUnig s2.
size_t strcspn(const char *s1, const char *s2) : epÞrcMnYnrbs;GkSrenAxagedImrbs; s1
EdlminEmnCaKUnig s2.
char *strtok(char *s1, const char *s2) : bMEbk string Edlcg¥úleday s1
eTAkamlMdab;rbs;eRKOgsMKal;nimYy²EdlkMnt;edaymYyb¤eRcInGkSrBI string Edlcg¥úleday s2.

char *strtok_r(char *s1, const char *s2, char **lasts) : manGnuKmn_mYycMnYndUcCa strtok()
elIkElgEtkarcg¥úleTAkEnøgpÞúk string cugeRkayRtUv)ankMnt;edayGñkehA.

strchr() nig strrchr() KWeRbIR)as;CasamBaØ ]TahrN_:
char *str1 = "Hello";
char *ans;
ans = strchr(str1,'l');
eRkayBIkarRbtibtþienH ans cg¥úleTATItaMg str1 + 2
strpbrk() CaGnuKmn_TUeTACageKEdlEsVgrkkarCYbRbTHelIkdMbUgrbs;RkuménGkSrNamYYy ]TahrN_:
char *ans;
ans = strpbrk(str1,'aeiou');
enATIenH ans cg¥úleTATItaMg str1 + 1 TItaMgrbs; e dMbUg.
strstr() epÞr pointer eTA string EdlEsVgrkCak;lak;b¤ null pointer RbsinebI string
minRtUv)anrkeXIj RbsinebI s2 cg¥úl string EdlmanRbEvgsUnü (EdlenaH string "") GnuKmn_epÞr

s1. ]TahrN_
char *ans;
-128-
vCBk
ans = strstr(str1,'lo');
nwgnaMmk ans = str + 3.
strtok() KWmankarBi)akeRcInCagbnþickñúgkarRbtibtþi. RbsinebI argument dMbUgminEmnCa NULL
enaHGnuKmn_rkTItaMgrbs;GkSr argument TIBIrNamYYy. EteTaHCay:agNak¾edayTItMagRtUv)ancgcaM

ehIykarehAbnþbnÞab;NamYyén strtok() nwgcab;epþImBITItaMgenHRbsinebIkarehAbnþbbnÞab;TaMgenH
argument TImYyCa NULL ]TahrN_RbsinebIeyIgcg;bMEbk string str1
enAkEnøgdkXøanimYy²ehIye)aHecje)aHecjmYYy²enAelIbnÞat;mYy²eyIgGaceFIV:
char *str1 = "Hello Big Boy";
char *t1;
for ( t1 = strtok(str1," ");

t1 != NULL;
t1 = strtok(NULL, " ") )
printf("%s\n",t1);
enATIenHeyIgeRbI for loop enAkúñgKMrUrab;minsþg;damYy:
karcabepþIm (initialisation) ehA strtok() load function Edlman string str1
eyIgbBa©b;enAeBl t1 esμI NULL
eyIgrkSakarkMnt;ykrbs; str1 esμI t1 rhUtdl;karbBa©b;edaykarehA strtok() eday NULL
argument dMbUg.
14.2 Character conversions and testing: <ctype.h>

eyIgbBa©b;emeronenHedayerobrab; library #include <ctype.h>
EdlpÞúkGnuKmn_manRbeyaCn_CaeRcInedIm,Ipøas;bþÚrnigsakl,gGkSrEtmYy. GnuKmn_CaFmμtamanKMrU
(prototype) dUcxageRkam:
Character testing:
int isalnum(int c) : BitRbsinebI c CaGkSrRkmelx.
int isalpha(int c) : BitRbsinebI c CaGkSrmYy.
int isascii(int c) : BitRbsinebI c Ca ASCII..
int iscntrl(int c) : BitRbsinebI c CaGkSrRtYtBinitü.
int isdigit(int c) : BitRbsinebI c CaelxRbB½n§eKaldb; (decimal digit)
-129-
vCBk
int isgraph(int c) : BitRbsinebI c CaGkSr graphic (graphical character).
int islower(int c) : BitRbsinebI c CatYGkSrtUc
int isprint(int c) : BitRbsinebI c CaGkSrGace)aHecj)an
int ispunct (int c) : BitRbsinebI c CaGkSrvNÑyutþi (punctuation character).
int isspace(int c) : BitRbsinebI c CaGkSrdkXøa.
int isupper(int c) : BitRbsinebI c CaGkSrFM.
int isxdigit(int c) : BitRbsinebI c CaelxeKaldb;R)aMmYy (hexadecimal digit)

Character Conversion:
int toascii(int c) :pøas;bþÚr c eTACa ASCII .
tolower(int c) : pøas;bþÚr c eTACaGkSrtUc.
int toupper(int c) : pøas;bþÚr c eTACaGkSrFM.
kareRbIR)as;GnuKmn_TaMgenHKWRtg;²ehIyeyIgmineGay]TahrN_enATIenHeT.
14.3 Memory Operations: <memory.h>
eyIgsegçbTsSn³RbtibtþikarRKwHmYycMnYn. eTaHbICaminmanGnuKmn_ string twgrwgk_edayk_
GnuKmn_KWKMrUmanenAkñúg #include <string.h>:
void *memchr (void *s, int c, size_t n) : EsVgrktYGkSrenAkñúg buffer.
int memcmp (void *s1, void *s2, size_t n) : eRbobeFob buffer BIr.
void *memcpy (void *dest, void *src, size_t n) : cmøg buffer mYyeTAmYYyepSgeTot.
void *memmove (void *dest, void *src, size_t n) : pøas;cMnYnrbs; byte BI buffer
eTAmYyepSgeTot.
void *memset (void *s, int c, size_t n) : kMnt;RKb; byte rbs; buffer eTAeGayGkSr.
kareRbIR)as;rbs;BYkvaKWRtwmRtUveq<aHeTAmunehIyminRsedogeTAnigkarRbtibtþi string EdlGac

eRbobeFob)an (elIkElgRbEvgCak;lak; length (n) énRbtibtþikarRtUvEt)ankMnt;dUcCavaminmankar
bBa©b;FmμtaenATIenH).
cMnaMfaenARKb;krNI byte rbs; memory KWRtUv)ancmøg. GnuKmn_ sizeof() manRbeyaCn_mþgeTot
enATIenH ]TahrN_:
char src[SIZE],dest[SIZE];
int isrc[SIZE],idest[SIZE];
memcpy(dest,src, SIZE); /* Copy chars (bytes) ok */
-130-
vCBk
memcpy(idest,isrc, SIZE*sizeof(int)); /* Copy arrays of ints */
memmove() eFVIenAkñúgviFICak;lak;dUc memcpy() elIkELgkEnøgRbPB (source) nigTisedA
(destination) GacRtYtelIKña.
memcmp() KWRsedogeTAnwg strcmp() elIkElgenATIenH unsigned bytes KWRtUv)aneRbobeFobnigepÞr
tMélticCagsUnüRbsinebI s1 KWticCag s2 .l.

14.4 Mathematics: <math.h>
KNitsaRsþKWTak;TgedayRtg;eTA library edIm,IeRbImþgeTot. eyIgRtUvEt #include <math.h> .
RbPBkMhusFmμtaKWkarePøcbBa©Úl <math.h> file (ehIy yes GñksresrkmμviFIEdlmanbTBiesaFn_
k¾mankMhusdUcenHEdr). minmansMNaglä C compiler minmanCMnYyeRcIneT. cUrBinitü:
double x;
x = sqrt(63.9);
minmaneXIg prototype sMrab;; sqrt compiler (eday default) snμt;faGnuKmn_epÞr int
ehIypøas;bþÚrtMéleTA double CamYylT§plKμann½y.

9 Math Functions
xageRkameyIgkt;RtaGnuKmn_KNitviTüamYycMnYn. BIkMnt;cMNaMxagelIBYkvaKYrEtgayRsYledIm,Ikñúg
kareRbInigeyIg)aneRbIvamYYycMnYnrYcehIyenAkñúg]TahrN_mun².
eyIgminmanpþl;eGaynUv]TahrN_eToteTenATIenH:
double acos(double x) : KNna arc cosine rbs; x.
double asin(double x) : KNna arc sine én x.
double atan(double x) : KNna arc tangent én x.
double atan2(double y, double x) : KNna arc tangent én y/x.
double ceil(double x) : TTYlyktMélcMnYnKt;FmμCatitUcbMputEdlelIs x.
double cos(double x) : KNna cosine énmMuKitCa radians.
double cosh(double x) : KNna cosine GIuEBbUlikén x.
div_t div(int number, int denom) : EcktMélcMnYnKt;mYyedaymYyepSgeTot.
double exp(double x) : KNna exponential én x
double fabs (double x ) : KNnatMéldac;xatrbs; x.
double floor(double x) : TTYltMélcMnYnKt;FmμCatiFMCageKtUcCag x.
double fmod(double x, double y) : Eck x nig y EdllT§plEckéncMnYnKt;ehIyepÞrsMnl;Eck.
double frexp(double x, int *expptr) : bMEbk x eTACaplbUknigKμanniTsSnþ.
-131-
vCBk
labs(long n) : rktMéldac;xat;rbs; long integer n.
double ldexp(double x, int exp) : eFIVeLIgvij x xageRkAénplbUknigniTsSnþén2.
ldiv_t ldiv(long number, long denom) : Eck long integer mYYyedaymYyepSgeTot.
double log(double x) : KNna log(x).
double log10 (double x ) : KNna log eKal 10 én x.
double modf(double x, double *intptr) : Eck x eTACaEpñkRbPaKnigcMnYnKt;.
double pow (double x, double y) : KNna x elIkCasV½yKuNén y.
double sin(double x) : KNna sine énmMuKitCa radian .
double sinh(double x) - KNna sine GIuEBbUlikén x.
double sqrt(double x) : KNnab¤skaerén x.
void srand(unsigned seed) : kMnt; seed fμIsMrab;;GñkbegáItcMnYnécdnü (rand).
double tan(double x) : KNna tangent énmMuKitCa radian.
double tanh(double x) : KNna tangent GIuEBbUlikén x.

9 Math Constants
math.h library kMnt;tMélminERbRbYlCaeRcIn (Cajwkjab;eFVsRbEhs) . vaEtgEtnaMeTAdl;karkMnt;
TaMgenaH:
HUGE : tMélFMbMputéncMnYnek,ósCak;lak;EtmYy (single-precision floating-point number).
M_E : ln eKal e. (base of natural logarithms (e))
M_LOG2E : ln eKal2 én e (base-2 logarithm of e)
M_LOG10E - ln eKal10 én e ( base-10 logarithm of e)
M_LN2 : log eKal 2 (natural logarithm of 2)
M_LN10 : log eKal 10 (natural logarithm of 10)

M_PI : .
M_PI_2 : /2.
M_PI_4 : /4.
M_1_PI : 1/ .
M_2_PI : 2/ .
M_SQRT2 :b¤skaercMnYnviC©manén 2.
M_SQRT1_2 : b¤skaercMnYnviC©manén 1/2.
MAXFLOAT : tMélFMbMputéncMnYnek,ósEdlminGacminkMnt;Cak;lak;EtmYyKt;. (non-infinite

single- precision floating point number)
HUGE_VAL : viC¢manKaμnRBMEdn (positive infinity).
-132-
vCBk
vak¾mancMnYntMélÉkraCürbs;m:asIunkMnt;kñúg #include <value.h> -- emIl man value b¤ list value.h
edIm,IlMGitCagenH.
Exercises
Exercise 14-1
cUrsresrGnuKmn_RsedogeTAnwg strlen EdlGacedaHRsay string EdlminkMnt;.
ENnaMGñknwgcaM)ac;RtUvecHbBa¢ÚnRbEvgrbs; string.
Exercise 14-2
sresrGnuKmn_EdlepÞrtMélBitRbsinebIkarbBa¢Úl string CaBaküEdlGacGanRtLb;cuHeLIg)an
(palindrome)rvagKñanigKña. Baküb¤XøaEdlGacGanRtLb;cuHeLIg)an (palindrome) KWCaBaküEdl
GaceTAmuxeTAeRkaydUcKña e.g ABBA.

Exercise 14-3
esñIkarGnuvtþEdlGacrbs;GnuKmn_ strtok():
1.
kareRbIdMeNaHRsayGnuKmn_ string d¾éTeTot.
2.
BIeKalkarN_RKwH pointer dMbUgetIrebobrkSaTukénnimitþsBaØa string seRmceTAy:agdUcemþc?
Exercise 14-4
sresrGnuKmn_Edlpøas;bþÚrRKb;tYrGkSrénkare)aHcUl string eTACatYGkSrFM.
Exercise 14-5
cUrsresrkmμviFIEdlRtLb;GVIEdlrkSaTukCa bytes enAkñúg memory. GBa©wgRbsinebIeyIgman n bytes
enAkñúg memory byte TI n køayCa byte TI 0, byte TI n-1 køayCa byte TI 1 .l.
WWWW±XXXX
-133-
vCBk
CMBUkTI 15
Process Control:
<stdlib.h>,<unistd.h>
-134-
vCBk
Rbtibtþikar (process) KWedaymUldæanCakmμviFIkMBugdMeNIrkarmYy. vaGacCa “RbB½n§ (system)” kmμviFI
(e.g login, update, csh) b¤kmμviFIEdlcab;epþImedayGñkeRbIR)as; (textedit, dbxtool
b¤sresredayGñkeRbIR)as;).
enAeBl UNIX dMeNIrkarRbtibtþi (runs a process) vapþl;eGayRbtibtþikarnimYy²nUvcMnYnEdl
manEtmYy – Rbtibtþikar ID (process ID), pid.
XøabBa¢a UNIX ps nwgeGaytaragRKb;RbtibtþikarkMBugdMeNIrkarenAelIma:sIunrbs;GñkehIynwgbBa¢I
pid.
GnuKmn_ C int getpid() nwgepÞr pid rbs;RbtibtþikarEdlehAGnuKmn_enH.

kmμviFIEtgEtdMeNIrkarCaRbtibtþikarEtmYy.
EteTaHCay:agNak¾edayeRkaymkeyIgeXIjrebobeyIgGaceFIVkmμviFIdMeNIrkardUcRbtibtþikarbBa¢Ún
dac;²mYYycMnYn.
eyIgGacdMeNIkarXøabBa¢aBIkmμviFI C RtwmEtdUcKñaRbsinebIBYkvaCaXøabBa¢amkBI UNIX edayeRbIR)as;
GnuKmn_ system(). cMnaM: enHGaceGayeyIgsnSMeBlevla)aneRcInehIynigkarlM)akdUcEdl
eyIgGacdMeNIkarkmμviFIepSgeTot (EdlbBa¢ak;) scripts .l. edIm,IeFIVsMnuMkargar.
int system(char *string) – kEnøgEdl string GacRtUv)aneGayeQμaHrbs;GtßRbeyaCn_
unix shell script GacRbtibtþikarb¤kmμviFIGñkeRbIR)as;. RbB½n§epÞrsBaØacakecjrbs; shell. RbB½n§
(system) RtUvmanKMrU (prototype) enAkñúg <stdlib.h>
]TahrN_: ehA ls BIkmμviFI

main()
{ printf(``Files in Directory are:\n'');
system(``ls -l'');
}
system KWkarehAEdl)anehARbB½n§bIepSg²Kña : execl(), wait() nig fork()
(Edlman prototyed enAkñúg<unistd>)
9 execl()
execl manGnuKmn_EdlmanTMnak;TMng 5 epSg²Kña -- emIlkñúg man pages.
-135-
vCBk
execl sþg;dasMrab;; execute nig leave Edlmann½yfaRbtibtþikar (process) nwgTTYlkarRbtibtþi
ehIybBa©b;eday execl.
vakMnt;eday:
execl(char *path, char *arg0,...,char *argn, 0);
)a:ra:Em:RtcugeRkayRtUvEtCa 0. vaKWCa NULL terminator. edaysar argument list

KWCaGBaaØteyIgRtUvEtmanviFImYycMnYnénkarR)ab; C enAeBlvadl;cugbBa©b;. NULL terminator
eFIVkic©karenH.
kEnøgEdl path cg¥úleTAeQμaHrbs; file EdlpÞúkXøabBa¢aEdlRtUv)anRbtibtþi argo cg¥úleTA string
Edlman path dUcKña (b¤y:agtUcbMputvaCasmasPaBcugeRkay.)
arg1 ... argn KWCa pointer eTA argument sMrab;;bBa¢anig 0 gayRsYlsMKas;cugbBa©b;rbs;
(GBaaØt) list én argument.
dUcenH]TahrN_xagelIrbs;eyIgmanragya:genH:
main()
{ printf(``Files in Directory are:\n'');
execl(`/bin/ls'',``ls'', ``-l'',0);
}
9 fork()
int fork() epÞrRbtibtþikarEtmYyeTAkñúgRbtibtþikardUcKañebHbiT 2 sÁal;Ca parent ehIynwg child.

eBleCaKC½y fork() epÞr 0 eTARbtibtþikar child nigepÞr process ID rbs; child process eTA parent
process. eBlbraC½y fork() epÞr -1 eTA parent process, kMnt; errno edIm,Icg¥úlR)ab;kMhus
nigminman child process RtUv)anbegáIt.

cMnaM: child process nwgman PID EtmYypÞal;rbs;va.
kmμviFIxageRkamBnül;kareRbIR)as;samBaØrbs; fork kEnøgEdlkarcmøg2RtUv)aneFIVehIy
dMeNIrkarcUlKña (multitasking)
main()
{ int return_value;
-136-
vCBk
printf(``Forking process\n'');
fork();
printf(``The process id is %d and return value is %d\n", getpid(),
return_value);
execl(``/bin/ls/'',``ls'',``-l'',0);
printf(``This line is not printed\n'');
}
kare)aHecjTaMgenHGacCa:
Forking process
The process id is 6753 and return value is 0
The process id is 6754 and return value is 0
two lists of files in current directory
cMnaM: Rbtibtþikarman ID EtmYypÞal;rbs;vaEdlnwgxus²KñaenAeBldMeNIrkar.

vak¾GacR)ab;munBIRbtibtþikarEdlnwgTTYl)aneBlevlarbs; CPU (CPU's time)
dUcenHdMeNIrkarmYYyGacxusKñaBIdMeNIrkarbnþbnÞab;eTot. enAeBleyIgbegáItRbtibtþikar 2
eyIgGacgay RsYlrkeXIj (enAkñúgRbtibtþikarmYy) minfavaCa child b¤ parent eRBaH fork epÞrtMél 0
eTA child. eyIgGaccab;kMhusNamYyRbsinebIvaepÞrtMél -1. i.e.:
int pid; /* process identifier */
pid = fork();
if ( pid < 0 )
{ printf(``Cannot fork!! n'');

exit(1);
}
if ( pid == 0 )
{ /* Child process */ ...... }
else
{ /* Parent process pid is child's pid */
.... }
9 wait()
int wait (int *status_location) -- nwgbgçM parent process eGayrg;cMasMrab;; child

process edIm,IbBaÄb;b¤bBa©b;. wait() epÞrtMél pid rbs; child b¤ -1 sMrab;;kMhusmYy.
sBaØacakecjrbs; child RtUv)anepÞreTA status_location.
9 exit()
void exit(int status) karbBa©b;RbtibtþikarEdlehAGnuKmn_enHnigepÞrtMélsBaØa

–
cakecj (exit status value). TaMg UNIX nig C (forked) kmμviFIGacGantMélsBaØa.

-137-
vCBk
edaykarsnμt; status én 0 mann½yfa karbBa©b;edayFmμta (normal termination)
tMélepSgeTotbgðajfamankarCYbRbTHkMhusb¤minFmμta. karehA Standard library CaeRcInman
kMhusRtUv)ankMnt;enAkñúg sys/stat.h header file. eyIgGacEby:aggaymkCakarsnμt;rbs;
eyIgpÞal;.
]TahrN_eBjeljsMrab;;kmμviFI fork (forking program) KWBIedImmkRtUv)andak;eQμaH fork.c:
/* fork.c - example of a fork in a program */
/* The program asks for UNIX commands to be typed and inputted to a
string*/
/* The string is then "parsed" by locating blanks etc. */
/* Each command and sorresponding arguments are put in a args array
*/
/* execvp is called to execute these commands in child process */
/* spawned by fork() */
/* cc -o fork fork.c */
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
main()
{
char buf[1024];
char *args[64];
for (;;) {
/*
* Prompt for and read a command.
*/
printf("Command: ");
if (gets(buf) == NULL) {
printf("\n");
exit(0);
}
/*
* Split the string into arguments.
*/
parse(buf, args);
/*
* Execute the command.
*/
execute(args);
}
}
/*
* parse--split the command in buf into
* individual arguments.
*/
-138-
vCBk
parse(buf, args)
char *buf;
char **args;
{
while (*buf != NULL) {
/*
* Strip whitespace. Use nulls, so
* that the previous argument is terminated
* automatically.
*/
while ((*buf == ' ') || (*buf == '\t'))
*buf++ = NULL;
/*
* Save the argument.
*/
*args++ = buf;
/*
* Skip over the argument.
*/
while ((*buf != NULL) && (*buf != ' ') && (*buf != '\t'))
buf++;
}
*args = NULL;
}
/*
* execute--spawn a child process and execute
* the program.
*/
execute(args)
char **args;
{
int pid, status;
/*
* Get a child process.
*/
if ((pid = fork()) < 0) {
perror("fork");
exit(1);
/* NOTE: perror() produces a short error message on the

standard error describing the last error encountered during a call
to a system or library function.*/
}
/*
* The child executes the code inside the if.
*/
if (pid == 0) {
execvp(*args, args);
perror(*args);
exit(1);
-139-
vCBk
/* NOTE: The execv() vnd execvp versions of execl() are useful when
the number of arguments is unknown in advance; The arguments to
execv() and execvp() are the name of the file to be executed and a
vector of strings containing the arguments. The last argument
string must be followed by a 0 pointer. execlp() and execvp() are
called with the same arguments as execl() and execv(), but
duplicate the shell's actions in searching for an executable file in
a list of directories. The directory list is obtained from the
environment. */
}
/*
* The parent executes the wait.
*/
while (wait(&status) != pid)
/* empty */ ;
}
Exerises
Exercise 15-1
eRbI popen() bBa¢ÚneTA rwho (UNIX command) e)aHecjeTAkñúg more (UNIX command)
kμñúgkmμviFI C.
WWWW±XXXX
-140-

C Program in Khmer

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

C Program in Khmer

Uploaded by

Copyright:

Available Formats

vCBk

1.3 rcnasm<½n§kmμviFI C..............................................................................................................10

1.4 karbkRsaykmμviFI .............................................................................................................12

1.5 KMrUkarbkRsay C ..............................................................................................................15

2.3 PaBminERbRbYl (Constants) ...............................................................................................21

2.4 karRbkas (Declarations) ..................................................................................................23

2.5 RbmaNviFInBVnþsaRsþ (Arithmetic Operations)...................................................................24

2.6 RbmaNviFIeRbobeFob .........................................................................................................25

2.7 RbmaNviFItkáviTüa Logical Operations...............................................................................25

2.8 RbmaNviFI Bitwise Bitwise Operations .............................................................................26

2.9 RbmaNviFIkMenIn ..................................................................................................................28

2.10 RbmaNviFIepÞrnigkenSam ...................................................................................................28

2.11 lMdab;énGTiPaB ................................................................................................................29

3.3 RbmaNviFI ? ......................................................................................................................36

3.4 Xøa switch..........................................................................................................................37

4.3 kenSamBakübgÁab; do-while .........................................................................................43

4.4 break nig continue ...................................................................................................44

7.3 GBaaØt Register .................................................................................................................70

7.4 karRKb;RKgTMhMkargar .........................................................................................................71

8.5 array eRcInvimaRt nig pointers ............................................................................................90

8.6 Static Initialisation én Pointer Arrays .............................................................................92

8.7 Pointers nig Structures .....................................................................................................92

8.8 eRKaHfñak; Pointer Fmμta .....................................................................................................95

9.2 Calloc nig Realloc ............................................................................................................99

CMBUkTI 12: GnuKmn_ Integer, cMnYnécdnü,karpøas;bþÚr String,

12.2 cMnYnécdnü ......................................................................................................................114

12.3 karpøas;bþÚr String ............................................................................................................115

12.4 karravrknigtMerob .............................................................................................................. 116

14.3 Rbtibtiþkar Memory: <memory.h> .......................................................................136

14.4 KNitsaRsþ: <math.h> ..........................................................................................137

PasafμI B )ancUlrYmelIkTI2kñúgqñMa 1970.

eyIgGacedaHRsaybBaðaenH)an. minmanPasaeRcIneTEdlGnuBaØatdUcenH. enHRbsinebIvaeFIVeday

RbsinebIRbePTénkarRbkasRtUv)anlub C snμt;faGnuKmn_epÞrtMélRbePTcMnYnKt; integer .

printf KWCaGnuKmn_sþg;darbs; C – RtUv)anehABI main

\n mann½yfacuHbnÞat;. kare)aHecjRtUv)ancat;Ecg -- GkSreRcIn

- Object file: Binary file sresredayPasam:asIun (*.obj)

- Execution file: file EdlGacRbtibtþi ( *.exe )

- Compile: Rbtibtþikarpøas;bþÚr source file eTACa object file

- Link: RbtibtþikarbegáIt execution file BI object files

Source file Object file execution

EdlmanGnuPaB. eyIgnwgeRbI compiler enHsMrab;; C nig C++ class BIeRBaHedaysarvagayRsYlnig

dMbUgGñkebIkkmμviFI C++ kñúg VC++ edIm,IbegáItkmμviFIkñúgfile EdleQμaHrbs;vabBa©b;eday “.cpp”

kmμviFIBitR)akdrbs;GñkedayXøabBa¢a Execute enAkúñg Build menu. RbtibtþikarkmμviFIrbs;GñkenH

RbsinebIdUcenH GñkRtUvEtRtLb;eTAEkERbkmμviFIedImrbs;Gñknig compile vasaCafμI ehIydMeNIrkarva

o #include <math.h> -- sþg;da library KNitviTüa file

enHsMGagelIGefrxageRkA (External Variable). nwgBisþarCagenHenAelIkeRkay.

C BitCaPasad¾tUcéRkELg. GnuKmn_CaeRcInénPasaepSg²minRtUv)anrYmbBa©ÚlkñúgPasa C eT. e.g.

b:uEnþ vaGacERbRbYlBIm:asIunmYyeTAma:sIunmYyeTot. (cf Borland C sMrab;; PC eTA UNIX C).

bBa©Úl compile nig runkmμviFixageRkam :

printf("\t Number \t\t Square of Number\n\n");

for (i=0; i<=25;++i)

kmμviFIxageRkameRbI library KNitviTüa. bBa©Úl compile nig run vay:agRtwmRtUv.

printf("\t Number \t\t Square Root of Number\n\n");

for (i=0; i<=360; ++i)

GBaaØtnigtMélefrKWCaRKwH data objects RtUv)anerobcMkúñgkmμviFI. karRbkasbBa¢I (list)GBaaØtRtUv)an

double double-precision cMnYnek,ósTMhMeTVdg. bEnßmelIenHmancMnYnEdlmansiT§iGacRtUv)an

Gnuvtþn_CaRbePTmUldæanRKwHTaMgenH . Short nig long GnuvtþCacMnYnKt;FmμCati (integers) :

C eRbIR)as;RTg;RTaye)aHecjedIm,Ie)aHBum<GBaaØt. GnuKmn_ printf mantYGkSrkMnt;RTg;RTay

cMnaM: RTg;RTayXøabiTenAkñúg “....” GBaaØtenABIeRkaybnÞab;. eFIVeGayR)akdfalMdab;énkarkMnt;RTg;

i.e. scanf(``%c %d %f'',&ch,&i,&x);

enAkúñgniymn½yedImrbs; C scanf nwgRtUv)ansresrdUcenH :

cMnaM : & enAxagmuxGBaaØt. sUmTTYlyksBaØaenHsMrab;;\LÚvenHehIycg;cMaedIm,IbBa©Úlva.

tMélcMnYnek,óspÞúkcMnucTsPaK (123.4) b¤niTsSnþ (1e-2) b¤TaMgBIr RbePTrbs;BYkvaKW double

tMélrbs;cMnYnKt;FmμCati (integer) GacRtUv)ankMnt;kñúgeKalR)aMbI (octal) b¤eKaldb;R)aMmYy

cMNaM : Edl x = y + 2 mann½yfa x = x(y + 2) ehIy cMNaM x = x*y + 2.