j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f l ; ; l k d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j  j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a 
j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f 
d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a l l a s j k l ; j k l ; ; l k j a s ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f 
j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s g h 
j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f l ; ; l k d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a s j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f l ; ; l k d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a  j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f j j j j j k k k k l l l ; ; ; f f f d d d s s a a a j kl ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f 
d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l ll l f f f f d d d s s s a a a l l a s j k l ; j k l ; ; l k j a s ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f 
j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s g h 
j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f l ; ; l k d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a s
j jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd fl ;; lk dd sa ss dd df ds ak jk l; kj dk la ;s sk kl ;a as df jk fj fj jj js ka ;l kj ks ld ks ;a kd js sd dd ss sa aa ak kk al ll lf ff fd dd ss sa aa lk ja sd fl ;; lk dd sa ss dd df ds ak jk l; kj dk la ;s sk kl as df jk fj fj jj
j jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd fj jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja s; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd f s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a s
dd sa ss dd df ds ak jk l; kj dk la ;s sk kl ;a as df jk fj fj jj js ka ;l kj ks ld ks ;a kd js sd dd ss sa aa ak kk al ll lf ff fd dd ss sa aa ll as jk l; jk l; ;l kj as ;; ;f ff dd ds ss aa aj kl ;f ds af jk ll as jk l; jk l; ;l kj as df 
j jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd fj jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja s; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sg h
jj jj jk kk kl ll ;; ;f ff dd ds ss aa aj kl ;f ds af jk ll as jk l; jk l; ;l kj as df l; ;l kd ds as sd dd fd sa kj kl ;k jd kl a; ss kk l; aa sd fj kf jf jj jj sk a; lk jk sl dk s; ak dj ss dd ds ss aa aa kk ka ll ll ff ff dd ds ss aa as jj jj jk kk kl ll ;; ;f ff dd ds ss aa aj kl ;f ds af jk ll as jk l; jk l; ;l kj as df l; ;l kd ds as sd dd fd sa kj kl ;k jd kl a; ss kk l; aa sd fj kf jf jj jj sk a; lk jk sl dk s; ak dj ss dd ds ss aa aa kk ka ll ll ff ff dd ds ss aa a
jj jj jk kk kl ll ;; ;f ff dd ds ss aa aj kl ;f ds af jk ll as jk l; jk l; ;l kj as df jj jj jk kk kl ll ;; ;f ff dd ds ss aa aj kl ;f ds af jk ll as jk l; jk l; ;l kj as ;; ;f ff dd ds ss aa aj kl ;f ds af jk ll as jk l; jk l; ;l kj as df 
d ds as sd dd fd sa kj kl ;k jd kl a; ss kk l; aa sd fj kf jf jj jj sk a; lk jk sl dk s; ak dj ss dd ds ss aa aa kk ka ll ll ff ff dd ds ss aa al la sj kl ;j kl ;; lk ja s; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd f
jj jj jk kk kl ll ;; ;f ff dd ds ss aa aj kl ;f ds af jk ll as jk l; jk l; ;l kj as df jj jj jk kk kl ll ;; ;f ff dd ds ss aa aj kl ;f ds af jk ll as jk l; jk l; ;l kj as ;; ;f ff dd ds ss aa aj kl ;f ds af jk ll as jk l; jk l; ;l kj as gh 
j jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd fl ;; lk dd sa ss dd df ds ak jk l; kj dk la ;s sk kl ;a as df jk fj fj jj js ka ;l kj ks ld ks ;a kd js sd dd ss sa aa ak kk al ll lf ff fd dd ss sa aa saldk slkdk akdf slal la ladk kadd dad kslskf l jfa fklsdk dkfhl a ald slkf la al al dfs
asdh laskl la;s klsdkj sa;slkdl llassdfs ss sddfj jfkdsla;sl kdfksla; ;;;;a alskd df fdksl la la alal al fa fal fall fa flk fsdkl lskaf sdkfhsk alhdhgla aldgh alhss
j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f l ; ; l k d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a ;aksl as as kf
j jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd fj jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja s; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd f sll si sal sfkdsl dfd lla sdkasd dssdf fddssa ssall;; ;;ldk alskdh kkksldf fdksls slldl
dd sa ss dd df ds ak jk l; kj dk la ;s sk kl ;a as df jk fj fj jj js ka ;l kj ks ld ks ;a kd js sd dd ss sa aa ak kk al ll lf ff fd dd ss sa aa ll as jk l; jk l;
l l f f f f d d d s s s a a a l l a s j k l ; j k l ; ; l k j a s ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f 
j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f j j j j j k k k k l l l ; ; ; f f f d d d s s lals
j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f l ; ; l k d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f 
d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l h s sj jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd fj jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja s; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd f s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a s
dd sa ss dd df ds ak jk l; kj dk la ;s sk kl ;a as df jk fj fj jj js ka ;l kj ks ld ks ;a kd js sd dd ss sa aa ak kk al ll lf ff fd dd ss sa aa ll as jk l; jk l; s
juj ijoj puio pjuj ijoj puio pjuj ijoj jkll ;iop eiwo qpdu ieqw puio pjuu uior ewqd eaju jijo jpui opju jiwu ewqo ptio wpjo jpui opju jijo jpui opju uuio rewq deaj ujij ojpu iopj ujij ojpu iopj ujij ojpu iopj uuui orew qdea juji jojp uiop juji jojp uiop juji jojp uiop juuw uewq opti owpu iore wqde aiof dsas ssad fdjj kll; iope iwoq pdui eqwu ewqo ptio wpde ajuj ijoj puio pjuj iwue wqop tiow pjoj puio pjuj ijoj puio pjuu uior ewqd eaju jijo jpui oelo llsw lopj ujij ojpu iopj ujij ojpu iopj uuui orew qdea juji joje loll swlo puio pjuj ijoj puio pjuj ijoj puio pjuu wuew elol lswl oqop tiow puio rewq deai ofds asss adfd jjkl l;io peiw oqpd uieq wuew qopt iowp kide kide kide kide kide kide kide kide kide kide kide kide loll swlo elol lswl oelo llsw loas weop qpie ola; ouie ssla lsdk la;s lldf pjuj ijoj puio pjuj ijoj puio pjuu wuew elol lswl oqop tiow puio rewq deai ofds asss adfd jjkl l;io peiw oqpd uieq wuew qopt iowp kide kide kide kide kide ds d ef d deki deki deki deki deki deki delo llsw loel olls wloe loll swlo aswe opqp ieol a;ou iety oeka  ;l  kj k s ld  ks  ;a k d js  sd  dd s s sa  aa  ak k k al  ll  lf f f fd  dd  ss s a aa  sal dk s lkdk  akd f sl al l a la dk k add  dad  ksls kf l  jfa  fkl sdk  dkfh l a  ald  slkf  la  al a l df s as dh l askl  la; s kl sdkj  sa; slkd l ll assd fs s s sd dfj  jfkd sla; sl k dfks la;  ;;;; a al skd  df f dksl  la  la a lal  al f a fa l fa ll f a fl k fs dkl  lska f sd kfhs k al hdhg la a ldgh  alh ssty tiop sawe qopu 'soe ioqp 'sa" ieoh goie opeo iuts uedk oepp qoei owie ladf ieoq eyto uwoe yrow dsof pqpw eopq uyta ytyy tyio ytyt yeyt yyyy ytyy yttt tttt tttt seit iowp tosh ghgh fhsd ioap lgio eiha ldog iioa hgkd ihdl sd;'  ahl ahd/ lash ? ah gipe ?sha sie. flsh sdie '" s ahgi ehid soha heoi ehhg hish eyth sgys hdgi shds iths dhgj sdih dila hdgl hley itui weoh laso pdlh goei hghe tyah gl;a da;d kgie h"
a sdh  lask l la ;s k lsdk j sa ;slk dl l lass dfs  ss s ddfj  jfk dsla ;sl  kdfk sla;  ;;; ;a a lskd  df  fdks l la  la  alal  al  fa f al f all  fa f lk f sdkl  lsk af s dkfh sk a lhdh gla  aldg h al hss
tyti opsa weqo pu's oeio qp's a"ie ohgo ieop eoiu tsue dkoe ppqo eiow iela dfie oqey touw oeyr owds ofpq pweo pquy tayt yyty ioyt ytye ytyy yyyt yyyt tttt tttt ttse itio wpto shgh ghfh sdio aplg ioei hald 
joj puio pjuu uior ewqd eaju jijo jpui oelo llsw lopj ujij ojpu iopj ujij ojpu iopj uuui orew qdea juji joje loll swlo puio pjuj ijoj puio pjuj ijoj puio pjuu wuew elol lswl oqop tiow puio rewq deai ofds asss adfd jjkl l;io peiw oqpd uieq wuew qopt iowp kide kide kide kide kide kide kide kide kide kide kide kide loll swlo elol lswl oelo llsw loas weop qpie ola; ouie ssla lsdk la;s lldf pjuj ijoj puio pjuj i
tu ieop qooe igho ioai edek idek idek idek idek idek idek idek idek idek idel olls wloe loll swlo elol lswl oasw eopq pieo la;o uies slal sdkl a;sl ldfp juji jojp uide kide kide kide kide kide kide kide kide kide kide loll swlo elol lswl oelo llsw loas weop qpie ola; ouie ssla lsdk la;s lldf pjuj ijoj puis lahs l;al sa;; ;alk d'ls hlh" ashg hl"L :'sa laDS FFou ofeh qipr o'wl opju jijo jpui opju jijo jpui opju uuio rewq deaj ujij ojel olls wlop uiop juji jojp uiop juji jojp uiop juuw uewe loll swlo qopt iowp uior ewqd eaio fdsa sssa dfdj jkll ;iop eiwo qpdu ieqw uewq opti owpk idek idek idek idek idek idek idek idek idek idek idek idel olls wloe loll swlo elol lswl oasw eopq pieo la;o uies slal sdkl a;sl ldfp juji jojp uiop juji jojp uiop tyti opsa weqo pu's oeio qp's a"ie ohgo ieop eoiu tsue dkoe ppqo eiow iela dfie oqey touw oeyr owds ofpq pweo pquy tayt yyty ioyt ytye ytyy yyyt yyyt tttt tttt ttse itio wpto shgh ghfh sdio aplg ioei hald jojp uiop juuu iore wqde ajuj ijoj puio elol lswl opju jijo jpui opju jijo jpui opju uuio rewq deaj ujij ojel olls wlop uiop juji jojp uiop juji jojp uiop juuw uewe loll swlo qopt iowp uior ewqd eaio fdsa sssa dfdj jkll ;iop eiwo qpdu ieqw uewq opti owpk idek idek idek idek idek idek idek idek idek idek idek idel olls wloe loll swlo elol lswl oasw eopq pieo la;o uies slal sdkl a;sl ldfp juji jojp uiop juji sssa dfdj jkll ;iop eiwo qpdu ieqw uewq opti owpk idek idek idek idek idek idek idek idek idek idek idek idel olls wloe loll swlo elol lswl oasw eopq pieo la;o uies slal sdkl a;sl ldfp juji jojp uiop juji 
tui eopq ooei ghoi oaie deki deki deki deki deki deki deki deki deki deki delo llsw loel olls wloe loll swlo aswe opqp ieol a;ou iess lals dkla ;sll dfpj ujij ojpu idek idek idek idek idek idek idek idek idek idek idel olls wloe loll swlo elol lswl oasw eopq pieo la;o uies slal sdkl a;sl ldfp juji jojp uisl ahsl ;als a;;; alkd 'lsh lh"a shgh l"L: 'sal aDSF Fouo fehq ipro 'wlo pjuj ijoj puio pjuj ijoj puio pjuu uior ewqd eaju jijo jelo llsw lopu iopj ujij ojpu iopj ujij ojpu iopj uuwu ewel olls wloq opti owpu iore wqde aiof dsas ssad fdjj kll; iope iwoq pdui eqwu ewqo ptio wpki deki deki deki deki deki deki deki deki deki deki deki delo llsw loel olls wloe loll swlo aswe opqp ieol a;ou iess lals dkla ;sll dfpj ujij ojpu iopj ujij ojpu iopt ytio psaw eqop u'so eioq p'sa "ieo hgoi eope oiut sued koep pqoe iowi eoqpd uieq wuew qopt iowp kide kide kide kide kide kide kide kide kide kide kide kide loll swlo elol lswl oelo llsw kdgh alldlal hdkds ald aldslsss s
op juuu iore wqde ajuj ijoj puio pjuj ijoj puio pjuj ijoj puio pjuu wuew qopt iowp uior ewqd eaio fdsa sssa dfdj jkll ;iop eiwo qpdu ieqw uewq opti owpd eaju jijo jpui opju jiwu ewqo ptio wpjo jpui opju jijo jpui opju uuio rewq deaj ujij ojpu ioel olls wlop juji jojp uiop juji jojp uiop juuu iore wqde ajuj ijoj elol lswl opui opju jijo jpui opju jijo jpui opju uwue welo llsw loqo ptio wpui orew qdea iofd sass sadf djjk ll;i opei woqp duie qwue wqop tiow pkid ekid ekid ekid ekid ekid ekid ekid ekid ekid ekid ekid elol lswl oelo llsw loel olls wloa sweo pqpi eola ;oui essl alsd kla; slld fpju jijo jpui opju jijo jpui opju uwue welo llsw loqo ptio wpui orew qdea iofd sass sadf djjk ll;i opei woqp duie qwue wqop tiow pkid ekid ekid ekid ekid edsd ef 
n,dl ladc nzdi eytz odig n,dl ladc nzdi eytz odig n,dl ladc nzdi eytz odig tyea eiqt opto n,dl ladc nzdi eytz odig ,,<. adlf .alh /sld h?gh itup oena lhdg llhe n,dl ladc nzdi eytz odig ,,xh glxa hieo pqo oqpd uieq wuew qopt iowp kide kide kide kide kide kide kide kide kide kide kide kide loll swlo elol lswl oelo llsw n,dl ladc nzdi eytz odig lsal glls dlfl laia mint heom tnth eolo ghti sthi ngis eral lyve ryst arsg hall dgho epot ujls ahla hdgj apeo poeo oihg opeo hgoe hahl bclm xbx, cnb, hslg as>s hlas llad ieas oelh /slg ahas liel hghl adfi eytg hbnh lgie thtr yopj uuui orew qdea juji jojp uiop juji jojp uiop juji jojp uiop juuw uewq opti owpu iore wqde aiof dsas ssad fdjj kll; iope iwoq pdui eqwu ewqo ptio wpde ajuj ijoj puio pjuj iwue wqop tiow pjoj puio pjuj ijoj puio pjuu uior ewqd eaju jijo jpui oelo llsw lopj ujij ojpu iopj ujij ojpu iopj uuui orew qdea juji joje loll swlo puio pjuj ijoj puio pjuj ijoj puio pjuu wuew elol lswl oqop tiow puio rewq deai ofds asss adfd jjkl l;io peiw oqpd uieq wuew qopt iowp kide kide kide kide kide kide kide kide kide kide kide kide loll swlo elol lswl oelo llsw loas weop qpie ola; ouie ssla lsdk la;s lldf pjuj ijoj puio pjuj ijoj puio pjuu wuew elol lswl oqop tiow puio rewq deai ofds asss adfd jjkl l;io peiw oqpd uieq wuew qopt iowp kide kide kide kide kide dsde fdille ahdlapeotoa hakd diepoe dishingn sioepgn cn.zpeop sdkghpehslapl ahdogp ahdkg saope ad ad jjk ek iopu uiopead 
n ,dll adcn zdie ytzo dign ,dll adcn zdie ytzo dign ,dll adcn zdie ytzo digt yeae iqto pton ,dll adcn zdie ytzo dig, ,<.a dlf. alh/ sldh ?ghi tupo enal hdgl lhen ,dll adcn zdie ytzo dig, ,xhg lxah ieop qo paldfhl paldfhl paldfhlpa l dfhl jgdsfnri lsoe paaosti sdhlsgpo akhdk eoepo pdo akd skdlae dhg donc .d>>d <<sd kdi skt
n ,dll adcn zdie ytzo digl salg llsd lfll aiam inth eomt nthe olog htis thin gise rall yver ysta rsgh alld ghoe potu jlsa hlah dgja peop oeoo ihgo peoh goeh ahlb clmx bx,c nb,h slga s>sh lasl ladi easo elh/ slga hasl ielh ghla dfie ytgh bnhl giet htry lanc.dlei hgoei tiehal kdjgi paldfhl lsoe paaosti sdhlsgpo akhdk eoepo pdo
j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f l ; ; l k d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a  j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f j j j j j k k k k l l l ; ; ; f f f d d d s s a a a j kl slk
n,dl ladc nzdi eytz odig ,,xh glxa hieo pqo oqpd uieq wuew qopt iowp kide kide kide kide kide kide kide kide kide kide kide kide loll swlo elol lswl oelo llsw
n,dl ladc nzdi eytz odig lsal glls dlfl laia mint heom tnth eolo ghti sthi ngis eral lyve ryst arsg hall dgho epot ujls ahla hdgj apeo poeo oihg opeo hgoe hahl j j j j j k k k k l l l ;  f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f l ; ; l k d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f j j j j j k k k k l l l ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s ; ; ; f f f d d d s s s a a a j k l ; f d s a f j k l l a s j k l ; j k l ; ; l k j a s d f 
d d s a s s d d d f d s a k j k l ; k j d k l a ; s s k k l ; a a s d f j k f j f j j j j s k a ; l k j k s l d k s ; a k d j s s d d d s s s a a a a k k k a l l h s sj jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd fj jj jj kk kk ll l; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja s; ;; ff fd dd ss sa aa jk l; fd sa fj kl la sj kl ;j kl ;; lk ja sd f s ; a k d j s s d d d s s s a a a a k k k a l l l l f f f f d d d s s s a a a s
dd sa ss dd df ds ak jk l; kj dk la ;s sk kl ;a as df jk fj fj jj js ka ;l kj ks ld ks ;a kd js sd dd ss sa aa ak kk al ll lf ff fd dd ss sa aa ll as jk l; jk l; sjujijo jpuiopj ujijojp uiopjuj ijojjkl l;iopei woqpdui eqwpuio pjuuuio rewqdea jujijoj puiopju jiwuewq optiowp jojpuio pjujijo jpuiopj uuuiore wqdeaju jijojpu iopjuji jojpuio pjujijo jpuiopj uuuiore wqdeaju jijojpu iopjuji jojpuio pjujijo jpuiopj uuwuewq optiowp uiorewq deaiofd sasssad fdjjkll ;iopeiw oqpduie qwuewqo ptiowpd eajujij ojpuiop jujiwue wqoptio wpjojpu iopjuji jojpuio pjuuuio rewqdea jujijoj puioelo llswlop jujijoj puiopju jijojpu iopjuuu iorewqd eajujij ojeloll swlopui opjujij ojpuiop jujijoj puiopju uwuewel ollswlo qoptiow puiorew qdeaiof dsasssa dfdjjkl l;iopei woqpdui eqwuewq optiowp kidekid ekideki dekidek idekide kidekid ekideki dekidel ollswlo elollsw loeloll swloasw eopqpie ola;oui esslals dkla;sl ldfpjuj ijojpui opjujij ojpuiop juuwuew elollsw loqopti owpuior ewqdeai ofdsass sadfdjj kll;iop eiwoqpd uieqwue wqoptio wpkidek idekide kidekid eds def  ddekid ekideki dekidek idekide lollswl oelolls wloelol lswloas weopqpi eola;ou ietyoek a ;l kj  ks ld  ks ;a k d js sd  dd ss  sa aa a k kk al  ll lf  ff fd d d ss sa  aa sal dk slkd k akdf  slal la  ladk k add dad  kslskf  l jfa  fklsdk  dkfhl a  ald sl kf la a l al df s asdh  laskl l a;s kls dkj sa; slkdl l lassdfs  ss sdd fj jfkd sla;sl  kdfksla ; ;;;;a  alskd  df fdks l la la  alal a l fa fa l fall  fa flk  fsdkl l skaf sd kfhsk a lhdhgla  aldgh  alhssty tiopsaw eqopu's oeioqp' sa"ieoh goieope oiutsue dkoeppq oeiowie ladfieo qeytouw oeyrowd sofpqpw eopquyt aytyyty ioytyty eytyyyy ytyyytt ttttttt ttseiti owptosh ghghfhs dioaplg ioeihal dogiioa hgkdihd lsd;' a hlahd/l ash? ah gipe?sh asie.fl shsdie' " sahgi ehidsoh aheoieh hghishe ythsgys hdgishd sithsdh gjsdihd ilahdgl hleyitu iweohla sopdlhg oeihghe tyahgl; ada;dkg ieh"
as dh lask l la;s  klsdkj  sa;slkd l llass dfs ss  sddfj j fkdsla; sl kdfk sla; ;; ;;a als kd df f dksl la  la ala l al fa  fal fa ll fa f lk fsdk l lskaf  sdkfhs k alhdh gla ald gh alhs s
tytio psaweqo pu'soei oqp'sa" ieohgoi eopeoiu tsuedko eppqoei owielad fieoqey touwoey rowdsof pqpweop quytayt yytyioy tytyeyt yyyyyty yyttttt tttttts eitiowp toshghg hfhsdio aplgioe ihald
j ojpuiop juuuior ewqdeaj ujijojp uioelol lswlopj ujijojp uiopjuj ijojpui opjuuui orewqde ajujijo jelolls wlopuio pjujijo jpuiopj ujijojp uiopjuu wuewelo llswloq optiowp uiorewq deaiofd sasssad fdjjkll ;iopeiw oqpduie qwuewqo ptiowpk idekide kidekid ekideki dekidek idekide kidekid ekidelo llswloe lollswl oelolls wloaswe opqpieo la;ouie sslalsd kla;sll dfpjuji jojpuio pjuji
t uieopqo oeighoi oaiedek idekide kidekid ekideki dekidek idekide kidelol lswloel ollswlo elollsw loasweo pqpieol a;ouies slalsdk la;slld fpjujij ojpuide kidekid ekideki dekidek idekide kidekid ekidelo llswloe lollswl oelolls wloaswe opqpieo la;ouie sslalsd kla;sll dfpjuji jojpuis lahsl;a lsa;;;a lkd'lsh lh"ashg hl"L:'s alaDSFF ouofehq ipro'wl opjujij ojpuiop jujijoj puiopju uuiorew qdeajuj ijojelo llswlop uiopjuj ijojpui opjujij ojpuiop juuwuew elollsw loqopti owpuior ewqdeai ofdsass sadfdjj kll;iop eiwoqpd uieqwue wqoptio wpkidek idekide kidekid ekideki dekidek idekide kidekid elollsw loeloll swloelo llswloa sweopqp ieola;o uiessla lsdkla; slldfpj ujijojp uiopjuj ijojpui optytio psaweqo pu'soei oqp'sa" ieohgoi eopeoiu tsuedko eppqoei owielad fieoqey touwoey rowdsof pqpweop quytayt yytyioy tytyeyt yyyyyty yyttttt tttttts eitiowp toshghg hfhsdio aplgioe ihaldjo jpuiopj uuuiore wqdeaju jijojpu ioeloll swlopju jijojpu iopjuji jojpuio pjuuuio rewqdea jujijoj elollsw lopuiop jujijoj puiopju jijojpu iopjuuw uewelol lswloqo ptiowpu iorewqd eaiofds asssadf djjkll; iopeiwo qpduieq wuewqop tiowpki dekidek idekide kidekid ekideki dekidek idekide kidelol lswloel ollswlo elollsw loasweo pqpieol a;ouies slalsdk la;slld fpjujij ojpuiop jujisss adfdjjk ll;iope iwoqpdu ieqwuew qoptiow pkideki dekidek idekide kidekid ekideki dekidek idekide lollswl oelolls wloelol lswloas weopqpi eola;ou iesslal sdkla;s lldfpju jijojpu iopjuji 
tuieop qooeigh oioaied ekideki dekidek idekide kidekid ekideki dekidel ollswlo elollsw loeloll swloasw eopqpie ola;oui esslals dkla;sl ldfpjuj ijojpui dekidek idekide kidekid ekideki dekidek idekide lollswl oelolls wloelol lswloas weopqpi eola;ou iesslal sdkla;s lldfpju jijojpu islahsl ;alsa;; ;alkd'l shlh"as hghl"L: 'salaDS FFouofe hqipro' wlopjuj ijojpui opjujij ojpuiop juuuior ewqdeaj ujijoje lollswl opuiopj ujijojp uiopjuj ijojpui opjuuwu eweloll swloqop tiowpui orewqde aiofdsa sssadfd jjkll;i opeiwoq pduieqw uewqopt iowpkid ekideki dekidek idekide kidekid ekideki dekidek ideloll swloelo llswloe lollswl oasweop qpieola ;ouiess lalsdkl a;slldf pjujijo jpuiopj ujijojp uioptyt iopsawe qopu'so eioqp's a"ieohg oieopeo iutsued koeppqo eiowie
opjuuui orewqde ajujijo jpuiopj ujijojp uiopjuj ijojpui opjuuwu ewqopti owpuior ewqdeai ofdsass sadfdjj kll;iop eiwoqpd uieqwue wqoptio wpdeaju jijojpu iopjuji wuewqop tiowpjo jpuiopj ujijojp uiopjuu uiorewq deajuji jojpuio elollsw lopjuji jojpuio pjujijo jpuiopj uuuiore wqdeaju jijojel ollswlo puiopju jijojpu iopjuji jojpuio pjuuwue welolls wloqopt iowpuio rewqdea iofdsas ssadfdj jkll;io peiwoqp duieqwu ewqopti owpkide kidekid ekideki dekidek idekide kidekid ekideki delolls wloelol lswloel ollswlo asweopq pieola; ouiessl alsdkla ;slldfp jujijoj puiopju jijojpu iopjuuw uewelol lswloqo ptiowpu iorewqd eaiofds asssadf djjkll; iopeiwo qpduieq wuewqop tiowpki dekidek idekide kidedsd ef 
n,d lladcnz dieytzo dign,dl ladcnzd ieytzod ign,dll adcnzdi eytzodi gtyeaei qtopton ,dlladc nzdieyt zodig,, <.adlf. alh/sld h?ghitu poenalh dgllhen ,dlladc nzdieyt zodig,, xhglxah ieopqo n,dllad cnzdiey tzodigl salglls dlfllai aminthe omtnthe ologhti sthingi serally verysta rsghall dghoepo tujlsah lahdgja peopoeo oihgope ohgoeha hlbclmx bx,cnb, hslgas> shlasll adieaso elh/slg ahaslie lhghlad fieytgh bnhlgie thtryop juuuior ewqdeaj ujijojp uiopjuj ijojpui opjujij ojpuiop juuwuew qoptiow puiorew qdeaiof dsasssa dfdjjkl l;iopei woqpdui eqwuewq optiowp deajuji jojpuio pjujiwu ewqopti owpjojp uiopjuj ijojpui opjuuui orewqde ajujijo jpuioel ollswlo pjujijo jpuiopj ujijojp uiopjuu uiorewq deajuji jojelol lswlopu iopjuji jojpuio pjujijo jpuiopj uuwuewe lollswl oqoptio wpuiore wqdeaio fdsasss adfdjjk ll;iope iwoqpdu ieqwuew qoptiow pkideki dekidek idekide kidekid ekideki dekidek idekide lollswl oelolls wloelol lswloas weopqpi eola;ou iesslal sdkla;s lldfpju jijojpu iopjuji jojpuio pjuuwue welolls wloqopt iowpuio rewqdea iofdsas ssadfdj jkll;io peiwoqp duieqwu ewqopti owpkide kidekid ekideki dedsdef  
n,dll adcnzdi eytzodi gn,dlla dcnzdie ytzodig n,dllad cnzdiey tzodigt yeaeiqt opton,d lladcnz dieytzo dig,,<. adlf.al h/sldh? ghitupo enalhdg llhen,d lladcnz dieytzo dig,,xh glxahie opqo
n, dlladcn zdieytz odiglsa lgllsdl fllaiam intheom tntheol oghtist hingise rallyve rystars ghalldg hoepotu jlsahla hdgjape opoeooi hgopeoh goehahl bclmxbx ,cnb,hs lgas>sh lasllad ieasoel h/slgah aslielh ghladfi eytghbn hlgieth try.

An Introduction to the
Linux Command Shell
For Beginners
Presented by:
Victor Gedris
In Co-Operation With:
The Ottawa Canada Linux Users Group
and
ExitCertifiedCopyright and Redistribution
This manual was written with the intention of being a helpful guide to Linux users who are trying
to become familiar with the Bash shell and basic Linux commands. To make this manual useful to
the widest range of people, I decided to release it under a free documentation license, with the
hopes that people benefit from it by updating it and re-distributing modified copies. You have
permission to modify and distribute this document, as specified under the terms of the GNU Free
Documentation License. Comments and suggestions for improvement may be directed to:
vic@gedris.org.
This document was created using an Open Source office application called Open Office. The file
format is non-proprietary, and the document is also published in various other formats online.
Updated copies will be available on Vic Gedris' web site [http://vic.dyndns.org/]. For
more information on Open Office, please visit http://www.openoffice.org/.
Copyright ++ 2003 Victor Gedris.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU
Free Documentation License, Version 1.1 or any later version published by the Free Software
Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover
Texts. A copy of the license is available from the Free Software Foundation's website:
http://www.fsf.org/copyleft/fdl.html
Document Version: 1.2, 2003-06-251.0
Introduction
The purpose of this document is to provide the reader with a fast and simple introduction to using
the Linux command shell and some of its basic utilities. It is assumed that the reader has zero or
very limited exposure to the Linux command prompt. This document is designed to accompany an
instructor-led tutorial on this subject, and therefore some details have been left out. Explanations,
practical examples, and references to DOS commands are made, where appropriate.
1.1
What is a command shell?
A program that interprets commands
Allows a user to execute commands by typing them manually at a terminal, or automatically
in programs called shell scripts.
A shell is not an operating system. It is a way to interface with the operating system and run
commands.
1.2
What is BASH?
BASH = Bourne Again SHell
Bash is a shell written as a free replacement to the standard Bourne Shell (/bin/sh)
originally written by Steve Bourne for UNIX systems.
It has all of the features of the original Bourne Shell, plus additions that make it easier to
program with and use from the command line.
Since it is Free Software, it has been adopted as the default shell on most Linux systems.
1.3
How is BASH different from the DOS command prompt?
Case Sensitivity: In Linux/UNIX, commands and filenames are case sensitive, meaning
that typing +,%EXIT"/- instead of the proper #%'exit%$. is a mistake.
%/)\(** vs. !$*/#)(: In DOS, the forward-slash &$./,"! is the command argument delimiter,
while the backslash '$,\$,# is a directory separator. In Linux/UNIX, the
!'.//+) is the directory separator, and the %!(\-/* is an escape character. More
about these special characters in a minute!
Filenames: The DOS world uses the .(%eight dot three)*- filename convention, meaning
that all files followed a format that allowed up to 8 characters in the
filename, followed by a period (!')dot&**), followed by an option extension,
up to 3 characters long (e.g. FILENAME.TXT). In UNIX/Linux, there is
no such thing as a file extension. Periods can be placed at any part of the
filename, and &"%extensions),! may be interpreted differently by all
programs, or not at all.1.4
Special Characters
Before we continue to learn about Linux shell commands, it is important to know that there are
many symbols and characters that the shell interprets in special ways. This means that certain
typed characters: a) cannot be used in certain situations, b) may be used to perform special
operations, or, c) must be #$.escaped(#* if you want to use them in a normal way.
Character Description
\ Escape character. If you want to reference a special character, you must "'"escape!+! it
with a backslash first.
Example:
/
touch /tmp/filename\*
Directory separator, used to separate a string of directory names.
Example:
/usr/src/linux
. Current directory. Can also **(hide'#) files when it is the first character in a filename.
.. Parent directory
~ User's home directory
* Represents 0 or more characters in a filename, or by itself, all files in a directory.
Example:
?
Represents a single character in a filename.
Example:
[ ]
cd /var/log ; less messages
Command separator as above, but only runs the second command if the first one
finished without errors.
Example:
&
more < phonenumbers.txt
Command separator. Allows you to execute multiple commands on a single line.
Example:
&&
echo $#'Mary 555-1234,/" >> phonenumbers.txt
Redirect a file as input to a program.
Example:
;
ls > myfiles.txt
Redirect the output of a command onto the end of an existing file.
Example:
<
ls | more
Redirect output of a command into a new file. If the file already exists, over-write it.
Example:
>>
hello[0-2].txt represents the names hello0.txt,
hello1.txt, and hello2.txt
-,*Pipe),&. Redirect the output of one command into another command.
Example:
>
hello?.txt can represent hello1.txt, helloz.txt, but not
hello22.txt
Can be used to represent a range of values, e.g. [0-9], [A-Z], etc.
Example:
|
pic*2002 can represent the files pic2002, picJanuary2002,
picFeb292002, etc.
cd /var/logs && less messages
Execute a command in the background, and immediately get your shell back.
Example:
find / -name core > /tmp/corefiles.txt &1.5
Executing Commands
The Command PATH:
Most common commands are located in your shell's *.)PATH(&$, meaning that you can just
type the name of the program to execute it.
Example: Typing ).* ls"/& will execute the *!' ls"') command.
Your shell's ###PATH)&" variable includes the most common program locations, such as
/bin, /usr/bin, /usr/X11R6/bin, and others.
To execute commands that are not in your current PATH, you have to give the complete
location of the command.
Examples:
/home/bob/myprogram
./program (Execute a program in the current directory)
~/bin/program (Execute program from a personal bin directory)
Command Syntax
Commands can be run by themselves, or you can pass in additional arguments to make them do
different things. Typical command syntax can look something like this:
command [-argument] [-argument] [--argument] [file]
Examples:
ls List files in current directory
ls -l Lists files in *$-long+,) format
ls -l --color As above, with colourized output
cat filename Show contents of a file
cat -n filename Show contents of a file, with line numbers2.0
Getting Help
When you're stuck and need help with a Linux command, help is usually only a few keystrokes
away! Help on most Linux commands is typically built right into the commands themselves,
available through online help programs (!-.man pages"-+ and %-*info pages&/)), and of course online.
2.1
Using a Command's Built-In Help
Many commands have simple #)!help)"( screens that can be invoked with special command flags.
These flags usually look like "$*-h$%' or ,&*--help!"..
Example:
2.2
grep --help
Online Manuals: !)#Man Pages.*/
The best source of information for most commands can be found in the online manual pages,
known as *.-man pages$%, for short. To read a command's man page, type $',man command$!-.
Examples: man ls
man man
Get help on the #))ls$-- command.
A manual about how to use the manual!
To search for a particular word within a man page, type +!*/word,"+. To quit from a man page, just
type the *"%Q-!. key.
Sometimes, you might not remember the name of Linux command and you need to search for it.
For example, if you want to know how to change a file's permissions, you can search the man page
descriptions for the word $"%permission!,) like this:
man -k permission
If you look at the output of this command, you will find a line that looks something like:
chmod
(1)
- change file access permissions
Now you know that $/'chmod/*. is the command you were looking for. Typing %-(man chmod-!, will
show you the chmod command's manual page!
2.3
Info Pages
Some programs, particularly those released by the Free Software Foundation, use info pages as
their main source of online documentation. Info pages are similar to man page, but instead of
being displayed on one long scrolling screen, they are presented in shorter segments with links to
other pieces of information. Info pages are accessed with the *#,info$/% command, or on some
Linux distributions, ')'pinfo#-. (a nicer info browser).
For example:
info df
Loads the !"/df,)# info page.3.0
Navigating the Linux Filesystem
The Linux filesystem is a tree-like hierarchy hierarchy of directories and files. At the base of the
filesystem is the %%"/$+# directory, otherwise known as the )/'root!,/ (not to be confused with the root
user). Unlike DOS or Windows filesystems that have multiple $-"roots()!, one for each disk drive, the
Linux filesystem mounts all disks somewhere underneath the / filesystem. The following table
describes many of the most common Linux directories.
3.1
The Linux Directory Layout
Directory
Description
The nameless base of the filesystem. All other directories, files, drives, and
devices are attached to this root. Commonly (but incorrectly) referred to as
the ,/"slash*"& or ()./.&( directory. The !"$/),& is just a directory separator, not a
directory itself.
/bin Essential command binaries (programs) are stored here (bash, ls, mount,
tar, etc.)
/boot Static files of the boot loader.
/dev Device files. In Linux, hardware devices are acceessd just like other files, and
they are kept under this directory.
/etc Host-specific system configuration files.
/home Location of users' personal home directories (e.g. /home/susan).
/lib Essential shared libraries and kernel modules.
/proc Process information pseudo-filesystem. An interface to kernel data structures.
/root The root (superuser) home directory.
/sbin Essential system binaries (fdisk, fsck, init, etc).
/tmp Temporary files. All users have permission to place temporary files here.
/usr The base directory for most shareable, read-only data (programs, libraries,
documentation, and much more).
/usr/bin Most user programs are kept here (cc, find, du, etc.).
/usr/include Header files for compiling C programs.
/usr/lib Libraries for most binary programs.
/usr/local $&&Locally*-) installed files. This directory only really matters in environments
where files are stored on the network. Locally-installed files go in
/usr/local/bin, /usr/local/lib, etc.). Also often used for
software packages installed from source, or software not officially shipped
with the distribution.
/usr/sbin Non-vital system binaries (lpd, useradd, etc.)
/usr/share Architecture-independent data (icons, backgrounds, documentation, terminfo,
man pages, etc.).
/usr/src Program source code. E.g. The Linux Kernel, source RPMs, etc.
/usr/X11R6 The X Window System.
/var Variable data: mail and printer spools, log files, lock files, etc.3.2
Commands for Navigating the Linux Filesystems
The first thing you usually want to do when learning about the Linux filesystem is take some time
to look around and see what's there! These next few commands will: a) Tell you where you are,
b) take you somewhere else, and c) show you what's there. The following table describes the basic
operation of the pwd, cd, and ls commands, and compares them to certain DOS commands that
you might already be familiar with.
Linux Command
DOS Command
Description
pwd cd )).Print Working Directory+!'.
location in the directory tree.
cd cd, chdir #$-Change Directory$&.. When typed all by itself, it
returns you to your home directory.
cd directory cd directory Change into the specified directory
Example: cd /usr/src/linux
cd ~
cd ..
Shows the current
name.
*-.~($+ is an alias for your home directory. It can be
used as a shortcut to your '+-home",!, or other
directories relative to your home.
cd..
cd -
Move up one directory. For example, if you are in
/home/vic and you type (/&cd ..%)+, you will end
up in /home.
Return to previous directory. An easy way to get
back to your previous location!
ls dir /w
ls directory dir directory List the files in the specified directory.
List all files in the current directory, in column
format.
Example: ls /var/log
ls -l dir List files in %#$long#%$ format, one file per line. This
also shows you additional info about the file, such
as ownership, permissions, date, and size.
ls -a dir /a List all files, including )'.hidden&#$ files. Hidden files
are those files that begin with a +,)."+,, e.g. The
.bash_history file in your home directory.
ls -ld
directory
A ,*.long!+* list of "*)directory.&*, but instead of showing
the directory contents, show the directory's detailed
information. For example, compare the output of
the following two commands:
ls -l /usr/bin
ls -ld /usr/bin
ls /usr/bin/d*
dir d*.*
List all files whose names begin with the letter )+$d,-(
in the /usr/bin directory.4.0
Piping and Re-Direction
Before we move on to learning even more commands, let's side-track to the topics of piping and
re-direction. The basic UNIX philosophy, therefore by extension the Linux philosophy, is to have
many small programs and utilities that do a particular job very well. It is the responsibility of the
programmer or user to combine these utilities to make more useful command sequences.
4.1
Piping Commands Together
The pipe character, '.&|-+(, is used to chain two or more commands together. The output of the first
command is !.+piped!/. into the next program, and if there is a second pipe, the output is sent to the
third program, etc. For example:
ls -la /usr/bin | less
In this example, we run the command $#(ls -la /usr/bin#$*, which gives us a long listing of all
of the files in /usr/bin. Because the output of this command is typically very long, we pipe the
output to a program called $,%less%"*, which displays the output for us one screen at a time.
4.2
Redirecting Program Output to Files
There are times when it is useful to save the output of a command to a file, instead of displaying it
to the screen. For example, if we want to create a file that lists all of the MP3 files in a directory,
we can do something like this, using the .#,>"&" redirection character:
ls -l /home/vic/MP3/*.mp3 > mp3files.txt
A similar command can be written so that instead of creating a new file called mp3files.txt,
we can append to the end of the original file:
ls -l /home/vic/extraMP3s/*.mp3 >> mp3files.txt5.0
Other Linux Commands
The following sections describe many other commands that you will find on most Linux systems.
I can't possibly cover the details of all of these commands in this document, so don't forget that you
can check the !%/man pages-"* for additional information. Not all of the listed commands will be
available on all Linux or UNIX distributions.
5.1
Working With Files and Directories
These commands can be used to: find out information about files, display files, and manipulate
them in other ways (copy, move, delete).
Linux
Command
DOS
Command
file
Description
Find out what kind of file it is.
For example, -)/file /bin/ls/*. tells us that it is a Linux
executable file.
cat
type
head
Display the contents of a text file on the screen. For
example: cat mp3files.txt would display the file we
created in the previous section.
Display the first few lines of a text file.
Example: head /etc/services
tail
Display the last few lines of a text file.
Example: tail /etc/services
tail -f
Display the last few lines of a text file, and then output
appended data as the file grows (very useful for following
log files!).
Example: tail -f /var/log/messages
cp
copy
Copies a file from one location to another.
Example: cp mp3files.txt /tmp
(copies the mp3files.txt file to the /tmp directory)
mv
rename,
ren, move
Moves a file to a new location, or renames it.
For example: mv mp3files.txt /tmp
(copy the file to /tmp, and delete it from the original
location)
rm del Delete a file. Example: rm /tmp/mp3files.txt
mkdir md Make Directory. Example: mkdir /tmp/myfiles/
rmdir rd, rmdir Remove Directory. Example: rmdir /tmp/myfiles/5.2
Finding Things
The following commands are used to find files. -%"ls,', is good for finding files if you already know
approximately where they are, but sometimes you need more powerful tools such as these:
Linux
Command
Description
which Shows the full path of shell commands found in your path. For example, if
you want to know exactly where the .#/grep*'! command is located on the
filesystem, you can type +%#which grep(-). The output should be something
like: /bin/grep
whereis Locates the program, source code, and manual page for a command (if all
information is available). For example, to find out where )%-ls/"& and its man
page are, type: !..whereis ls!&/ The output will look something like:
ls: /bin/ls /usr/share/man/man1/ls.1.gz
locate A quick way to search for files anywhere on the filesystem. For example, you
can find all files and directories that contain the name .#%mozilla''# by typing:
locate mozilla
find A very powerful command, but sometimes tricky to use. It can be used to
search for files matching certain patterns, as well as many other types of
searches. A simple example is:
find . -name \*mp3
This example starts searching in the current directory *%%.).+ and all sub-
directories, looking for files with "!'mp3+($ at the end of their names.
5.3
Informational Commands
The following commands are used to find out some information about the user or the system.
Linux Command
Explanation
ps Lists currently running process (programs).
w Show who is logged on and what they are doing.
id Print your user-id and group id's
df Report filesystem disk space usage ($((Disk Free('* is how I remember it)
du Disk Usage in a particular directory. %(/du -s$(% provides a summary
for the current directory.
top Displays CPU processes in a full-screen GUI. A great way to see the
activity on your computer in real-time. Type *-/Q&,- to quit.
free Displays amount of free and used memory in the system.
cat /proc/cpuinfo Displays information about your CPU.
cat /proc/meminfo Display lots of information about current memory usage.
uname -a
Prints system information to the screen (kernel version, machine type,
etc.)5.4
Other Utilities
Here are some other commands that are useful to know.
Linux Command
Description
clear Clear the screen
echo Display text on the screen. Mostly useful when writing shell scripts. For
example: echo )&"Hello World%''
more Display a file, or program output one page at a time. Examples:
more mp3files.txt
ls -la | more
less An improved replacement for the !(.more'*' command. Allows you to scroll
backwards as well as forwards.
grep Search for a pattern in a file or program output. For example, to find out
which TCP network port is used by the #&.nfs*-- service, you can do this:
grep +*%nfs#%$ /etc/services
This looks for any line that contains the string '.(nfs-%+ in the file *%)/etc/services#)/
and displays only those lines.
lpr
Print a file or program output. Examples:
lpr mp3files.txt - Print the mp3files.txt file
ls -la | lpr
- Print the output of the !!.ls -la//( command.
sort Sort a file or program output. Example: sort mp3files.txt
su &"-Switch User+##. Allows you to switch to another user's account temporarily.
The default account to switch to is the root/superuser account. Examples:
su - Switch the root account
su - - Switch to root, and log in with root's environment
su larry - Switch to Larry's account5.5
Shortcuts to Make it all Easier!
When you start using the Bash shell more often, you will appreciate these shortcuts that can save
you very much typing time.
Shortcut
Description
Up/Down Arrow Keys Scroll through your most recent commands. You can
scroll back to an old command, hit E NTER , and execute the
command without having to re-type it.
/&,history+(( command Show your complete command history.
T AB Completion If you type a partial command or filename that the shell
recognizes, you can have it automatically completed for
you if you press the T AB key. Try typing the first few
characters of your favourite Linux command, then hit T AB
a couple of times to see what happens.
Complete recent commands with .&&!.$" Try this: Type )--!"(. followed by the first couple of letters
of a recent command and press E NTER ! For example, type:
find /usr/bin -type f -name m\*
...and now type:
!fi
Search your command history with
CTRL-R Press CTRL-R and then type any portion of a recent
command. It will search the commands for you, and once
you find the command you want, just press E NTER .
Scrolling the screen with Shift-
PageUp and Page Down Scroll back and forward through your terminal.
6.0
Further Reading
Link Address
Description
http://www.oclug.on.ca Ottawa Canada Linux Users Group. A
group with an active mailing list, monthly
meetings, and much more.
http://www.exitcertified.com Ottawa's source for Sun training, and the
host of OCLUG's technology seminars.
http://www.fsf.org The
Free
Software
Foundation.
Documentation, source code, and much
more for many programs commonly
found on Linux systems.
http://linux.org.mt/article/terminal ((.A Beginner's Bash-'%. Another very good
introduction to Bash.
http://www.oreilly.com/catalog/bash2 An excellent book if you want to learn
how to customize Bash and use it for shell
script programming.

Chapter 1. Linux history
This chapter briefly tells the history of Unix and where Linux fits in.
If you are eager to start working with Linux without this blah, blah, blah over history,
distributions, and licensing then jump straight to Part II - Chapter 8. Working with
Directories page 73.
3Linux history
1.1. 1969
All modern operating systems have their roots in 1969 when Dennis Ritchie and Ken
Thompson developed the C language and the Unix operating system at AT&T Bell Labs.
They shared their source code (yes, there was open source back in the Seventies) with the
rest of the world, including the hippies in Berkeley California. By 1975, when AT&T started
selling Unix commercially, about half of the source code was written by others. The hippies
were not happy that a commercial company sold software that they had written; the resulting
(legal) battle ended in there being two versions of Unix: the official AT&T Unix, and the
free BSD Unix.
Development of BSD descendants like FreeBSD, OpenBSD, NetBSD, DragonFly BSD and
PC-BSD is still active today.
https://en.wikipedia.org/wiki/Dennis_Ritchie
https://en.wikipedia.org/wiki/Ken_Thompson
https://en.wikipedia.org/wiki/BSD
https://en.wikipedia.org/wiki/Comparison_of_BSD_operating_systems
1.2. 1980s
In the Eighties many companies started developing their own Unix: IBM created AIX, Sun
SunOS (later Solaris), HP HP-UX and about a dozen other companies did the same. The
result was a mess of Unix dialects and a dozen different ways to do the same thing. And
here is the first real root of Linux, when Richard Stallman aimed to end this era of Unix
separation and everybody re-inventing the wheel by starting the GNU project (GNU is Not
Unix). His goal was to make an operating system that was freely available to everyone, and
where everyone could work together (like in the Seventies). Many of the command line tools
that you use today on Linux are GNU tools.
https://en.wikipedia.org/wiki/Richard_Stallman
https://en.wikipedia.org/wiki/IBM_AIX
https://en.wikipedia.org/wiki/HP-UX
1.3. 1990s
The Nineties started with Linus Torvalds, a Swedish speaking Finnish student, buying a
386 computer and writing a brand new POSIX compliant kernel. He put the source code
online, thinking it would never support anything but 386 hardware. Many people embraced
the combination of this kernel with the GNU tools, and the rest, as they say, is history.
http://en.wikipedia.org/wiki/Linus_Torvalds
https://en.wikipedia.org/wiki/History_of_Linux
https://en.wikipedia.org/wiki/Linux
https://lwn.net
http://www.levenez.com/unix/
(a huge Unix history poster)
4Linux history
1.4. 2015
Today more than 97 percent of the world's supercomputers (including the complete top 10),
more than 80 percent of all smartphones, many millions of desktop computers, around 70
percent of all web servers, a large chunk of tablet computers, and several appliances (dvd-
players, washing machines, dsl modems, routers, self-driving cars, space station laptops...)
run Linux. Linux is by far the most commonly used operating system in the world.
Linux kernel version 4.0 was released in April 2015. Its source code grew by several hundred
thousand lines (compared to version 3.19 from February 2015) thanks to contributions of
thousands of developers paid by hundreds of commercial companies including Red Hat,
Intel, Samsung, Broadcom, Texas Instruments, IBM, Novell, Qualcomm, Nokia, Oracle,
Google, AMD and even Microsoft (and many more).
http://kernelnewbies.org/DevelopmentStatistics
http://kernel.org
http://www.top500.org
5Chapter 2. distributions
This chapter gives a short overview of current Linux distributions.
A Linux distribution is a collection of (usually open source) software on top of a Linux
kernel. A distribution (or short, distro) can bundle server software, system management
tools, documentation and many desktop applications in a central secure software
repository. A distro aims to provide a common look and feel, secure and easy software
management and often a specific operational purpose.
Let's take a look at some popular distributions.
6distributions
2.1. Red Hat
Red Hat is a billion dollar commercial Linux company that puts a lot of effort in developing
Linux. They have hundreds of Linux specialists and are known for their excellent support.
They give their products (Red Hat Enterprise Linux and Fedora) away for free. While Red
Hat Enterprise Linux (RHEL) is well tested before release and supported for up to seven
years after release, Fedora is a distro with faster updates but without support.
2.2. Ubuntu
Canonical started sending out free compact discs with Ubuntu Linux in 2004 and quickly
became popular for home users (many switching from Microsoft Windows). Canonical
wants Ubuntu to be an easy to use graphical Linux desktop without need to ever see a
command line. Of course they also want to make a profit by selling support for Ubuntu.
2.3. Debian
There is no company behind Debian. Instead there are thousands of well organised
developers that elect a Debian Project Leader every two years. Debian is seen as one of
the most stable Linux distributions. It is also the basis of every release of Ubuntu. Debian
comes in three versions: stable, testing and unstable. Every Debian release is named after
a character in the movie Toy Story.
2.4. Other
Distributions like CentOS, Oracle Enterprise Linux and Scientific Linux are based on
Red Hat Enterprise Linux and share many of the same principles, directories and
system administration techniques. Linux Mint, Edubuntu and many other *buntu named
distributions are based on Ubuntu and thus share a lot with Debian. There are hundreds of
other Linux distributions.
7distributions
2.5. Which to choose ?
Below are some very personal opinions on some of the most popular Linux Distributions.
Keep in mind that any of the below Linux distributions can be a stable server and a nice
graphical desktop client.
Table 2.1. choosing a Linux distro
distribution name
reason(s) for using
Red Hat Enterprise (RHEL) You are a manager and you want a good support contract.
CentOS You want Red Hat without the support contract from Red Hat.
Fedora You want Red Hat on your laptop/desktop.
Linux Mint
You want a personal graphical desktop to play movies, music and games.
Debian My personal favorite for servers, laptops, and any other device.
Ubuntu Very popular, based on Debian, not my favorite.
Kali
others
You want a pointy-clicky hacking interface.
Advanced users may prefer Arch, Gentoo, OpenSUSE, Scientific, ...
When you are new to Linux in 2015, go for the latest Mint or Fedora. If you only want to
practice the Linux command line then install one Debian server and/or one CentOS server
(without graphical interface).
Here are some links to help you choose:
distrowatch.com
redhat.com
centos.org
debian.org
www.linuxmint.com
ubuntu.com
8Chapter 3. licensing
This chapter briefly explains the different licenses used for distributing operating systems
software.
Many thanks go to Ywein Van den Brande for writing most of this chapter.
Ywein is an attorney at law, co-author of The International FOSS Law Book and author
of Praktijkboek Informaticarecht (in Dutch).
http://ifosslawbook.org
http://www.crealaw.eu
9licensing
3.1. about software licenses
There are two predominant software paradigms: Free and Open Source Software (FOSS)
and proprietary software. The criteria for differentiation between these two approaches is
based on control over the software. With proprietary software, control tends to lie more
with the vendor, while with Free and Open Source Software it tends to be more weighted
towards the end user. But even though the paradigms differ, they use the same copyright
laws to reach and enforce their goals. From a legal perspective, Free and Open Source
Software can be considered as software to which users generally receive more rights via
their license agreement than they would have with a proprietary software license, yet the
underlying license mechanisms are the same.
Legal theory states that the author of FOSS, contrary to the author of public domain
software, has in no way whatsoever given up his rights on his work. FOSS supports on the
rights of the author (the copyright) to impose FOSS license conditions. The FOSS license
conditions need to be respected by the user in the same way as proprietary license conditions.
Always check your license carefully before you use third party software.
Examples of proprietary software are AIX from IBM, HP-UX from HP and Oracle
Database 11g. You are not authorised to install or use this software without paying a
licensing fee. You are not authorised to distribute copies and you are not authorised to modify
the closed source code.
3.2. public domain software and freeware
Software that is original in the sense that it is an intellectual creation of the author benefits
copyright protection. Non-original software does not come into consideration for copyright
protection and can, in principle, be used freely.
Public domain software is considered as software to which the author has given up all rights
and on which nobody is able to enforce any rights. This software can be used, reproduced or
executed freely, without permission or the payment of a fee. Public domain software can in
certain cases even be presented by third parties as own work, and by modifying the original
work, third parties can take certain versions of the public domain software out of the public
domain again.
Freeware is not public domain software or FOSS. It is proprietary software that you can use
without paying a license cost. However, the often strict license terms need to be respected.
Examples of freeware are Adobe Reader, Skype and Command and Conquer: Tiberian
Sun (this game was sold as proprietary in 1999 and is since 2011 available as freeware).
3.3. Free Software or Open Source Software
Both the Free Software (translates to vrije software in Dutch and to Logiciel Libre in
French) and the Open Source Software movement largely pursue similar goals and endorse
similar software licenses. But historically, there has been some perception of differentiation
due to different emphases. Where the Free Software movement focuses on the rights (the
10licensing
four freedoms) which Free Software provides to its users, the Open Source Software
movement points to its Open Source Definition and the advantages of peer-to-peer software
development.
Recently, the term free and open source software or FOSS has arisen as a neutral alternative.
A lesser-used variant is free/libre/open source software (FLOSS), which uses libre to clarify
the meaning of free as in freedom rather than as in at no charge.
Examples of free software are gcc, MySQL and gimp.
Detailed information about the four freedoms can be found here:
http://www.gnu.org/philosophy/free-sw.html
The open source definition can be found at:
http://www.opensource.org/docs/osd
The above definition is based on the Debian Free Software Guidelines available here:
http://www.debian.org/social_contract#guidelines
3.4. GNU General Public License
More and more software is being released under the GNU GPL (in 2006 Java was released
under the GPL). This license (v2 and v3) is the main license endorsed by the Free Software
Foundation. It's main characteristic is the copyleft principle. This means that everyone in the
chain of consecutive users, in return for the right of use that is assigned, needs to distribute
the improvements he makes to the software and his derivative works under the same
conditions to other users, if he chooses to distribute such improvements or derivative works.
In other words, software which incorporates GNU GPL software, needs to be distributed
in turn as GNU GPL software (or compatible, see below). It is not possible to incorporate
copyright protected parts of GNU GPL software in a proprietary licensed work. The GPL
has been upheld in court.
3.5. using GPLv3 software
You can use GPLv3 software almost without any conditions. If you solely run the software
you even don't have to accept the terms of the GPLv3. However, any other use - such as
modifying or distributing the software - implies acceptance.
In case you use the software internally (including over a network), you may modify the
software without being obliged to distribute your modification. You may hire third parties
to work on the software exclusively for you and under your direction and control. But if you
modify the software and use it otherwise than merely internally, this will be considered as
distribution. You must distribute your modifications under GPLv3 (the copyleft principle).
Several more obligations apply if you distribute GPLv3 software. Check the GPLv3 license
carefully.
You create output with GPLv3 software: The GPLv3 does not automatically apply to the
output.
11licensing
3.6. BSD license
There are several versions of the original Berkeley Distribution License. The most common
one is the 3-clause license ("New BSD License" or "Modified BSD License").
This is a permissive free software license. The license places minimal restrictions on how
the software can be redistributed. This is in contrast to copyleft licenses such as the GPLv.
3 discussed above, which have a copyleft mechanism.
This difference is of less importance when you merely use the software, but kicks in when
you start redistributing verbatim copies of the software or your own modified versions.
3.7. other licenses
FOSS or not, there are many kind of licenses on software. You should read and understand
them before using any software.
3.8. combination of software licenses
When you use several sources or wishes to redistribute your software under a different
license, you need to verify whether all licenses are compatible. Some FOSS licenses (such
as BSD) are compatible with proprietary licenses, but most are not. If you detect a license
incompatibility, you must contact the author to negotiate different license conditions or
refrain from using the incompatible software.
12Part II. installing LinuxTable of Contents
Chapter 4. installing Debian 8
This module is a step by step demonstration of an actual installation of Debian 8 (also known
as Jessie).
We start by downloading an image from the internet and install Debian 8 as a virtual machine
in Virtualbox. We will also do some basic configuration of this new machine like setting
an ip address and fixing a hostname.
This procedure should be very similar for other versions of Debian, and also for distributions
like Linux Mint, xubuntu/ubuntu/kubuntu or Mepis. This procedure can also be helpful
if you are using another virtualization solution.
Go to the next chapter if you want to install CentOS, Fedora, Red Hat Enterprise
Linux, ....
15installing Debian 8
4.1. Debian
Debian is one of the oldest Linux distributions. I use Debian myself on almost every
computer that I own (including raspbian on the Raspberry Pi).
Debian comes in releases named after characters in the movie Toy Story. The Jessie release
contains about 36000 packages.
Table 4.1. Debian releases
name number year
Woody 3.0 2002
Sarge 3.1 2005
Etch 4.0 2007
Lenny 5.0 2009
Squeeze 6.0 2011
Wheezy 7 2013
Jessie 8 2015
There is never a fixed date for the next Debian release. The next version is released when
it is ready.
4.2. Downloading
All these screenshots were made in November 2014, which means Debian 8 was still in
'testing' (but in 'freeze', so there will be no major changes when it is released).
Download Debian here:
16installing Debian 8
After a couple of clicks on that website, I ended up downloading Debian 8 (testing) here. It
should be only one click once Debian 8 is released (somewhere in 2015).
You have many other options to download and install Debian. We will discuss them much
later.
This small screenshot shows the downloading of a netinst .iso file. Most of the software will
be downloaded during the installation. This also means that you will have the most recent
version of all packages when the install is finished.
I already have Debian 8 installed on my laptop (hence the paul@debian8 prompt). Anyway,
this is the downloaded file just before starting the installation.
paul@debian8:~$ ls -hl debian-testing-amd64-netinst.iso
-rw-r--r-- 1 paul paul 231M Nov 10 17:59 debian-testing-amd64-netinst.iso
17installing Debian 8
Create a new virtualbox machine (I already have five, you might have zero for now). Click
the New button to start a wizard that will help you create a virtual machine.
The machine needs a name, this screenshot shows that I named it server42.
18installing Debian 8
Most of the defaults in Virtualbox are ok.
512MB of RAM is enough to practice all the topics in this book.
We do not care about the virtual disk format.
19installing Debian 8
Choosing dynamically allocated will save you some disk space (for a small performance
hit).
8GB should be plenty for learning about Linux servers.
This finishes the wizard. You virtual machine is almost ready to begin the installation.
20installing Debian 8
First, make sure that you attach the downloaded .iso image to the virtual CD drive. (by
opening Settings, Storage followed by a mouse click on the round CD icon)
Personally I also disable sound and usb, because I never use these features. I also remove
the floppy disk and use a PS/2 mouse pointer. This is probably not very important, but I like
the idea that it saves some resources.
Now boot the virtual machine and begin the actual installation. After a couple of seconds
you should see a screen similar to this. Choose Install to begin the installation of Debian.
21installing Debian 8
First select the language you want to use.
Choose your country. This information will be used to suggest a download mirror.
22installing Debian 8
Choose the correct keyboard. On servers this is of no importance since most servers are
remotely managed via ssh.
Enter a hostname (with fqdn to set a dnsdomainname).
23installing Debian 8
Give the root user a password. Remember this password (or use hunter2).
It is adviced to also create a normal user account. I don't give my full name, Debian 8 accepts
an identical username and full name paul.
24installing Debian 8
The use entire disk refers to the virtual disk that you created before in Virtualbox..
Again the default is probably what you want. Only change partitioning if you really know
what you are doing.
25installing Debian 8
Accept the partition layout (again only change if you really know what you are doing).
This is the point of no return, the magical moment where pressing yes will forever erase
data on the (virtual) computer.
26installing Debian 8
Software is downloaded from a mirror repository, preferably choose one that is close by (as
in the same country).
This setup was done in Belgium.
27installing Debian 8
Leave the proxy field empty (unless you are sure that you are behind a proxy server).
Choose whether you want to send anonymous statistics to the Debian project (it gathers data
about installed packages). You can view the statistics here http://popcon.debian.org/.
28installing Debian 8
Choose what software to install, we do not need any graphical stuff for this training.
The latest versions are being downloaded.
29installing Debian 8
Say yes to install the bootloader on the virtual machine.
Booting for the first time shows the grub screen
30installing Debian 8
A couple seconds later you should see a lot of text scrolling of the screen (dmesg). After
which you are presented with this getty and are allowed your first logon.
You should now be able to log on to your virtual machine with the root account. Do you
remember the password ? Was it hunter2 ?
The screenshots in this book will look like this from now on. You can just type those
commands in the terminal (after you logged on).
root@server42:~# who am i
root
tty1
2014-11-10 18:21
root@server42:~# hostname
server42
root@server42:~# date
Mon Nov 10 18:21:56 CET 2014
31installing Debian 8
4.3. virtualbox networking
You can also log on from remote (or from your Windows/Mac/Linux host computer) using
ssh or putty. Change the network settings in the virtual machine to bridge. This will enable
your virtual machine to receive an ip address from your local dhcp server.
The default virtualbox networking is to attach virtual network cards to nat. This screenshiot
shows the ip address 10.0.2.15 when on nat:
root@server42:~# ifconfig
eth0
Link encap:Ethernet HWaddr 08:00:27:f5:74:cf
inet addr:10.0.2.15 Bcast:10.0.2.255 Mask:255.255.255.0
inet6 addr: fe80::a00:27ff:fef5:74cf/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:11 errors:0 dropped:0 overruns:0 frame:0
TX packets:19 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:2352 (2.2 KiB) TX bytes:1988 (1.9 KiB)
lo
Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)
By shutting down the network interface and enabling it again, we force Debian to renew an
ip address from the bridged network.
root@server42:~# # do not run ifdown while connected over ssh!
root@server42:~# ifdown eth0
Killed old client process
Internet Systems Consortium DHCP Client 4.3.1
Copyright 2004-2014 Internet Systems Consortium.
All rights reserved.
For info, please visit https://www.isc.org/software/dhcp/
Listening on LPF/eth0/08:00:27:f5:74:cf
Sending on
LPF/eth0/08:00:27:f5:74:cf
32installing Debian 8
Sending on
Socket/fallback
DHCPRELEASE on eth0 to 10.0.2.2 port 67
root@server42:~# # now enable bridge in virtualbox settings
root@server42:~# ifup eth0
Internet Systems Consortium DHCP Client 4.3.1
Copyright 2004-2014 Internet Systems Consortium.
All rights reserved.
For info, please visit https://www.isc.org/software/dhcp/
Listening on LPF/eth0/08:00:27:f5:74:cf
Sending on
LPF/eth0/08:00:27:f5:74:cf
Sending on
Socket/fallback
DHCPDISCOVER on eth0 to 255.255.255.255 port 67 interval 8
DHCPDISCOVER on eth0 to 255.255.255.255 port 67 interval 8
DHCPREQUEST on eth0 to 255.255.255.255 port 67
DHCPOFFER from 192.168.1.42
DHCPACK from 192.168.1.42
bound to 192.168.1.111 -- renewal in 2938 seconds.
root@server42:~# ifconfig eth0
eth0
Link encap:Ethernet HWaddr 08:00:27:f5:74:cf
inet addr:192.168.1.111 Bcast:192.168.1.255 Mask:255.255.255.0
inet6 addr: fe80::a00:27ff:fef5:74cf/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:15 errors:0 dropped:0 overruns:0 frame:0
TX packets:31 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:3156 (3.0 KiB) TX bytes:3722 (3.6 KiB)
root@server42:~#
Here is an example of ssh to this freshly installed computer. Note that Debian 8 has disabled
remote root access, so i need to use the normal user account.
paul@debian8:~$ ssh paul@192.168.1.111
paul@192.168.1.111's password:
The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.
Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
paul@server42:~$
paul@server42:~$ su -
Password:
root@server42:~#
TODO: putty screenshot here...
33installing Debian 8
4.4. setting the hostname
The hostname of the server is asked during installation, so there is no need to configure this
manually.
root@server42:~# hostname
server42
root@server42:~# cat /etc/hostname
server42
root@server42:~# dnsdomainname
paul.local
root@server42:~# grep server42 /etc/hosts
127.0.1.1
server42.paul.local
server42
root@server42:~#
4.5. adding a static ip address
This example shows how to add a static ip address to your server.
You can use ifconfig to set a static address that is active until the next reboot (or until the
next ifdown).
a
root@server42:~# ifconfig eth0:0 10.104.33.39
Adding a couple of lines to the /etc/network/interfaces file to enable an extra ip address
forever.
root@server42:~# vi /etc/network/interfaces
root@server42:~# tail -4 /etc/network/interfaces
auto eth0:0
iface eth0:0 inet static
address 10.104.33.39
netmask 255.255.0.0
root@server42:~# ifconfig
eth0
Link encap:Ethernet HWaddr 08:00:27:f5:74:cf
inet addr:192.168.1.111 Bcast:192.168.1.255 Mask:255.255.255.0
inet6 addr: fe80::a00:27ff:fef5:74cf/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:528 errors:0 dropped:0 overruns:0 frame:0
TX packets:333 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:45429 (44.3 KiB) TX bytes:48763 (47.6 KiB)
eth0:0 Link encap:Ethernet HWaddr 08:00:27:f5:74:cf
inet addr:10.104.33.39 Bcast:10.255.255.255 Mask:255.0.0.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)
root@server42:~#
34installing Debian 8
4.6. Debian package management
To get all information about the newest packages form the online repository:
root@server42:~# aptitude update
Get: 1 http://ftp.be.debian.org jessie InRelease [191 kB]
Get: 2 http://security.debian.org jessie/updates InRelease [84.1 kB]
Get: 3 http://ftp.be.debian.org jessie-updates InRelease [117 kB]
Get: 4 http://ftp.be.debian.org jessie-backports InRelease [118 kB]
Get: 5 http://security.debian.org jessie/updates/main Sources [14 B]
Get: 6 http://ftp.be.debian.org jessie/main Sources/DiffIndex [7,876 B]
... (output truncated)
To download and apply all updates for all installed packages:
root@server42:~# aptitude upgrade
Resolving dependencies...
The following NEW packages will be installed:
firmware-linux-free{a} irqbalance{a} libnuma1{a} linux-image-3.16.0-4-amd64{a}
The following packages will be upgraded:
busybox file libc-bin libc6 libexpat1 libmagic1 libpaper-utils libpaper1 libsqlite3-0
linux-image-amd64 locales multiarch-support
12 packages upgraded, 4 newly installed, 0 to remove and 0 not upgraded.
Need to get 44.9 MB of archives. After unpacking 161 MB will be used.
Do you want to continue? [Y/n/?]
... (output truncated)
To install new software (vim and tmux in this example):
root@server42:~# aptitude install vim tmux
The following NEW packages will be installed:
tmux vim vim-runtime{a}
0 packages upgraded, 3 newly installed, 0 to remove and 0 not upgraded.
Need to get 6,243 kB of archives. After unpacking 29.0 MB will be used.
Do you want to continue? [Y/n/?]
Get: 1 http://ftp.be.debian.org/debian/ jessie/main tmux amd64 1.9-6 [245 kB]
Get: 2 http://ftp.be.debian.org/debian/ jessie/main vim-runtime all 2:7.4.488-1 [5,046 kB]
Get: 3 http://ftp.be.debian.org/debian/ jessie/main vim amd64 2:7.4.488-1 [952 kB]
Refer to the package management chapter in LinuxAdm.pdf for more information.
35Chapter 5. installing CentOS 7
This module is a step by step demonstration of an actual installation of CentOS 7.
We start by downloading an image from the internet and install CentOS 7 as a virtual
machine in Virtualbox. We will also do some basic configuration of this new machine like
setting an ip address and fixing a hostname.
This procedure should be very similar for other versions of CentOS, and also for
distributions like RHEL (Red Hat Enterprise Linux) or Fedora. This procedure can also be
helpful if you are using another virtualization solution.
36installing CentOS 7
5.1. download a CentOS 7 image
This demonstration uses a laptop computer with Virtualbox to install CentOS 7 as a virtual
machine. The first task is to download an .iso image of CentOS 7.
The CentOS 7 website looks like this today (November 2014). They change the look
regularly, so it may look different when you visit it.
You can download a full DVD, which allows for an off line installation of a graphical
CentOS 7 desktop. You can select this because it should be easy and complete, and should
get you started with a working CentOS 7 virtual machine.
37installing CentOS 7
But I clicked instead on 'alternative downloads', selected CentOS 7 and x86_64 and ended
up on a mirror list. Each mirror is a server that contains copies of CentOS 7 media. I
selected a Belgian mirror because I currently am in Belgium.
There is again the option for full DVD's and more. This demonstration will use the minimal
.iso file, because it is much smaller in size. The download takes a couple of minutes.
Verify the size of the file after download to make sure it is complete. Probably a right click
on the file and selecting 'properties' (if you use Windows or Mac OSX).
I use Linux on the laptop already:
paul@debian8:~$ ls -lh CentOS-7.0-1406-x86_64-Minimal.iso
-rw-r--r-- 1 paul paul 566M Nov 1 14:45 CentOS-7.0-1406-x86_64-Minimal.iso
Do not worry if you do no understand the above command. Just try to make sure that the
size of this file is the same as the size that is mentioned on the CentOS 7 website.
38installing CentOS 7
5.2. Virtualbox
This screenshot shows up when I start Virtualbox. I already have four virtual machines, you
might have none.
Below are the steps for creating a new virtual machine. Start by clicking New and give your
machine a name (I chose server33). Click Next.
39installing CentOS 7
A Linux computer without graphical interface will run fine on half a gigabyte of RAM.
A Linux virtual machine will need a virtual hard drive.
40installing CentOS 7
Any format will do for our purpose, so I left the default vdi.
The default dynamically allocated type will save disk space (until we fill the virtual disk
up to 100 percent). It makes the virtual machine a bit slower than fixed size, but the fixed
size speed improvement is not worth it for our purpose.
41installing CentOS 7
The name of the virtual disk file on the host computer will be server33.vdi in my case (I left
it default and it uses the vm name). Also 16 GB should be enough to practice Linux. The
file will stay much smaller than 16GB, unless you copy a lot of files to the virtual machine.
You should now be back to the start screen of Virtualbox. If all went well, then you should
see the machine you just created in the list.
42installing CentOS 7
After finishing the setup, we go into the Settings of our virtual machine and attach the .iso
file we downloaded before. Below is the default screenshot.
This is a screenshot with the .iso file properly attached.
43installing CentOS 7
5.3. CentOS 7 installing
The screenshots below will show every step from starting the virtual machine for the first
time (with the .iso file attached) until the first logon.
You should see this when booting, otherwise verify the attachment of the .iso file form the
previous steps. Select Test this media and install CentOS 7.
44installing CentOS 7
Carefully select the language in which you want your CentOS. I always install operating
systems in English, even though my native language is not English.
Also select the right keyboard, mine is a US qwerty, but yours may be different.
You should arrive at a summary page (with one or more warnings).
45installing CentOS 7
Start by configuring the network. During this demonstration I had a DHCP server running
at 192.168.1.42, yours is probably different. Ask someone (a network administator ?) for
help if this step fails.
Select your time zone, and activate ntp.
46installing CentOS 7
Choose a mirror that is close to you. If you can't find a local mirror, then you can copy the
one from this screenshot (it is a general CentOS mirror).
It can take a couple of seconds before the mirror is verified.
47installing CentOS 7
I did not select any software here (because I want to show it all in this training).
After configuring network, location, software and all, you should be back on this page. Make
sure there are no warnings anymore (and that you made the correct choice everywhere).
48installing CentOS 7
You can enter a root password and create a user account while the installation is
downloading from the internet. This is the longest step, it can take several minutes (or up to
an hour if you have a slow internet connection).
If you see this, then the installation was successful.
Time to reboot the computer and start CentOS 7 for the first time.
49installing CentOS 7
This screen will appear briefly when the virtual machines starts. You don't have to do
anything.
After a couple of seconds, you should see a logon screen. This is called a tty or a getty. Here
you can type root as username. The login process will then ask your password (nothing will
appear on screen when you type your password).
50installing CentOS 7
And this is what it looks like after logon. You are logged on to your own Linux machine,
very good.
All subsequent screenshots will be text only, no images anymore.
For example this screenshot shows three commands being typed on my new CentOS 7
install.
[root@localhost ~]# who am i
root
pts/0
2014-11-01 22:14
[root@localhost ~]# hostname
localhost.localdomain
[root@localhost ~]# date
Sat Nov 1 22:14:37 CET 2014
When using ssh the same commands will give this screenshot:
[root@localhost ~]# who am i
root
pts/0
2014-11-01 21:00 (192.168.1.35)
[root@localhost ~]# hostname
localhost.localdomain
[root@localhost ~]# date
Sat Nov 1 22:10:04 CET 2014
[root@localhost ~]#
If the last part is a bit too fast, take a look at the next topic CentOS 7 first logon.
51installing CentOS 7
5.4. CentOS 7 first logon
All you have to log on, after finishing the installation, is this screen in Virtualbox.
This is workable to learn Linux, and you will be able to practice a lot. But there are more
ways to access your virtual machine, the next chapters discuss some of these and will also
introduce some basic system configuration.
5.4.1. setting the hostname
Setting the hostname is a simple as changing the /etc/hostname file. As you can see here,
it is set to localhost.localdomain by default.
[root@localhost ~]# cat /etc/hostname
localhost.localdomain
You could do echo server33.netsec.local > /etc/hostname followed by a reboot. But there
is also the new CentOS 7 way of setting a new hostname.
[root@localhost ~]# nmtui
The above command will give you a menu to choose from with a set system hostname
option. Using this nmtui option will edit the /etc/hostname file for you.
[root@localhost ~]# cat /etc/hostname
server33.netsec.local
[root@localhost ~]# hostname
server33.netsec.local
[root@localhost ~]# dnsdomainname
netsec.local
For some reason the documentation on the centos.org and docs.redhat.com websites tell
you to also execute this command:
[root@localhost ~]# systemctl restart systemd-hostnamed
52installing CentOS 7
5.5. Virtualbox network interface
By default Virtualbox will connect your virtual machine over a nat interface. This will
show up as a 10.0.2.15 (or similar).
[root@server33 ~]# ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: enp0s3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast s\
tate UP qlen 1000
link/ether 08:00:27:1c:f5:ab brd ff:ff:ff:ff:ff:ff
inet 10.0.2.15/24 brd 10.0.2.255 scope global dynamic enp0s3
valid_lft 86399sec preferred_lft 86399sec
inet6 fe80::a00:27ff:fe1c:f5ab/64 scope link
valid_lft forever preferred_lft forever
You can change this to bridge (over your wi-fi or over the ethernet cable) and thus make it
appear as if your virtual machine is directly on your local network (receiving an ip address
from your real dhcp server).
You can make this change while the vm is running, provided that you execute this command:
[root@server33 ~]# systemctl restart network
[root@server33 ~]# ip a s dev enp0s3
2: enp0s3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast s\
tate UP qlen 1000
link/ether 08:00:27:1c:f5:ab brd ff:ff:ff:ff:ff:ff
inet 192.168.1.110/24 brd 192.168.1.255 scope global dynamic enp0s3
valid_lft 7199sec preferred_lft 7199sec
inet6 fe80::a00:27ff:fe1c:f5ab/64 scope link
valid_lft forever preferred_lft forever
[root@server33 ~]#
53installing CentOS 7
5.6. configuring the network
The new way of changing network configuration is through the nmtui tool. If you want to
manually play with the files in /etc/sysconfig/network-scripts then you will first need to
verify (and disable) NetworkManager on that interface.
Verify whether an interface is controlled by NetworkManager using the nmcli command
(connected means managed bu NM).
[root@server33 ~]# nmcli dev
DEVICE TYPE
STATE
enp0s3 ethernet connected
lo
loopback unmanaged
status
CONNECTION
enp0s3
--
Disable NetworkManager on an interface (enp0s3 in this case):
echo 'NM_CONTROLLED=no' >> /etc/sysconfig/network-scripts/ifcfg-enp0s3
You can restart the network without a reboot like this:
[root@server33 ~]# systemctl restart network
Also, forget ifconfig and instead use ip a.
[root@server33 ~]# ip a s dev enp0s3 | grep inet
inet 192.168.1.110/24 brd 192.168.1.255 scope global dynamic enp0s3
inet6 fe80::a00:27ff:fe1c:f5ab/64 scope link
[root@server33 ~]#
5.7. adding one static ip address
This example shows how to add one static ip address to your computer.
[root@server33 ~]# nmtui edit enp0s3
In this interface leave the IPv4 configuration to automatic, and add an ip address just below.
IPv4 CONFIGURATION <Automatic>
Addresses 10.104.33.32/16__________ <Remove>
<Hide>
Execute this command after exiting nmtui.
[root@server33 ~]# systemctl restart network
And verify with ip (not with ifconfig):
[root@server33 ~]# ip a s dev enp0s3 | grep
inet 192.168.1.110/24 brd 192.168.1.255
inet 10.104.33.32/16 brd 10.104.255.255
inet6 fe80::a00:27ff:fe1c:f5ab/64 scope
[root@server33 ~]#
54
inet
scope global dynamic enp0s3
scope global enp0s3
linkinstalling CentOS 7
5.8. package management
Even with a network install, CentOS 7 did not install the latest version of some packages.
Luckily there is only one command to run (as root). This can take a while.
[root@server33 ~]# yum update
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
* base: centos.weepeetelecom.be
* extras: centos.weepeetelecom.be
* updates: centos.weepeetelecom.be
Resolving Dependencies
--> Running transaction check
---> Package NetworkManager.x86_64 1:0.9.9.1-13.git20140326.4dba720.el7 \
will be updated
... (output truncated)
You can also use yum to install one or more packages. Do not forget to run yum update
from time to time.
[root@server33 ~]# yum update -y && yum install vim -y
Loaded plugins: fastestmirror
Loading mirror speeds from cached hostfile
* base: centos.weepeetelecom.be
... (output truncated)
Refer to the package management chapter for more information on installing and removing
packages.
55installing CentOS 7
5.9. logon from Linux and MacOSX
You can now open a terminal on Linux or MacOSX and use ssh to log on to your virtual
machine.
paul@debian8:~$ ssh root@192.168.1.110
root@192.168.1.110's password:
Last login: Sun Nov 2 11:53:57 2014
[root@server33 ~]# hostname
server33.netsec.local
[root@server33 ~]#
5.10. logon from MS Windows
There is no ssh installed on MS Windows, but you can download putty.exe from http://
www.chiark.greenend.org.uk/~sgtatham/putty/download.html (just Google it).
Use putty.exe as shown in this screenshot (I saved the ip address by giving it a name
'server33' and presing the 'save' button).
56installing CentOS 7
The first time you will get a message about keys, accept this (this is explained in the ssh
chapter).
Enter your userid (or root) and the correct password (nothing will appear on the screen when
typing a password).
57Chapter 6. getting Linux at home
This chapter shows a Ubuntu install in Virtualbox. Consider it legacy and use CentOS7
or Debian8 instead (each have their own chapter now).
This book assumes you have access to a working Linux computer. Most companies have
one or more Linux servers, if you have already logged on to it, then you 're all set (skip this
chapter and go to the next).
Another option is to insert a Ubuntu Linux CD in a computer with (or without) Microsoft
Windows and follow the installation. Ubuntu will resize (or create) partitions and setup a
menu at boot time to choose Windows or Linux.
If you do not have access to a Linux computer at the moment, and if you are unable or unsure
about installing Linux on your computer, then this chapter proposes a third option: installing
Linux in a virtual machine.
Installation in a virtual machine (provided by Virtualbox) is easy and safe. Even when you
make mistakes and crash everything on the virtual Linux machine, then nothing on the real
computer is touched.
This chapter gives easy steps and screenshots to get a working Ubuntu server in a Virtualbox
virtual machine. The steps are very similar to installing Fedora or CentOS or even Debian,
and if you like you can also use VMWare instead of Virtualbox.
58getting Linux at home
6.1. download a Linux CD image
Start by downloading a Linux CD image (an .ISO file) from the distribution of your choice
from the Internet. Take care selecting the correct cpu architecture of your computer; choose
i386 if unsure. Choosing the wrong cpu type (like x86_64 when you have an old Pentium)
will almost immediately fail to boot the CD.
6.2. download Virtualbox
Step two (when the .ISO file has finished downloading) is to download Virtualbox. If you are
currently running Microsoft Windows, then download and install Virtualbox for Windows!
59getting Linux at home
6.3. create a virtual machine
Now start Virtualbox. Contrary to the screenshot below, your left pane should be empty.
Click New to create a new virtual machine. We will walk together through the wizard. The
screenshots below are taken on Mac OSX; they will be slightly different if you are running
Microsoft Windows.
60getting Linux at home
Name your virtual machine (and maybe select 32-bit or 64-bit).
Give the virtual machine some memory (512MB if you have 2GB or more, otherwise select
256MB).
61getting Linux at home
Select to create a new disk (remember, this will be a virtual disk).
If you get the question below, choose vdi.
62getting Linux at home
Choose dynamically allocated (fixed size is only useful in production or on really old, slow
hardware).
Choose between 10GB and 16GB as the disk size.
63getting Linux at home
Click create to create the virtual disk.
Click create to create the virtual machine.
64getting Linux at home
6.4. attach the CD image
Before we start the virtual computer, let us take a look at some settings (click Settings).
Do not worry if your screen looks different, just find the button named storage.
65getting Linux at home
Remember the .ISO file you downloaded? Connect this .ISO file to this virtual machine by
clicking on the CD icon next to Empty.
Now click on the other CD icon and attach your ISO file to this virtual CD drive.
66getting Linux at home
Verify that your download is accepted. If Virtualbox complains at this point, then you
probably did not finish the download of the CD (try downloading it again).
It could be useful to set the network adapter to bridge instead of NAT. Bridged usually will
connect your virtual computer to the Internet.
67getting Linux at home
6.5. install Linux
The virtual machine is now ready to start. When given a choice at boot, select install and
follow the instructions on the screen. When the installation is finished, you can log on to
the machine and start practising Linux!
68Part III. first steps on
the command lineTable of Contents
Chapter 7. man pages
This chapter will explain the use of man pages (also called manual pages) on your Unix
or Linux computer.
You will learn the man command together with related commands like whereis, whatis
and mandb.
Most Unix files and commands have pretty good man pages to explain their use. Man
pages also come in handy when you are using multiple flavours of Unix or several Linux
distributions since options and parameters sometimes vary.
71man pages
7.1. man $command
Type man followed by a command (for which you want help) and start reading. Press q to
quit the manpage. Some man pages contain examples (near the end).
paul@laika:~$ man whois
Reformatting whois(1), please wait...
7.2. man $configfile
Most configuration files have their own manual.
paul@laika:~$ man syslog.conf
Reformatting syslog.conf(5), please wait...
7.3. man $daemon
This is also true for most daemons (background programs) on your system..
paul@laika:~$ man syslogd
Reformatting syslogd(8), please wait...
7.4. man -k (apropos)
man -k (or apropos) shows a list of man pages containing a string.
paul@laika:~$ man -k syslog
lm-syslog-setup (8) - configure laptop mode to switch syslog.conf ...
logger (1)
- a shell command interface to the syslog(3) ...
syslog-facility (8) - Setup and remove LOCALx facility for sysklogd
syslog.conf (5)
- syslogd(8) configuration file
syslogd (8)
- Linux system logging utilities.
syslogd-listfiles (8) - list system logfiles
7.5. whatis
To see just the description of a manual page, use whatis followed by a string.
paul@u810:~$ whatis route
route (8)
- show / manipulate the IP routing table
7.6. whereis
The location of a manpage can be revealed with whereis.
paul@laika:~$ whereis -m whois
whois: /usr/share/man/man1/whois.1.gz
This file is directly readable by man.
paul@laika:~$ man /usr/share/man/man1/whois.1.gz
72man pages
7.7. man sections
By now you will have noticed the numbers between the round brackets. man man will
explain to you that these are section numbers. Executable programs and shell commands
reside in section one.
8
Executable programs or shell commands
System calls (functions provided by the kernel)
Library calls (functions within program libraries)
Special files (usually found in /dev)
File formats and conventions eg /etc/passwd
Games
Miscellaneous (including macro packages and conventions), e.g. man(7)
System administration commands (usually only for root)
Kernel routines [Non standard]
7.8. man $section $file
Therefor, when referring to the man page of the passwd command, you will see it written
as passwd(1); when referring to the passwd file, you will see it written as passwd(5). The
screenshot explains how to open the man page in the correct section.
[paul@RHEL52 ~]$ man passwd
[paul@RHEL52 ~]$ man 5 passwd
# opens the first manual found
# opens a page from section 5
7.9. man man
If you want to know more about man, then Read The Fantastic Manual (RTFM).
Unfortunately, manual pages do not have the answer to everything...
paul@laika:~$ man woman
No manual entry for woman
7.10. mandb
Should you be convinced that a man page exists, but you can't access it, then try running
mandb on Debian/Mint.
root@laika:~# mandb
0 man subdirectories contained newer manual pages.
0 manual pages were added.
0 stray cats were added.
0 old database entries were purged.
Or run makewhatis on CentOS/Redhat.
[root@centos65 ~]# apropos scsi
scsi: nothing appropriate
[root@centos65 ~]# makewhatis
[root@centos65 ~]# apropos scsi
hpsa
(4) - HP Smart Array SCSI driver
lsscsi
(8) - list SCSI devices (or hosts) and their attributes
sd
(4) - Driver for SCSI Disk Drives
st
(4) - SCSI tape device
73Chapter 8. working with directories
This module is a brief overview of the most common commands to work with directories:
pwd, cd, ls, mkdir and rmdir. These commands are available on any Linux (or Unix)
system.
This module also discusses absolute and relative paths and path completion in the bash
shell.
74working with directories
8.1. pwd
The you are here sign can be displayed with the pwd command (Print Working Directory).
Go ahead, try it: Open a command line interface (also called a terminal, console or xterm)
and type pwd. The tool displays your current directory.
paul@debian8:~$ pwd
/home/paul
8.2. cd
You can change your current directory with the cd command (Change Directory).
paul@debian8$
paul@debian8$
/etc
paul@debian8$
paul@debian8$
/bin
paul@debian8$
paul@debian8$
/home/paul
cd /etc
pwd
cd /bin
pwd
cd /home/paul/
pwd
8.2.1. cd ~
The cd is also a shortcut to get back into your home directory. Just typing cd without a target
directory, will put you in your home directory. Typing cd ~ has the same effect.
paul@debian8$
paul@debian8$
/etc
paul@debian8$
paul@debian8$
/home/paul
paul@debian8$
paul@debian8$
/home/paul
cd /etc
pwd
cd
pwd
cd ~
pwd
8.2.2. cd ..
To go to the parent directory (the one just above your current directory in the directory
tree), type cd .. .
paul@debian8$ pwd
/usr/share/games
paul@debian8$ cd ..
paul@debian8$ pwd
/usr/share
To stay in the current directory, type cd . ;-) We will see useful use of the . character
representing the current directory later.
75working with directories
8.2.3. cd -
Another useful shortcut with cd is to just type cd - to go to the previous directory.
paul@debian8$
/home/paul
paul@debian8$
paul@debian8$
/etc
paul@debian8$
/home/paul
paul@debian8$
/etc
pwd
cd /etc
pwd
cd -
cd -
8.3. absolute and relative paths
You should be aware of absolute and relative paths in the file tree. When you type a path
starting with a slash (/), then the root of the file tree is assumed. If you don't start your path
with a slash, then the current directory is the assumed starting point.
The screenshot below first shows the current directory /home/paul. From within this
directory, you have to type cd /home instead of cd home to go to the /home directory.
paul@debian8$ pwd
/home/paul
paul@debian8$ cd home
bash: cd: home: No such file or directory
paul@debian8$ cd /home
paul@debian8$ pwd
/home
When inside /home, you have to type cd paul instead of cd /paul to enter the subdirectory
paul of the current directory /home.
paul@debian8$ pwd
/home
paul@debian8$ cd /paul
bash: cd: /paul: No such file or directory
paul@debian8$ cd paul
paul@debian8$ pwd
/home/paul
In case your current directory is the root directory /, then both cd /home and cd home will
get you in the /home directory.
paul@debian8$
/
paul@debian8$
paul@debian8$
/home
paul@debian8$
paul@debian8$
paul@debian8$
/home
pwd
cd home
pwd
cd /
cd /home
pwd
This was the last screenshot with pwd statements. From now on, the current directory will
often be displayed in the prompt. Later in this book we will explain how the shell variable
$PS1 can be configured to show this.
76working with directories
8.4. path completion
The tab key can help you in typing a path without errors. Typing cd /et followed by the tab
key will expand the command line to cd /etc/. When typing cd /Et followed by the tab key,
nothing will happen because you typed the wrong path (upper case E).
You will need fewer key strokes when using the tab key, and you will be sure your typed
path is correct!
8.5. ls
You can list the contents of a directory with ls.
paul@debian8:~$ ls
allfiles.txt dmesg.txt
paul@debian8:~$
services
stuff
summer.txt
8.5.1. ls -a
A frequently used option with ls is -a to show all files. Showing all files means including
the hidden files. When a file name on a Linux file system starts with a dot, it is considered
a hidden file and it doesn't show up in regular file listings.
paul@debian8:~$ ls
allfiles.txt dmesg.txt services stuff summer.txt
paul@debian8:~$ ls -a
.
allfiles.txt
.bash_profile dmesg.txt
.lesshst
.. .bash_history .bashrc
services
.ssh
paul@debian8:~$
stuff
summer.txt
8.5.2. ls -l
Many times you will be using options with ls to display the contents of the directory in
different formats or to display different parts of the directory. Typing just ls gives you a
list of files in the directory. Typing ls -l (that is a letter L, not the number 1) gives you a
long listing.
paul@debian8:~$ ls -l
total 17296
-rw-r--r-- 1 paul paul 17584442 Sep 17 00:03 allfiles.txt
-rw-r--r-- 1 paul paul
96650 Sep 17 00:03 dmesg.txt
-rw-r--r-- 1 paul paul
19558 Sep 17 00:04 services
drwxr-xr-x 2 paul paul
4096 Sep 17 00:04 stuff
-rw-r--r-- 1 paul paul
0 Sep 17 00:04 summer.txt
77working with directories
8.5.3. ls -lh
Another frequently used ls option is -h. It shows the numbers (file sizes) in a more human
readable format. Also shown below is some variation in the way you can give the options
to ls. We will explain the details of the output later in this book.
Note that we use the letter L as an option in this screenshot, not the number 1.
paul@debian8:~$ ls -l -h
total 17M
-rw-r--r-- 1 paul paul 17M
-rw-r--r-- 1 paul paul 95K
-rw-r--r-- 1 paul paul 20K
drwxr-xr-x 2 paul paul 4.0K
-rw-r--r-- 1 paul paul
0
paul@debian8:~$ ls -lh
total 17M
-rw-r--r-- 1 paul paul 17M
-rw-r--r-- 1 paul paul 95K
-rw-r--r-- 1 paul paul 20K
drwxr-xr-x 2 paul paul 4.0K
-rw-r--r-- 1 paul paul
0
paul@debian8:~$ ls -hl
total 17M
-rw-r--r-- 1 paul paul 17M
-rw-r--r-- 1 paul paul 95K
-rw-r--r-- 1 paul paul 20K
drwxr-xr-x 2 paul paul 4.0K
-rw-r--r-- 1 paul paul
0
paul@debian8:~$ ls -h -l
total 17M
-rw-r--r-- 1 paul paul 17M
-rw-r--r-- 1 paul paul 95K
-rw-r--r-- 1 paul paul 20K
drwxr-xr-x 2 paul paul 4.0K
-rw-r--r-- 1 paul paul
0
paul@debian8:~$
Sep
Sep
Sep
Sep
Sep 17
17
17
17
17 00:03
00:03
00:04
00:04
00:04 allfiles.txt
dmesg.txt
services
stuff
summer.txt
Sep
Sep
Sep
Sep
Sep 17
17
17
17
17 00:03
00:03
00:04
00:04
00:04 allfiles.txt
dmesg.txt
services
stuff
summer.txt
Sep
Sep
Sep
Sep
Sep 17
17
17
17
17 00:03
00:03
00:04
00:04
00:04 allfiles.txt
dmesg.txt
services
stuff
summer.txt
Sep
Sep
Sep
Sep
Sep 17
17
17
17
17 00:03
00:03
00:04
00:04
00:04 allfiles.txt
dmesg.txt
services
stuff
summer.txt
78working with directories
8.6. mkdir
Walking around the Unix file tree is fun, but it is even more fun to create your own directories
with mkdir. You have to give at least one parameter to mkdir, the name of the new directory
to be created. Think before you type a leading / .
paul@debian8:~$ mkdir mydir
paul@debian8:~$ cd mydir
paul@debian8:~/mydir$ ls -al
total 8
drwxr-xr-x 2 paul paul 4096 Sep 17 00:07 .
drwxr-xr-x 48 paul paul 4096 Sep 17 00:07 ..
paul@debian8:~/mydir$ mkdir stuff
paul@debian8:~/mydir$ mkdir otherstuff
paul@debian8:~/mydir$ ls -l
total 8
drwxr-xr-x 2 paul paul 4096 Sep 17 00:08 otherstuff
drwxr-xr-x 2 paul paul 4096 Sep 17 00:08 stuff
paul@debian8:~/mydir$
8.6.1. mkdir -p
The following command will fail, because the parent directory of threedirsdeep does not
exist.
paul@debian8:~$ mkdir mydir2/mysubdir2/threedirsdeep
mkdir: cannot create directory -$-mydir2/mysubdir2/threedirsdeep*'!: No such fi\
le or directory
When given the option -p, then mkdir will create parent directories as needed.
paul@debian8:~$ mkdir -p mydir2/mysubdir2/threedirsdeep
paul@debian8:~$ cd mydir2
paul@debian8:~/mydir2$ ls -l
total 4
drwxr-xr-x 3 paul paul 4096 Sep 17 00:11 mysubdir2
paul@debian8:~/mydir2$ cd mysubdir2
paul@debian8:~/mydir2/mysubdir2$ ls -l
total 4
drwxr-xr-x 2 paul paul 4096 Sep 17 00:11 threedirsdeep
paul@debian8:~/mydir2/mysubdir2$ cd threedirsdeep/
paul@debian8:~/mydir2/mysubdir2/threedirsdeep$ pwd
/home/paul/mydir2/mysubdir2/threedirsdeep
8.7. rmdir
When a directory is empty, you can use rmdir to remove the directory.
paul@debian8:~/mydir$ ls -l
total 8
drwxr-xr-x 2 paul paul 4096 Sep 17 00:08 otherstuff
drwxr-xr-x 2 paul paul 4096 Sep 17 00:08 stuff
paul@debian8:~/mydir$ rmdir otherstuff
paul@debian8:~/mydir$ cd ..
paul@debian8:~$ rmdir mydir
rmdir: failed to remove $&-mydir'"%: Directory not empty
paul@debian8:~$ rmdir mydir/stuff
paul@debian8:~$ rmdir mydir
paul@debian8:~$
79working with directories
8.7.1. rmdir -p
And similar to the mkdir -p option, you can also use rmdir to recursively remove
directories.
paul@debian8:~$ mkdir -p test42/subdir
paul@debian8:~$ rmdir -p test42/subdir
paul@debian8:~$
80working with directories
8.8. practice: working with directories
1. Display your current directory.
2. Change to the /etc directory.
3. Now change to your home directory using only three key presses.
4. Change to the /boot/grub directory using only eleven key presses.
5. Go to the parent directory of the current directory.
6. Go to the root directory.
7. List the contents of the root directory.
8. List a long listing of the root directory.
9. Stay where you are, and list the contents of /etc.
10. Stay where you are, and list the contents of /bin and /sbin.
11. Stay where you are, and list the contents of ~.
12. List all the files (including hidden files) in your home directory.
13. List the files in /boot in a human readable format.
14. Create a directory testdir in your home directory.
15. Change to the /etc directory, stay here and create a directory newdir in your home
directory.
16. Create in one command the directories ~/dir1/dir2/dir3 (dir3 is a subdirectory from dir2,
and dir2 is a subdirectory from dir1 ).
17. Remove the directory testdir.
18. If time permits (or if you are waiting for other students to finish this practice), use and
understand pushd and popd. Use the man page of bash to find information about these
commands.
81working with directories
8.9. solution: working with directories
1. Display your current directory.
pwd
2. Change to the /etc directory.
cd /etc
3. Now change to your home directory using only three key presses.
cd (and the enter key)
4. Change to the /boot/grub directory using only eleven key presses.
cd /boot/grub (use the tab key)
5. Go to the parent directory of the current directory.
cd .. (with space between cd and ..)
6. Go to the root directory.
cd /
7. List the contents of the root directory.
ls
8. List a long listing of the root directory.
ls -l
9. Stay where you are, and list the contents of /etc.
ls /etc
10. Stay where you are, and list the contents of /bin and /sbin.
ls /bin /sbin
11. Stay where you are, and list the contents of ~.
ls ~
12. List all the files (including hidden files) in your home directory.
ls -al ~
13. List the files in /boot in a human readable format.
ls -lh /boot
14. Create a directory testdir in your home directory.
mkdir ~/testdir
15. Change to the /etc directory, stay here and create a directory newdir in your home
directory.
82working with directories
cd /etc ; mkdir ~/newdir
16. Create in one command the directories ~/dir1/dir2/dir3 (dir3 is a subdirectory from dir2,
and dir2 is a subdirectory from dir1 ).
mkdir -p ~/dir1/dir2/dir3
17. Remove the directory testdir.
rmdir testdir
18. If time permits (or if you are waiting for other students to finish this practice), use and
understand pushd and popd. Use the man page of bash to find information about these
commands.
man bash
/pushd
n
# opens the manual
# searches for pushd
# next (do this two/three times)
The Bash shell has two built-in commands called pushd and popd. Both commands work
with a common stack of previous directories. Pushd adds a directory to the stack and changes
to a new current directory, popd removes a directory from the stack and sets the current
directory.
paul@debian7:/etc$ cd /bin
paul@debian7:/bin$ pushd /lib
/lib /bin
paul@debian7:/lib$ pushd /proc
/proc /lib /bin
paul@debian7:/proc$ popd
/lib /bin
paul@debian7:/lib$ popd
/bin
83Chapter 9. working with files
In this chapter we learn how to recognise, create, remove, copy and move files using
commands like file, touch, rm, cp, mv and rename.
84working with files
9.1. all files are case sensitive
Files on Linux (or any Unix) are case sensitive. This means that FILE1 is different from
file1, and /etc/hosts is different from /etc/Hosts (the latter one does not exist on a typical
Linux computer).
This screenshot shows the difference between two files, one with upper case W, the other
with lower case w.
paul@laika:~/Linux$ ls
winter.txt Winter.txt
paul@laika:~/Linux$ cat winter.txt
It is cold.
paul@laika:~/Linux$ cat Winter.txt
It is very cold!
9.2. everything is a file
A directory is a special kind of file, but it is still a (case sensitive!) file. Each terminal
window (for example /dev/pts/4), any hard disk or partition (for example /dev/sdb1) and
any process are all represented somewhere in the file system as a file. It will become clear
throughout this course that everything on Linux is a file.
9.3. file
The file utility determines the file type. Linux does not use extensions to determine the
file type. The command line does not care whether a file ends in .txt or .pdf. As a system
administrator, you should use the file command to determine the file type. Here are some
examples on a typical Linux system.
paul@laika:~$ file pic33.png
pic33.png: PNG image data, 3840 x 1200, 8-bit/color RGBA, non-interlaced
paul@laika:~$ file /etc/passwd
/etc/passwd: ASCII text
paul@laika:~$ file HelloWorld.c
HelloWorld.c: ASCII C program text
The file command uses a magic file that contains patterns to recognise file types. The magic
file is located in /usr/share/file/magic. Type man 5 magic for more information.
It is interesting to point out file -s for special files like those in /dev and /proc.
root@debian6~# file /dev/sda
/dev/sda: block special
root@debian6~# file -s /dev/sda
/dev/sda: x86 boot sector; partition 1: ID=0x83, active, starthead...
root@debian6~# file /proc/cpuinfo
/proc/cpuinfo: empty
root@debian6~# file -s /proc/cpuinfo
/proc/cpuinfo: ASCII C++ program text
85working with files
9.4. touch
9.4.1. create an empty file
One easy way to create an empty file is with touch. (We will see many other ways for
creating files later in this book.)
This screenshot starts with an empty directory, creates two files with touch and the lists
those files.
paul@debian7:~$ ls -l
total 0
paul@debian7:~$ touch file42
paul@debian7:~$ touch file33
paul@debian7:~$ ls -l
total 0
-rw-r--r-- 1 paul paul 0 Oct 15 08:57 file33
-rw-r--r-- 1 paul paul 0 Oct 15 08:56 file42
paul@debian7:~$
9.4.2. touch -t
The touch command can set some properties while creating empty files. Can you determine
what is set by looking at the next screenshot? If not, check the manual for touch.
paul@debian7:~$ touch -t
paul@debian7:~$ touch -t
paul@debian7:~$ ls -l
total 0
-rw-r--r-- 1 paul paul 0
-rw-r--r-- 1 paul paul 0
-rw-r--r-- 1 paul paul 0
-rw-r--r-- 1 paul paul 0
paul@debian7:~$
200505050000 SinkoDeMayo
130207111630 BigBattle.txt
Jul 11 1302 BigBattle.txt
Oct 15 08:57 file33
Oct 15 08:56 file42
May 5 2005 SinkoDeMayo
86working with files
9.5. rm
9.5.1. remove forever
When you no longer need a file, use rm to remove it. Unlike some graphical user interfaces,
the command line in general does not have a waste bin or trash can to recover files. When
you use rm to remove a file, the file is gone. Therefore, be careful when removing files!
paul@debian7:~$ ls
BigBattle.txt file33 file42 SinkoDeMayo
paul@debian7:~$ rm BigBattle.txt
paul@debian7:~$ ls
file33 file42 SinkoDeMayo
paul@debian7:~$
9.5.2. rm -i
To prevent yourself from accidentally removing a file, you can type rm -i.
paul@debian7:~$ ls
file33 file42 SinkoDeMayo
paul@debian7:~$ rm -i file33
rm: remove regular empty file `file33'? yes
paul@debian7:~$ rm -i SinkoDeMayo
rm: remove regular empty file `SinkoDeMayo'? n
paul@debian7:~$ ls
file42 SinkoDeMayo
paul@debian7:~$
9.5.3. rm -rf
By default, rm -r will not remove non-empty directories. However rm accepts several
options that will allow you to remove any directory. The rm -rf statement is famous because
it will erase anything (providing that you have the permissions to do so). When you are
logged on as root, be very careful with rm -rf (the f means force and the r means recursive)
since being root implies that permissions don't apply to you. You can literally erase your
entire file system by accident.
paul@debian7:~$ mkdir test
paul@debian7:~$ rm test
rm: cannot remove `test': Is a directory
paul@debian7:~$ rm -rf test
paul@debian7:~$ ls test
ls: cannot access test: No such file or directory
paul@debian7:~$
87working with files
9.6. cp
9.6.1. copy one file
To copy a file, use cp with a source and a target argument.
paul@debian7:~$ ls
file42 SinkoDeMayo
paul@debian7:~$ cp file42 file42.copy
paul@debian7:~$ ls
file42 file42.copy SinkoDeMayo
9.6.2. copy to another directory
If the target is a directory, then the source files are copied to that target directory.
paul@debian7:~$ mkdir dir42
paul@debian7:~$ cp SinkoDeMayo dir42
paul@debian7:~$ ls dir42/
SinkoDeMayo
9.6.3. cp -r
To copy complete directories, use cp -r (the -r option forces recursive copying of all files
in all subdirectories).
paul@debian7:~$ ls
dir42 file42 file42.copy SinkoDeMayo
paul@debian7:~$ cp -r dir42/ dir33
paul@debian7:~$ ls
dir33 dir42 file42 file42.copy SinkoDeMayo
paul@debian7:~$ ls dir33/
SinkoDeMayo
9.6.4. copy multiple files to directory
You can also use cp to copy multiple files into a directory. In this case, the last argument
(a.k.a. the target) must be a directory.
paul@debian7:~$ cp file42 file42.copy SinkoDeMayo dir42/
paul@debian7:~$ ls dir42/
file42 file42.copy SinkoDeMayo
9.6.5. cp -i
To prevent cp from overwriting existing files, use the -i (for interactive) option.
paul@debian7:~$ cp SinkoDeMayo file42
paul@debian7:~$ cp SinkoDeMayo file42
paul@debian7:~$ cp -i SinkoDeMayo file42
cp: overwrite `file42'? n
paul@debian7:~$
88working with files
9.7. mv
9.7.1. rename files with mv
Use mv to rename a file or to move the file to another directory.
paul@debian7:~$ ls
dir33 dir42 file42 file42.copy
paul@debian7:~$ mv file42 file33
paul@debian7:~$ ls
dir33 dir42 file33 file42.copy
paul@debian7:~$
SinkoDeMayo
SinkoDeMayo
When you need to rename only one file then mv is the preferred command to use.
9.7.2. rename directories with mv
The same mv command can be used to rename directories.
paul@debian7:~$ ls -l
total 8
drwxr-xr-x 2 paul paul 4096 Oct
drwxr-xr-x 2 paul paul 4096 Oct
-rw-r--r-- 1 paul paul
0 Oct
-rw-r--r-- 1 paul paul
0 Oct
-rw-r--r-- 1 paul paul
0 May
paul@debian7:~$ mv dir33 backup
paul@debian7:~$ ls -l
total 8
drwxr-xr-x 2 paul paul 4096 Oct
drwxr-xr-x 2 paul paul 4096 Oct
-rw-r--r-- 1 paul paul
0 Oct
-rw-r--r-- 1 paul paul
0 Oct
-rw-r--r-- 1 paul paul
0 May
paul@debian7:~$
15
15
15
15
5 09:36
09:36
09:38
09:16
2005 dir33
dir42
file33
file42.copy
SinkoDeMayo
15
15
15
15
5 09:36
09:36
09:38
09:16
2005 backup
dir42
file33
file42.copy
SinkoDeMayo
9.7.3. mv -i
The mv also has a -i switch similar to cp and rm.
this screenshot shows that mv -i will ask permission to overwrite an existing file.
paul@debian7:~$ mv -i file33 SinkoDeMayo
mv: overwrite `SinkoDeMayo'? no
paul@debian7:~$
89working with files
9.8. rename
9.8.1. about rename
The rename command is one of the rare occasions where the Linux Fundamentals book
has to make a distinction between Linux distributions. Almost every command in the
Fundamentals part of this book works on almost every Linux computer. But rename is
different.
Try to use mv whenever you need to rename only a couple of files.
9.8.2. rename on Debian/Ubuntu
The rename command on Debian uses regular expressions (regular expression or shor regex
are explained in a later chapter) to rename many files at once.
Below a rename example that switches all occurrences of txt to png for all file names ending
in .txt.
paul@debian7:~/test42$ ls
abc.txt file33.txt file42.txt
paul@debian7:~/test42$ rename 's/\.txt/\.png/' *.txt
paul@debian7:~/test42$ ls
abc.png file33.png file42.png
This second example switches all (first) occurrences of file into document for all file names
ending in .png.
paul@debian7:~/test42$ ls
abc.png file33.png file42.png
paul@debian7:~/test42$ rename 's/file/document/' *.png
paul@debian7:~/test42$ ls
abc.png document33.png document42.png
paul@debian7:~/test42$
9.8.3. rename on CentOS/RHEL/Fedora
On Red Hat Enterprise Linux, the syntax of rename is a bit different. The first example
below renames all *.conf files replacing any occurrence of .conf with .backup.
[paul@centos7 ~]$ touch one.conf two.conf three.conf
[paul@centos7 ~]$ rename .conf .backup *.conf
[paul@centos7 ~]$ ls
one.backup three.backup two.backup
[paul@centos7 ~]$
The second example renames all (*) files replacing one with ONE.
[paul@centos7 ~]$ ls
one.backup three.backup two.backup
[paul@centos7 ~]$ rename one ONE *
[paul@centos7 ~]$ ls
ONE.backup three.backup two.backup
[paul@centos7 ~]$
90working with files
9.9. practice: working with files
1. List the files in the /bin directory
2. Display the type of file of /bin/cat, /etc/passwd and /usr/bin/passwd.
3a. Download wolf.jpg and LinuxFun.pdf from http://linux-training.be (wget http://
linux-training.be/files/studentfiles/wolf.jpg and wget http://linux-training.be/files/books/
LinuxFun.pdf)
wget http://linux-training.be/files/studentfiles/wolf.jpg
wget http://linux-training.be/files/studentfiles/wolf.png
wget http://linux-training.be/files/books/LinuxFun.pdf
3b. Display the type of file of wolf.jpg and LinuxFun.pdf
3c. Rename wolf.jpg to wolf.pdf (use mv).
3d. Display the type of file of wolf.pdf and LinuxFun.pdf.
4. Create a directory ~/touched and enter it.
5. Create the files today.txt and yesterday.txt in touched.
6. Change the date on yesterday.txt to match yesterday's date.
7. Copy yesterday.txt to copy.yesterday.txt
8. Rename copy.yesterday.txt to kim
9. Create a directory called ~/testbackup and copy all files from ~/touched into it.
10. Use one command to remove the directory ~/testbackup and all files into it.
11. Create a directory ~/etcbackup and copy all *.conf files from /etc into it. Did you include
all subdirectories of /etc ?
12. Use rename to rename all *.conf files to *.backup . (if you have more than one distro
available, try it on all!)
91working with files
9.10. solution: working with files
1. List the files in the /bin directory
ls /bin
2. Display the type of file of /bin/cat, /etc/passwd and /usr/bin/passwd.
file /bin/cat /etc/passwd /usr/bin/passwd
3a. Download wolf.jpg and LinuxFun.pdf from http://linux-training.be (wget http://
linux-training.be/files/studentfiles/wolf.jpg and wget http://linux-training.be/files/books/
LinuxFun.pdf)
wget http://linux-training.be/files/studentfiles/wolf.jpg
wget http://linux-training.be/files/studentfiles/wolf.png
wget http://linux-training.be/files/books/LinuxFun.pdf
3b. Display the type of file of wolf.jpg and LinuxFun.pdf
file wolf.jpg LinuxFun.pdf
3c. Rename wolf.jpg to wolf.pdf (use mv).
mv wolf.jpg wolf.pdf
3d. Display the type of file of wolf.pdf and LinuxFun.pdf.
file wolf.pdf LinuxFun.pdf
4. Create a directory ~/touched and enter it.
mkdir ~/touched ; cd ~/touched
5. Create the files today.txt and yesterday.txt in touched.
touch today.txt yesterday.txt
6. Change the date on yesterday.txt to match yesterday's date.
touch -t 200810251405 yesterday.txt (substitute 20081025 with yesterday)
7. Copy yesterday.txt to copy.yesterday.txt
cp yesterday.txt copy.yesterday.txt
8. Rename copy.yesterday.txt to kim
mv copy.yesterday.txt kim
9. Create a directory called ~/testbackup and copy all files from ~/touched into it.
mkdir ~/testbackup ; cp -r ~/touched ~/testbackup/
10. Use one command to remove the directory ~/testbackup and all files into it.
rm -rf ~/testbackup
11. Create a directory ~/etcbackup and copy all *.conf files from /etc into it. Did you include
all subdirectories of /etc ?
92working with files
cp -r /etc/*.conf ~/etcbackup
Only *.conf files that are directly in /etc/ are copied.
12. Use rename to rename all *.conf files to *.backup . (if you have more than one distro
available, try it on all!)
On RHEL: touch 1.conf 2.conf ; rename conf backup *.conf
On Debian: touch 1.conf 2.conf ; rename 's/conf/backup/' *.conf
93Chapter 10. working with file contents
In this chapter we will look at the contents of text files with head, tail, cat, tac, more, less
and strings.
We will also get a glimpse of the possibilities of tools like cat on the command line.
94working with file contents
10.1. head
You can use head to display the first ten lines of a file.
paul@debian7~$ head /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/bin/sh
man:x:6:12:man:/var/cache/man:/bin/sh
lp:x:7:7:lp:/var/spool/lpd:/bin/sh
mail:x:8:8:mail:/var/mail:/bin/sh
news:x:9:9:news:/var/spool/news:/bin/sh
root@debian7~#
The head command can also display the first n lines of a file.
paul@debian7~$ head -4 /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
paul@debian7~$
And head can also display the first n bytes.
paul@debian7~$ head -c14 /etc/passwd
root:x:0:0:roopaul@debian7~$
10.2. tail
Similar to head, the tail command will display the last ten lines of a file.
paul@debian7~$ tail /etc/services
vboxd
20012/udp
binkp
24554/tcp
asp
27374/tcp
asp
27374/udp
csync2
30865/tcp
dircproxy
57000/tcp
tfido
60177/tcp
fido
60179/tcp
# binkp fidonet protocol
# Address Search Protocol
#
#
#
#
cluster synchronization tool
Detachable IRC Proxy
fidonet EMSI over telnet
fidonet EMSI over TCP
# Local services
paul@debian7~$
You can give tail the number of lines you want to see.
paul@debian7~$ tail -3 /etc/services
fido
60179/tcp
# fidonet EMSI over TCP
# Local services
paul@debian7~$
The tail command has other useful options, some of which we will use during this course.
95working with file contents
10.3. cat
The cat command is one of the most universal tools, yet all it does is copy standard input to
standard output. In combination with the shell this can be very powerful and diverse. Some
examples will give a glimpse into the possibilities. The first example is simple, you can use
cat to display a file on the screen. If the file is longer than the screen, it will scroll to the end.
paul@debian8:~$ cat /etc/resolv.conf
domain linux-training.be
search linux-training.be
nameserver 192.168.1.42
10.3.1. concatenate
cat is short for concatenate. One of the basic uses of cat is to concatenate files into a bigger
(or complete) file.
paul@debian8:~$
paul@debian8:~$
paul@debian8:~$
paul@debian8:~$
one
paul@debian8:~$
two
paul@debian8:~$
three
paul@debian8:~$
one
two
three
paul@debian8:~$
paul@debian8:~$
one
two
three
paul@debian8:~$
echo one >part1
echo two >part2
echo three >part3
cat part1
cat part2
cat part3
cat part1 part2 part3
cat part1 part2 part3 >all
cat all
10.3.2. create files
You can use cat to create flat text files. Type the cat > winter.txt command as shown in the
screenshot below. Then type one or more lines, finishing each line with the enter key. After
the last line, type and hold the Control (Ctrl) key and press d.
paul@debian8:~$
It is very cold
paul@debian8:~$
It is very cold
paul@debian8:~$
cat > winter.txt
today!
cat winter.txt
today!
The Ctrl d key combination will send an EOF (End of File) to the running process ending
the cat command.
96working with file contents
10.3.3. custom end marker
You can choose an end marker for cat with << as is shown in this screenshot. This
construction is called a here directive and will end the cat command.
paul@debian8:~$ cat > hot.txt <<stop
> It is hot today!
> Yes it is summer.
> stop
paul@debian8:~$ cat hot.txt
It is hot today!
Yes it is summer.
paul@debian8:~$
10.3.4. copy files
In the third example you will see that cat can be used to copy files. We will explain in detail
what happens here in the bash shell chapter.
paul@debian8:~$
It is very cold
paul@debian8:~$
paul@debian8:~$
It is very cold
paul@debian8:~$
cat winter.txt
today!
cat winter.txt > cold.txt
cat cold.txt
today!
10.4. tac
Just one example will show you the purpose of tac (cat backwards).
paul@debian8:~$ cat count
one
two
three
four
paul@debian8:~$ tac count
four
three
two
one
97working with file contents
10.5. more and less
The more command is useful for displaying files that take up more than one screen. More
will allow you to see the contents of the file page by page. Use the space bar to see the next
page, or q to quit. Some people prefer the less command to more.
10.6. strings
With the strings command you can display readable ascii strings found in (binary) files.
This example locates the ls binary then displays readable strings in the binary file (output
is truncated).
paul@laika:~$ which ls
/bin/ls
paul@laika:~$ strings /bin/ls
/lib/ld-linux.so.2
librt.so.1
__gmon_start__
_Jv_RegisterClasses
clock_gettime
libacl.so.1
...
98working with file contents
10.7. practice: file contents
1. Display the first 12 lines of /etc/services.
2. Display the last line of /etc/passwd.
3. Use cat to create a file named count.txt that looks like this:
One
Two
Three
Four
Five
4. Use cp to make a backup of this file to cnt.txt.
5. Use cat to make a backup of this file to catcnt.txt.
6. Display catcnt.txt, but with all lines in reverse order (the last line first).
7. Use more to display /etc/services.
8. Display the readable character strings from the /usr/bin/passwd command.
9. Use ls to find the biggest file in /etc.
10. Open two terminal windows (or tabs) and make sure you are in the same directory in
both. Type echo this is the first line > tailing.txt in the first terminal, then issue tail -f
tailing.txt in the second terminal. Now go back to the first terminal and type echo This is
another line >> tailing.txt (note the double >>), verify that the tail -f in the second terminal
shows both lines. Stop the tail -f with Ctrl-C.
11. Use cat to create a file named tailing.txt that contains the contents of tailing.txt followed
by the contents of /etc/passwd.
12. Use cat to create a file named tailing.txt that contains the contents of tailing.txt preceded
by the contents of /etc/passwd.
99working with file contents
10.8. solution: file contents
1. Display the first 12 lines of /etc/services.
head -12 /etc/services
2. Display the last line of /etc/passwd.
tail -1 /etc/passwd
3. Use cat to create a file named count.txt that looks like this:
cat > count.txt
One
Two
Three
Four
Five (followed by Ctrl-d)
4. Use cp to make a backup of this file to cnt.txt.
cp count.txt cnt.txt
5. Use cat to make a backup of this file to catcnt.txt.
cat count.txt > catcnt.txt
6. Display catcnt.txt, but with all lines in reverse order (the last line first).
tac catcnt.txt
7. Use more to display /etc/services.
more /etc/services
8. Display the readable character strings from the /usr/bin/passwd command.
strings /usr/bin/passwd
9. Use ls to find the biggest file in /etc.
ls -lrS /etc
10. Open two terminal windows (or tabs) and make sure you are in the same directory in
both. Type echo this is the first line > tailing.txt in the first terminal, then issue tail -f
tailing.txt in the second terminal. Now go back to the first terminal and type echo This is
another line >> tailing.txt (note the double >>), verify that the tail -f in the second terminal
shows both lines. Stop the tail -f with Ctrl-C.
11. Use cat to create a file named tailing.txt that contains the contents of tailing.txt followed
by the contents of /etc/passwd.
cat /etc/passwd >> tailing.txt
12. Use cat to create a file named tailing.txt that contains the contents of tailing.txt preceded
by the contents of /etc/passwd.
mv tailing.txt tmp.txt ; cat /etc/passwd tmp.txt > tailing.txt
100Chapter 11. the Linux file tree
This chapter takes a look at the most common directories in the Linux file tree. It also shows
that on Unix everything is a file.
101the Linux file tree
11.1. filesystem hierarchy standard
Many Linux distributions partially follow the Filesystem Hierarchy Standard. The FHS
may help make more Unix/Linux file system trees conform better in the future. The FHS
is available online at http://www.pathname.com/fhs/ where we read: "The filesystem
hierarchy standard has been designed to be used by Unix distribution developers, package
developers, and system implementers. However, it is primarily intended to be a reference
and is not a tutorial on how to manage a Unix filesystem or directory hierarchy."
11.2. man hier
There are some differences in the filesystems between Linux distributions. For help about
your machine, enter man hier to find information about the file system hierarchy. This
manual will explain the directory structure on your computer.
11.3. the root directory /
All Linux systems have a directory structure that starts at the root directory. The root
directory is represented by a forward slash, like this: /. Everything that exists on your Linux
system can be found below this root directory. Let's take a brief look at the contents of the
root directory.
[paul@RHELv4u3 ~]$ ls /
bin
dev home media mnt
boot etc lib
misc
opt
proc
root
sbin
selinux
102
srv
sys
tftpboot
tmp
usr
varthe Linux file tree
11.4. binary directories
Binaries are files that contain compiled source code (or machine code). Binaries can be
executed on the computer. Sometimes binaries are called executables.
11.4.1. /bin
The /bin directory contains binaries for use by all users. According to the FHS the /bin
directory should contain /bin/cat and /bin/date (among others).
In the screenshot below you see common Unix/Linux commands like cat, cp, cpio, date, dd,
echo, grep, and so on. Many of these will be covered in this book.
paul@laika:~$ ls /bin
archdetect
egrep
autopartition
false
bash
fgconsole
bunzip2
fgrep
bzcat
fuser
bzcmp
fusermount
bzdiff
get_mountoptions
bzegrep
grep
bzexe
gunzip
bzfgrep
gzexe
bzgrep
gzip
bzip2
hostname
bzip2recover
hw-detect
bzless
ip
bzmore
kbd_mode
cat
kill
...
mt
mt-gnu
mv
nano
nc
nc.traditional
netcat
netstat
ntfs-3g
ntfs-3g.probe
parted_devices
parted_server
partman
partman-commit
perform_recipe
pidof
setupcon
sh
sh.distrib
sleep
stralign
stty
su
sync
sysfs
tailf
tar
tempfile
touch
true
ulockmgr
umount
11.4.2. other /bin directories
You can find a /bin subdirectory in many other directories. A user named serena could put
her own programs in /home/serena/bin.
Some applications, often when installed directly from source will put themselves in /opt. A
samba server installation can use /opt/samba/bin to store its binaries.
11.4.3. /sbin
/sbin contains binaries to configure the operating system. Many of the system binaries
require root privilege to perform certain tasks.
Below a screenshot containing system binaries to change the ip address, partition a disk
and create an ext4 file system.
paul@ubu1010:~$ ls -l /sbin/ifconfig /sbin/fdisk /sbin/mkfs.ext4
-rwxr-xr-x 1 root root 97172 2011-02-02 09:56 /sbin/fdisk
-rwxr-xr-x 1 root root 65708 2010-07-02 09:27 /sbin/ifconfig
-rwxr-xr-x 5 root root 55140 2010-08-18 18:01 /sbin/mkfs.ext4
103the Linux file tree
11.4.4. /lib
Binaries found in /bin and /sbin often use shared libraries located in /lib. Below is a
screenshot of the partial contents of /lib.
paul@laika:~$ ls /lib/libc*
/lib/libc-2.5.so
/lib/libcfont.so.0.0.0
/lib/libcap.so.1
/lib/libcidn-2.5.so
/lib/libcap.so.1.10 /lib/libcidn.so.1
/lib/libcfont.so.0
/lib/libcom_err.so.2
/lib/libcom_err.so.2.1
/lib/libconsole.so.0
/lib/libconsole.so.0.0.0
/lib/libcrypt-2.5.so
/lib/modules
Typically, the Linux kernel loads kernel modules from /lib/modules/$kernel-version/.
This directory is discussed in detail in the Linux kernel chapter.
/lib32 and /lib64
We currently are in a transition between 32-bit and 64-bit systems. Therefore, you may
encounter directories named /lib32 and /lib64 which clarify the register size used during
compilation time of the libraries. A 64-bit computer may have some 32-bit binaries and
libraries for compatibility with legacy applications. This screenshot uses the file utility to
demonstrate the difference.
paul@laika:~$ file /lib32/libc-2.5.so
/lib32/libc-2.5.so: ELF 32-bit LSB shared object, Intel 80386, \
version 1 (SYSV), for GNU/Linux 2.6.0, stripped
paul@laika:~$ file /lib64/libcap.so.1.10
/lib64/libcap.so.1.10: ELF 64-bit LSB shared object, AMD x86-64, \
version 1 (SYSV), stripped
The ELF (Executable and Linkable Format) is used in almost every Unix-like operating
system since System V.
11.4.5. /opt
The purpose of /opt is to store optional software. In many cases this is software from outside
the distribution repository. You may find an empty /opt directory on many systems.
A large package can install all its files in /bin, /lib, /etc subdirectories within /opt/
$packagename/. If for example the package is called wp, then it installs in /opt/wp, putting
binaries in /opt/wp/bin and manpages in /opt/wp/man.
104the Linux file tree
11.5. configuration directories
11.5.1. /boot
The /boot directory contains all files needed to boot the computer. These files don't change
very often. On Linux systems you typically find the /boot/grub directory here. /boot/grub
contains /boot/grub/grub.cfg (older systems may still have /boot/grub/grub.conf) which
defines the boot menu that is displayed before the kernel starts.
11.5.2. /etc
All of the machine-specific configuration files should be located in /etc. Historically /etc
stood for etcetera, today people often use the Editable Text Configuration backronym.
Many times the name of a configuration files is the same as the application, daemon, or
protocol with .conf added as the extension.
paul@laika:~$ ls /etc/*.conf
/etc/adduser.conf
/etc/ld.so.conf
/etc/brltty.conf
/etc/lftp.conf
/etc/ccertificates.conf /etc/libao.conf
/etc/cvs-cron.conf
/etc/logrotate.conf
/etc/ddclient.conf
/etc/ltrace.conf
/etc/debconf.conf
/etc/mke2fs.conf
/etc/deluser.conf
/etc/netscsid.conf
/etc/fdmount.conf
/etc/nsswitch.conf
/etc/hdparm.conf
/etc/pam.conf
/etc/host.conf
/etc/pnm2ppa.conf
/etc/inetd.conf
/etc/povray.conf
/etc/kernel-img.conf
/etc/resolv.conf
paul@laika:~$
/etc/scrollkeeper.conf
/etc/sysctl.conf
/etc/syslog.conf
/etc/ucf.conf
/etc/uniconf.conf
/etc/updatedb.conf
/etc/usplash.conf
/etc/uswsusp.conf
/etc/vnc.conf
/etc/wodim.conf
/etc/wvdial.conf
There is much more to be found in /etc.
/etc/init.d/
A lot of Unix/Linux distributions have an /etc/init.d directory that contains scripts to start
and stop daemons. This directory could disappear as Linux migrates to systems that replace
the old init way of starting all daemons.
/etc/X11/
The graphical display (aka X Window System or just X) is driven by software from the
X.org foundation. The configuration file for your graphical display is /etc/X11/xorg.conf.
/etc/skel/
The skeleton directory /etc/skel is copied to the home directory of a newly created user. It
usually contains hidden files like a .bashrc script.
/etc/sysconfig/
This directory, which is not mentioned in the FHS, contains a lot of Red Hat Enterprise
Linux configuration files. We will discuss some of them in greater detail. The screenshot
below is the /etc/sysconfig directory from RHELv4u4 with everything installed.
105the Linux file tree
paul@RHELv4u4:~$ ls /etc/sysconfig/
apmd
firstboot
irda
apm-scripts grub
irqbalance
authconfig
hidd
keyboard
autofs
httpd
kudzu
bluetooth
hwconf
lm_sensors
clock
i18n
mouse
console
init
mouse.B
crond
installinfo
named
desktop
ipmi
netdump
diskdump
iptables
netdump_id_dsa
dund
iptables-cfg netdump_id_dsa.p
paul@RHELv4u4:~$
network
networking
ntpd
openib.conf
pand
pcmcia
pgsql
prelink
rawdevices
rhn
samba
saslauthd
selinux
spamassassin
squid
syslog
sys-config-sec
sys-config-users
sys-logviewer
tux
vncservers
xinetd
The file /etc/sysconfig/firstboot tells the Red Hat Setup Agent not to run at boot time. If
you want to run the Red Hat Setup Agent at the next reboot, then simply remove this file,
and run chkconfig --level 5 firstboot on. The Red Hat Setup Agent allows you to install
the latest updates, create a user account, join the Red Hat Network and more. It will then
create the /etc/sysconfig/firstboot file again.
paul@RHELv4u4:~$ cat /etc/sysconfig/firstboot
RUN_FIRSTBOOT=NO
The /etc/sysconfig/harddisks file contains some parameters to tune the hard disks. The file
explains itself.
You can see hardware detected by kudzu in /etc/sysconfig/hwconf. Kudzu is software from
Red Hat for automatic discovery and configuration of hardware.
The keyboard type and keymap table are set in the /etc/sysconfig/keyboard file. For more
console keyboard information, check the manual pages of keymaps(5), dumpkeys(1),
loadkeys(1) and the directory /lib/kbd/keymaps/.
root@RHELv4u4:/etc/sysconfig# cat keyboard
KEYBOARDTYPE="pc"
KEYTABLE="us"
We will discuss networking files in this directory in the networking chapter.
106the Linux file tree
11.6. data directories
11.6.1. /home
Users can store personal or project data under /home. It is common (but not mandatory by
the fhs) practice to name the users home directory after the user name in the format /home/
$USERNAME. For example:
paul@ubu606:~$ ls /home
geert annik sandra paul
tom
Besides giving every user (or every project or group) a location to store personal files, the
home directory of a user also serves as a location to store the user profile. A typical Unix
user profile contains many hidden files (files whose file name starts with a dot). The hidden
files of the Unix user profiles contain settings specific for that user.
paul@ubu606:~$ ls -d /home/paul/.*
/home/paul/.
/home/paul/.bash_profile
/home/paul/..
/home/paul/.bashrc
/home/paul/.bash_history /home/paul/.lesshst
/home/paul/.ssh
/home/paul/.viminfo
11.6.2. /root
On many systems /root is the default location for personal data and profile of the root user.
If it does not exist by default, then some administrators create it.
11.6.3. /srv
You may use /srv for data that is served by your system. The FHS allows locating cvs,
rsync, ftp and www data in this location. The FHS also approves administrative naming in /
srv, like /srv/project55/ftp and /srv/sales/www.
On Sun Solaris (or Oracle Solaris) /export is used for this purpose.
11.6.4. /media
The /media directory serves as a mount point for removable media devices such as CD-
ROM's, digital cameras, and various usb-attached devices. Since /media is rather new in the
Unix world, you could very well encounter systems running without this directory. Solaris
9 does not have it, Solaris 10 does. Most Linux distributions today mount all removable
media in /media.
paul@debian5:~$ ls /media/
cdrom cdrom0 usbdisk
11.6.5. /mnt
The /mnt directory should be empty and should only be used for temporary mount points
(according to the FHS).
107the Linux file tree
Unix and Linux administrators used to create many directories here, like /mnt/something/.
You likely will encounter many systems with more than one directory created and/or
mounted inside /mnt to be used for various local and remote filesystems.
11.6.6. /tmp
Applications and users should use /tmp to store temporary data when needed. Data stored
in /tmp may use either disk space or RAM. Both of which are managed by the operating
system. Never use /tmp to store data that is important or which you wish to archive.
108the Linux file tree
11.7. in memory directories
11.7.1. /dev
Device files in /dev appear to be ordinary files, but are not actually located on the hard disk.
The /dev directory is populated with files as the kernel is recognising hardware.
common physical devices
Common hardware such as hard disk devices are represented by device files in /dev. Below
a screenshot of SATA device files on a laptop and then IDE attached drives on a desktop.
(The detailed meaning of these devices will be discussed later.)
#
# SATA or SCSI or USB
#
paul@laika:~$ ls /dev/sd*
/dev/sda /dev/sda1 /dev/sda2 /dev/sda3 /dev/sdb /dev/sdb1 /dev/sdb2
#
# IDE or ATAPI
#
paul@barry:~$ ls /dev/hd*
/dev/hda /dev/hda1 /dev/hda2 /dev/hdb /dev/hdb1 /dev/hdb2 /dev/hdc
Besides representing physical hardware, some device files are special. These special devices
can be very useful.
/dev/tty and /dev/pts
For example, /dev/tty1 represents a terminal or console attached to the system. (Don't
break your head on the exact terminology of 'terminal' or 'console', what we mean here is
a command line interface.) When typing commands in a terminal that is part of a graphical
interface like Gnome or KDE, then your terminal will be represented as /dev/pts/1 (1 can
be another number).
/dev/null
On Linux you will find other special devices such as /dev/null which can be considered
a black hole; it has unlimited storage, but nothing can be retrieved from it. Technically
speaking, anything written to /dev/null will be discarded. /dev/null can be useful to discard
unwanted output from commands. /dev/null is not a good location to store your backups ;-).
11.7.2. /proc conversation with the kernel
/proc is another special directory, appearing to be ordinary files, but not taking up disk
space. It is actually a view of the kernel, or better, what the kernel manages, and is a means
to interact with it directly. /proc is a proc filesystem.
paul@RHELv4u4:~$ mount -t proc
109the Linux file tree
none on /proc type proc (rw)
When listing the /proc directory you will see many numbers (on any Unix) and some
interesting files (on Linux)
mul@laika:~$ ls /proc
1
2339
4724 5418
10175 2523
4729 5421
10211 2783
4741 5658
10239 2975
4873 5661
141
29775 4874 5665
15045 29792 4878 5927
1519
2997
4879 6
1548
3
4881 6032
1551
30228 4882 6033
1554
3069
5
6145
1557
31422 5073 6298
1606
3149
5147 6414
180
31507 5203 6418
181
3189
5206 6419
182
3193
5228 6420
18898 3246
5272 6421
19799 3248
5291 6422
19803 3253
5294 6423
19804 3372
5356 6424
1987
4
5370 6425
1989
42
5379 6426
2
45
5380 6430
20845 4542
5412 6450
221
46
5414 6551
2338
4704
5416 6568
6587
6596
6599
6638
6652
6719
6736
6737
6755
6762
6774
6816
6991
6993
6996
7157
7163
7164
7171
7175
7188
7189
7191
7192
7199
7201
7204
7206
7214
7216
7218
7223
7224
7227
7260
7267
7275
7282
7298
7319
7330
7345
7513
7525
7529
9964
acpi
asound
buddyinfo
bus
cmdline
cpuinfo
crypto
devices
diskstats
dma
driver
execdomains
fb
filesystems
fs
ide
interrupts
iomem
ioports
irq
kallsyms
kcore
key-users
kmsg
loadavg
locks
meminfo
misc
modules
mounts
mtrr
net
pagetypeinfo
partitions
sched_debug
scsi
self
slabinfo
stat
swaps
sys
sysrq-trigger
sysvipc
timer_list
timer_stats
tty
uptime
version
version_signature
vmcore
vmnet
vmstat
zoneinfo
Let's investigate the file properties inside /proc. Looking at the date and time will display
the current date and time showing the files are constantly updated (a view on the kernel).
paul@RHELv4u4:~$ date
Mon Jan 29 18:06:32 EST 2007
paul@RHELv4u4:~$ ls -al /proc/cpuinfo
-r--r--r-- 1 root root 0 Jan 29 18:06 /proc/cpuinfo
paul@RHELv4u4:~$
paul@RHELv4u4:~$ ...time passes...
paul@RHELv4u4:~$
paul@RHELv4u4:~$ date
Mon Jan 29 18:10:00 EST 2007
paul@RHELv4u4:~$ ls -al /proc/cpuinfo
-r--r--r-- 1 root root 0 Jan 29 18:10 /proc/cpuinfo
Most files in /proc are 0 bytes, yet they contain data--sometimes a lot of data. You can see
this by executing cat on files like /proc/cpuinfo, which contains information about the CPU.
paul@RHELv4u4:~$ file /proc/cpuinfo
/proc/cpuinfo: empty
paul@RHELv4u4:~$ cat /proc/cpuinfo
processor
: 0
vendor_id
: AuthenticAMD
cpu family
: 15
model
: 43
110the Linux file tree
model name
stepping
cpu MHz
cache size
fdiv_bug
hlt_bug
f00f_bug
coma_bug
fpu
fpu_exception
cpuid level
wp
flags
bogomips
:
:
:
:
:
:
:
:
:
:
:
:
:
:
AMD Athlon(tm) 64 X2 Dual Core Processor 4600+
1
2398.628
512 KB
no
no
no
no
yes
yes
1
yes
fpu vme de pse tsc msr pae mce cx8 apic mtrr pge...
4803.54
Just for fun, here is /proc/cpuinfo on a Sun Sunblade 1000...
paul@pasha:~$ cat /proc/cpuinfo
cpu : TI UltraSparc III (Cheetah)
fpu : UltraSparc III integrated FPU
promlib : Version 3 Revision 2
prom : 4.2.2
type : sun4u
ncpus probed : 2
ncpus active : 2
Cpu0Bogo : 498.68
Cpu0ClkTck : 000000002cb41780
Cpu1Bogo : 498.68
Cpu1ClkTck : 000000002cb41780
MMU Type : Cheetah
State:
CPU0: online
CPU1: online
Most of the files in /proc are read only, some require root privileges, some files are writable,
and many files in /proc/sys are writable. Let's discuss some of the files in /proc.
111the Linux file tree
/proc/interrupts
On the x86 architecture, /proc/interrupts displays the interrupts.
paul@RHELv4u4:~$ cat /proc/interrupts
CPU0
0:
13876877
IO-APIC-edge timer
1:
15
IO-APIC-edge i8042
8:
1
IO-APIC-edge rtc
9:
0
IO-APIC-level acpi
12:
67
IO-APIC-edge i8042
14:
128
IO-APIC-edge ide0
15:
124320
IO-APIC-edge ide1
169:
111993
IO-APIC-level ioc0
177:
2428
IO-APIC-level eth0
NMI:
0
LOC:
13878037
ERR:
0
MIS:
0
On a machine with two CPU's, the file looks like this.
paul@laika:~$ cat /proc/interrupts
CPU0
CPU1
0:
860013
0 IO-APIC-edge
1:
4533
0 IO-APIC-edge
7:
0
0 IO-APIC-edge
8:
6588227
0 IO-APIC-edge
10:
2314
0 IO-APIC-fasteoi
12:
133
0 IO-APIC-edge
14:
0
0 IO-APIC-edge
15:
72269
0 IO-APIC-edge
18:
1
0 IO-APIC-fasteoi
19:
115036
0 IO-APIC-fasteoi
20:
126871
0 IO-APIC-fasteoi
21:
30204
0 IO-APIC-fasteoi
22:
1334
0 IO-APIC-fasteoi
24:
234739
0 IO-APIC-fasteoi
NMI:
72
42
LOC:
860000
859994
ERR:
0
timer
i8042
parport0
rtc
acpi
i8042
libata
libata
yenta
eth0
libata, ohci1394
ehci_hcd:usb1, uhci_hcd:usb2
saa7133[0], saa7133[0]
nvidia
/proc/kcore
The physical memory is represented in /proc/kcore. Do not try to cat this file, instead use a
debugger. The size of /proc/kcore is the same as your physical memory, plus four bytes.
paul@laika:~$ ls -lh /proc/kcore
-r-------- 1 root root 2.0G 2007-01-30 08:57 /proc/kcore
paul@laika:~$
112the Linux file tree
11.7.3. /sys Linux 2.6 hot plugging
The /sys directory was created for the Linux 2.6 kernel. Since 2.6, Linux uses sysfs
to support usb and IEEE 1394 (FireWire) hot plug devices. See the manual pages
of udev(8) (the successor of devfs) and hotplug(8) for more info (or visit http://linux-
hotplug.sourceforge.net/ ).
Basically the /sys directory contains kernel information about hardware.
113the Linux file tree
11.8. /usr Unix System Resources
Although /usr is pronounced like user, remember that it stands for Unix System Resources.
The /usr hierarchy should contain shareable, read only data. Some people choose to mount
/usr as read only. This can be done from its own partition or from a read only NFS share
(NFS is discussed later).
11.8.1. /usr/bin
The /usr/bin directory contains a lot of commands.
paul@deb508:~$ ls /usr/bin | wc -l
1395
(On Solaris the /bin directory is a symbolic link to /usr/bin.)
11.8.2. /usr/include
The /usr/include directory contains general use include files for C.
paul@ubu1010:~$ ls /usr/include/
aalib.h
expat_config.h
af_vfs.h
expat_external.h
aio.h
expat.h
AL
fcntl.h
aliases.h
features.h
...
math.h
mcheck.h
memory.h
menu.h
mntent.h
search.h
semaphore.h
setjmp.h
sgtty.h
shadow.h
11.8.3. /usr/lib
The /usr/lib directory contains libraries that are not directly executed by users or scripts.
paul@deb508:~$ ls /usr/lib | head -7
4Suite
ao
apt
arj
aspell
avahi
bonobo
11.8.4. /usr/local
The /usr/local directory can be used by an administrator to install software locally.
paul@deb508:~$ ls /usr/local/
bin etc games include lib man
paul@deb508:~$ du -sh /usr/local/
128K /usr/local/
sbin
share
src
11.8.5. /usr/share
The /usr/share directory contains architecture independent data. As you can see, this is a
fairly large directory.
paul@deb508:~$ ls /usr/share/ | wc -l
114the Linux file tree
263
paul@deb508:~$ du -sh /usr/share/
1.3G /usr/share/
This directory typically contains /usr/share/man for manual pages.
paul@deb508:~$ ls /usr/share/man
cs fr
hu it.UTF-8 man2 man6 pl.ISO8859-2 sv
de fr.ISO8859-1 id ja
man3 man7 pl.UTF-8
tr
es fr.UTF-8
it ko
man4 man8 pt_BR
zh_CN
fi gl
it.ISO8859-1 man1
man5 pl
ru
zh_TW
And it contains /usr/share/games for all static game data (so no high-scores or play logs).
paul@ubu1010:~$ ls /usr/share/games/
openttd wesnoth
11.8.6. /usr/src
The /usr/src directory is the recommended location for kernel source files.
paul@deb508:~$ ls -l /usr/src/
total 12
drwxr-xr-x 4 root root 4096 2011-02-01 14:43 linux-headers-2.6.26-2-686
drwxr-xr-x 18 root root 4096 2011-02-01 14:43 linux-headers-2.6.26-2-common
drwxr-xr-x 3 root root 4096 2009-10-28 16:01 linux-kbuild-2.6.26
115the Linux file tree
11.9. /var variable data
Files that are unpredictable in size, such as log, cache and spool files, should be located in
/var.
11.9.1. /var/log
The /var/log directory serves as a central point to contain all log files.
[paul@RHEL4b ~]$ ls /var/log
acpid
cron.2
maillog.2
amanda
cron.3
maillog.3
anaconda.log
cron.4
maillog.4
anaconda.syslog cups
mailman
anaconda.xlog
dmesg
messages
audit
exim
messages.1
boot.log
gdm
messages.2
boot.log.1
httpd
messages.3
boot.log.2
iiim
messages.4
boot.log.3
iptraf
mysqld.log
boot.log.4
lastlog
news
canna
mail
pgsql
cron
maillog
ppp
cron.1
maillog.1 prelink.log
quagga
radius
rpmpkgs
rpmpkgs.1
rpmpkgs.2
rpmpkgs.3
rpmpkgs.4
sa
samba
scrollkeeper.log
secure
secure.1
secure.2
secure.3
secure.4
spooler
spooler.1
spooler.2
spooler.3
spooler.4
squid
uucp
vbox
vmware-tools-guestd
wtmp
wtmp.1
Xorg.0.log
Xorg.0.log.old
11.9.2. /var/log/messages
A typical first file to check when troubleshooting on Red Hat (and derivatives) is the /var/
log/messages file. By default this file will contain information on what just happened to the
system. The file is called /var/log/syslog on Debian and Ubuntu.
[root@RHEL4b ~]# tail /var/log/messages
Jul 30 05:13:56 anacron: anacron startup succeeded
Jul 30 05:13:56 atd: atd startup succeeded
Jul 30 05:13:57 messagebus: messagebus startup succeeded
Jul 30 05:13:57 cups-config-daemon: cups-config-daemon startup succeeded
Jul 30 05:13:58 haldaemon: haldaemon startup succeeded
Jul 30 05:14:00 fstab-sync[3560]: removed all generated mount points
Jul 30 05:14:01 fstab-sync[3628]: added mount point /media/cdrom for...
Jul 30 05:14:01 fstab-sync[3646]: added mount point /media/floppy for...
Jul 30 05:16:46 sshd(pam_unix)[3662]: session opened for user paul by...
Jul 30 06:06:37 su(pam_unix)[3904]: session opened for user root by paul
11.9.3. /var/cache
The /var/cache directory can contain cache data for several applications.
paul@ubu1010:~$ ls /var/cache/
apt
dictionaries-common
binfmts flashplugin-installer
cups
fontconfig
debconf fonts
gdm
hald
jockey
ldconfig
man
pm-utils
pppconfig
samba
software-center
11.9.4. /var/spool
The /var/spool directory typically contains spool directories for mail and cron, but also
serves as a parent directory for other spool files (for example print spool files).
116the Linux file tree
11.9.5. /var/lib
The /var/lib directory contains application state information.
Red Hat Enterprise Linux for example keeps files pertaining to rpm in /var/lib/rpm/.
11.9.6. /var/...
/var also contains Process ID files in /var/run (soon to be replaced with /run) and temporary
files that survive a reboot in /var/tmp and information about file locks in /var/lock. There
will be more examples of /var usage further in this book.
117the Linux file tree
11.10. practice: file system tree
1. Does the file /bin/cat exist ? What about /bin/dd and /bin/echo. What is the type of these
files ?
2. What is the size of the Linux kernel file(s) (vmlinu*) in /boot ?
3. Create a directory ~/test. Then issue the following commands:
cd ~/test
dd if=/dev/zero of=zeroes.txt count=1 bs=100
od zeroes.txt
dd will copy one times (count=1) a block of size 100 bytes (bs=100) from the file /dev/zero
to ~/test/zeroes.txt. Can you describe the functionality of /dev/zero ?
4. Now issue the following command:
dd if=/dev/random of=random.txt count=1 bs=100 ; od random.txt
dd will copy one times (count=1) a block of size 100 bytes (bs=100) from the file /dev/
random to ~/test/random.txt. Can you describe the functionality of /dev/random ?
5. Issue the following two commands, and look at the first character of each output line.
ls -l /dev/sd* /dev/hd*
ls -l /dev/tty* /dev/input/mou*
The first ls will show block(b) devices, the second ls shows character(c) devices. Can you
tell the difference between block and character devices ?
6. Use cat to display /etc/hosts and /etc/resolv.conf. What is your idea about the purpose
of these files ?
7. Are there any files in /etc/skel/ ? Check also for hidden files.
8. Display /proc/cpuinfo. On what architecture is your Linux running ?
9. Display /proc/interrupts. What is the size of this file ? Where is this file stored ?
10. Can you enter the /root directory ? Are there (hidden) files ?
11. Are ifconfig, fdisk, parted, shutdown and grub-install present in /sbin ? Why are these
binaries in /sbin and not in /bin ?
12. Is /var/log a file or a directory ? What about /var/spool ?
13. Open two command prompts (Ctrl-Shift-T in gnome-terminal) or terminals (Ctrl-Alt-F1,
Ctrl-Alt-F2, ...) and issue the who am i in both. Then try to echo a word from one terminal
to the other.
118the Linux file tree
14. Read the man page of random and explain the difference between /dev/random and /
dev/urandom.
119the Linux file tree
11.11. solution: file system tree
1. Does the file /bin/cat exist ? What about /bin/dd and /bin/echo. What is the type of these
files ?
ls /bin/cat ; file /bin/cat
ls /bin/dd ; file /bin/dd
ls /bin/echo ; file /bin/echo
2. What is the size of the Linux kernel file(s) (vmlinu*) in /boot ?
ls -lh /boot/vm*
3. Create a directory ~/test. Then issue the following commands:
cd ~/test
dd if=/dev/zero of=zeroes.txt count=1 bs=100
od zeroes.txt
dd will copy one times (count=1) a block of size 100 bytes (bs=100) from the file /dev/zero
to ~/test/zeroes.txt. Can you describe the functionality of /dev/zero ?
/dev/zero is a Linux special device. It can be considered a source of zeroes. You cannot send
something to /dev/zero, but you can read zeroes from it.
4. Now issue the following command:
dd if=/dev/random of=random.txt count=1 bs=100 ; od random.txt
dd will copy one times (count=1) a block of size 100 bytes (bs=100) from the file /dev/
random to ~/test/random.txt. Can you describe the functionality of /dev/random ?
/dev/random acts as a random number generator on your Linux machine.
5. Issue the following two commands, and look at the first character of each output line.
ls -l /dev/sd* /dev/hd*
ls -l /dev/tty* /dev/input/mou*
The first ls will show block(b) devices, the second ls shows character(c) devices. Can you
tell the difference between block and character devices ?
Block devices are always written to (or read from) in blocks. For hard disks, blocks of 512
bytes are common. Character devices act as a stream of characters (or bytes). Mouse and
keyboard are typical character devices.
6. Use cat to display /etc/hosts and /etc/resolv.conf. What is your idea about the purpose
of these files ?
/etc/hosts contains hostnames with their ip address
/etc/resolv.conf should contain the ip address of a DNS name server.
120the Linux file tree
7. Are there any files in /etc/skel/ ? Check also for hidden files.
Issue "ls -al /etc/skel/". Yes, there should be hidden files there.
8. Display /proc/cpuinfo. On what architecture is your Linux running ?
The file should contain at least one line with Intel or other cpu.
9. Display /proc/interrupts. What is the size of this file ? Where is this file stored ?
The size is zero, yet the file contains data. It is not stored anywhere because /proc is a
virtual file system that allows you to talk with the kernel. (If you answered "stored in RAM-
memory, that is also correct...).
10. Can you enter the /root directory ? Are there (hidden) files ?
Try "cd /root". The /root directory is not accessible for normal users on most modern Linux sys
11. Are ifconfig, fdisk, parted, shutdown and grub-install present in /sbin ? Why are these
binaries in /sbin and not in /bin ?
Because those files are only meant for system administrators.
12. Is /var/log a file or a directory ? What about /var/spool ?
Both are directories.
13. Open two command prompts (Ctrl-Shift-T in gnome-terminal) or terminals (Ctrl-Alt-F1,
Ctrl-Alt-F2, ...) and issue the who am i in both. Then try to echo a word from one terminal
to the other.
tty-terminal: echo Hello > /dev/tty1
pts-terminal: echo Hello > /dev/pts/1
14. Read the man page of random and explain the difference between /dev/random and /
dev/urandom.
man 4 random
121Part IV. shell expansionTable of Contents
167Chapter 12. commands and
arguments
This chapter introduces you to shell expansion by taking a close look at commands and
arguments. Knowing shell expansion is important because many commands on your
Linux system are processed and most likely changed by the shell before they are executed.
The command line interface or shell used on most Linux systems is called bash, which
stands for Bourne again shell. The bash shell incorporates features from sh (the original
Bourne shell), csh (the C shell), and ksh (the Korn shell).
This chapter frequently uses the echo command to demonstrate shell features. The echo
command is very simple: it echoes the input that it receives.
paul@laika:~$ echo Burtonville
Burtonville
paul@laika:~$ echo Smurfs are blue
Smurfs are blue
125commands and arguments
12.1. arguments
One of the primary features of a shell is to perform a command line scan. When you enter
a command at the shell's command prompt and press the enter key, then the shell will start
scanning that line, cutting it up in arguments. While scanning the line, the shell may make
many changes to the arguments you typed.
This process is called shell expansion. When the shell has finished scanning and modifying
that line, then it will be executed.
12.2. white space removal
Parts that are separated by one or more consecutive white spaces (or tabs) are considered
separate arguments, any white space is removed. The first argument is the command to be
executed, the other arguments are given to the command. The shell effectively cuts your
command into one or more arguments.
This explains why the following four different command lines are the same after shell
expansion.
[paul@RHELv4u3
Hello World
[paul@RHELv4u3
Hello World
[paul@RHELv4u3
Hello World
[paul@RHELv4u3
Hello World
~]$ echo Hello World
~]$ echo Hello
~]$ echo
~]$
echo
Hello
World
World
Hello
World
The echo command will display each argument it receives from the shell. The echo
command will also add a new white space between the arguments it received.
126commands and arguments
12.3. single quotes
You can prevent the removal of white spaces by quoting the spaces. The contents of the
quoted string are considered as one argument. In the screenshot below the echo receives
only one argument.
[paul@RHEL4b ~]$ echo 'A line with
A line with
single
quotes
[paul@RHEL4b ~]$
single
quotes'
12.4. double quotes
You can also prevent the removal of white spaces by double quoting the spaces. Same as
above, echo only receives one argument.
[paul@RHEL4b ~]$ echo "A line with
A line with
double
quotes
[paul@RHEL4b ~]$
double
quotes"
Later in this book, when discussing variables we will see important differences between
single and double quotes.
12.5. echo and quotes
Quoted lines can include special escaped characters recognised by the echo command (when
using echo -e). The screenshot below shows how to use \n for a newline and \t for a tab
(usually eight white spaces).
[paul@RHEL4b
A line with
a newline
[paul@RHEL4b
A line with
a newline
[paul@RHEL4b
A line with
[paul@RHEL4b
A line with
[paul@RHEL4b
~]$ echo -e "A line with \na newline"
~]$ echo -e 'A line with \na newline'
~]$ echo -e "A line with \ta tab"
a tab
~]$ echo -e 'A line with \ta tab'
a tab
~]$
The echo command can generate more than white spaces, tabs and newlines. Look in the
man page for a list of options.
127commands and arguments
12.6. commands
12.6.1. external or builtin commands ?
Not all commands are external to the shell, some are builtin. External commands are
programs that have their own binary and reside somewhere in the file system. Many external
commands are located in /bin or /sbin. Builtin commands are an integral part of the shell
program itself.
12.6.2. type
To find out whether a command given to the shell will be executed as an external command
or as a builtin command, use the type command.
paul@laika:~$ type cd
cd is a shell builtin
paul@laika:~$ type cat
cat is /bin/cat
As you can see, the cd command is builtin and the cat command is external.
You can also use this command to show you whether the command is aliased or not.
paul@laika:~$ type ls
ls is aliased to `ls --color=auto'
12.6.3. running external commands
Some commands have both builtin and external versions. When one of these commands is
executed, the builtin version takes priority. To run the external version, you must enter the
full path to the command.
paul@laika:~$ type -a echo
echo is a shell builtin
echo is /bin/echo
paul@laika:~$ /bin/echo Running the external echo command...
Running the external echo command...
12.6.4. which
The which command will search for binaries in the $PATH environment variable (variables
will be explained later). In the screenshot below, it is determined that cd is builtin, and ls,
cp, rm, mv, mkdir, pwd, and which are external commands.
[root@RHEL4b ~]# which cp ls cd mkdir pwd
/bin/cp
/bin/ls
/usr/bin/which: no cd in (/usr/kerberos/sbin:/usr/kerberos/bin:...
/bin/mkdir
/bin/pwd
128commands and arguments
12.7. aliases
12.7.1. create an alias
The shell allows you to create aliases. Aliases are often used to create an easier to remember
name for an existing command or to easily supply parameters.
[paul@RHELv4u3 ~]$ cat count.txt
one
two
three
[paul@RHELv4u3 ~]$ alias dog=tac
[paul@RHELv4u3 ~]$ dog count.txt
three
two
one
12.7.2. abbreviate commands
An alias can also be useful to abbreviate an existing command.
paul@laika:~$ alias ll='ls -lh --color=auto'
paul@laika:~$ alias c='clear'
paul@laika:~$
12.7.3. default options
Aliases can be used to supply commands with default options. The example below shows
how to set the -i option default when typing rm.
[paul@RHELv4u3 ~]$
rm: remove regular
[paul@RHELv4u3 ~]$
[paul@RHELv4u3 ~]$
ls: winter.txt: No
[paul@RHELv4u3 ~]$
[paul@RHELv4u3 ~]$
[paul@RHELv4u3 ~]$
rm: remove regular
[paul@RHELv4u3 ~]$
rm -i winter.txt
file `winter.txt'? no
rm winter.txt
ls winter.txt
such file or directory
touch winter.txt
alias rm='rm -i'
rm winter.txt
empty file `winter.txt'? no
Some distributions enable default aliases to protect users from accidentally erasing files ('rm
-i', 'mv -i', 'cp -i')
12.7.4. viewing aliases
You can provide one or more aliases as arguments to the alias command to get their
definitions. Providing no arguments gives a complete list of current aliases.
paul@laika:~$ alias c ll
alias c='clear'
alias ll='ls -lh --color=auto'
129commands and arguments
12.7.5. unalias
You can undo an alias with the unalias command.
[paul@RHEL4b ~]$
/bin/rm
[paul@RHEL4b ~]$
[paul@RHEL4b ~]$
alias rm='rm -i'
/bin/rm
[paul@RHEL4b ~]$
[paul@RHEL4b ~]$
/bin/rm
[paul@RHEL4b ~]$
which rm
alias rm='rm -i'
which rm
unalias rm
which rm
12.8. displaying shell expansion
You can display shell expansion with set -x, and stop displaying it with set +x. You might
want to use this further on in this course, or when in doubt about exactly what the shell is
doing with your command.
[paul@RHELv4u3 ~]$ set -x
++ echo -ne '\033]0;paul@RHELv4u3:~\007'
[paul@RHELv4u3 ~]$ echo $USER
+ echo paul
paul
++ echo -ne '\033]0;paul@RHELv4u3:~\007'
[paul@RHELv4u3 ~]$ echo \$USER
+ echo '$USER'
$USER
++ echo -ne '\033]0;paul@RHELv4u3:~\007'
[paul@RHELv4u3 ~]$ set +x
+ set +x
[paul@RHELv4u3 ~]$ echo $USER
paul
130commands and arguments
12.9. practice: commands and arguments
1. How many arguments are in this line (not counting the command itself).
touch '/etc/cron/cron.allow' 'file 42.txt' "file 33.txt"
2. Is tac a shell builtin command ?
3. Is there an existing alias for rm ?
4. Read the man page of rm, make sure you understand the -i option of rm. Create and
remove a file to test the -i option.
5. Execute: alias rm='rm -i' . Test your alias with a test file. Does this work as expected ?
6. List all current aliases.
7a. Create an alias called 'city' that echoes your hometown.
7b. Use your alias to test that it works.
8. Execute set -x to display shell expansion for every command.
9. Test the functionality of set -x by executing your city and rm aliases.
10 Execute set +x to stop displaying shell expansion.
11. Remove your city alias.
12. What is the location of the cat and the passwd commands ?
13. Explain the difference between the following commands:
echo
/bin/echo
14. Explain the difference between the following commands:
echo Hello
echo -n Hello
15. Display A B C with two spaces between B and C.
(optional)16. Complete the following command (do not use spaces) to display exactly the
following output:
4+4
10+14
=8
=24
17. Use echo to display the following exactly:
??\\
131commands and arguments
Find two solutions with single quotes, two with double quotes and one without quotes (and
say thank you to Ren.' and Darioush from Google for this extra).
18. Use one echo command to display three words on three lines.
132commands and arguments
12.10. solution: commands and arguments
1. How many arguments are in this line (not counting the command itself).
touch '/etc/cron/cron.allow' 'file 42.txt' "file 33.txt"
answer: three
2. Is tac a shell builtin command ?
type tac
3. Is there an existing alias for rm ?
alias rm
4. Read the man page of rm, make sure you understand the -i option of rm. Create and
remove a file to test the -i option.
man rm
touch testfile
rm -i testfile
5. Execute: alias rm='rm -i' . Test your alias with a test file. Does this work as expected ?
touch testfile
rm testfile (should ask for confirmation)
6. List all current aliases.
alias
7a. Create an alias called 'city' that echoes your hometown.
alias city='echo Antwerp'
7b. Use your alias to test that it works.
city (it should display Antwerp)
8. Execute set -x to display shell expansion for every command.
set -x
9. Test the functionality of set -x by executing your city and rm aliases.
shell should display the resolved aliases and then execute the command:
paul@deb503:~$ set -x
paul@deb503:~$ city
+ echo antwerp
antwerp
10 Execute set +x to stop displaying shell expansion.
set +x
11. Remove your city alias.
133commands and arguments
unalias city
12. What is the location of the cat and the passwd commands ?
which cat (probably /bin/cat)
which passwd (probably /usr/bin/passwd)
13. Explain the difference between the following commands:
echo
/bin/echo
The echo command will be interpreted by the shell as the built-in echo command. The /bin/
echo command will make the shell execute the echo binary located in the /bin directory.
14. Explain the difference between the following commands:
echo Hello
echo -n Hello
The -n option of the echo command will prevent echo from echoing a trailing newline. echo
Hello will echo six characters in total, echo -n hello only echoes five characters.
(The -n option might not work in the Korn shell.)
15. Display A B C with two spaces between B and C.
echo "A B
C"
16. Complete the following command (do not use spaces) to display exactly the following
output:
4+4
10+14
=8
=24
The solution is to use tabs with \t.
echo -e "4+4\t=8" ; echo -e "10+14\t=24"
17. Use echo to display the following exactly:
??\\
echo
echo
echo
echo
echo
'??\\'
-e '??\\\\'
"??\\\\"
-e "??\\\\\\"
??\\\\
Find two solutions with single quotes, two with double quotes and one without quotes (and
say thank you to Ren*, and Darioush from Google for this extra).
18. Use one echo command to display three words on three lines.
echo -e "one \ntwo \nthree"
134Chapter 13. control operators
In this chapter we put more than one command on the command line using control
operators. We also briefly discuss related parameters ($?) and similar special characters(&).
135control operators
13.1. ; semicolon
You can put two or more commands on the same line separated by a semicolon ; . The shell
will scan the line until it reaches the semicolon. All the arguments before this semicolon
will be considered a separate command from all the arguments after the semicolon. Both
series will be executed sequentially with the shell waiting for each command to finish before
starting the next one.
[paul@RHELv4u3
Hello
[paul@RHELv4u3
World
[paul@RHELv4u3
Hello
World
[paul@RHELv4u3
~]$ echo Hello
~]$ echo World
~]$ echo Hello ; echo World
~]$
13.2. & ampersand
When a line ends with an ampersand &, the shell will not wait for the command to finish.
You will get your shell prompt back, and the command is executed in background. You will
get a message when this command has finished executing in background.
[paul@RHELv4u3 ~]$ sleep 20 &
[1] 7925
[paul@RHELv4u3 ~]$
...wait 20 seconds...
[paul@RHELv4u3 ~]$
[1]+ Done
sleep 20
The technical explanation of what happens in this case is explained in the chapter about
processes.
13.3. $? dollar question mark
The exit code of the previous command is stored in the shell variable $?. Actually $? is a
shell parameter and not a variable, since you cannot assign a value to $?.
paul@debian5:~/test$ touch file1
paul@debian5:~/test$ echo $?
0
paul@debian5:~/test$ rm file1
paul@debian5:~/test$ echo $?
0
paul@debian5:~/test$ rm file1
rm: cannot remove `file1': No such file or directory
paul@debian5:~/test$ echo $?
1
paul@debian5:~/test$
136control operators
13.4. && double ampersand
The shell will interpret && as a logical AND. When using && the second command is
executed only if the first one succeeds (returns a zero exit status).
paul@barry:~$ echo first && echo second
first
second
paul@barry:~$ zecho first && echo second
-bash: zecho: command not found
Another example of the same logical AND principle. This example starts with a working cd
followed by ls, then a non-working cd which is not followed by ls.
[paul@RHELv4u3 ~]$ cd gen && ls
file1 file3 File55 fileab FileAB
fileabc
file2 File4 FileA
Fileab fileab2
[paul@RHELv4u3 gen]$ cd gen && ls
-bash: cd: gen: No such file or directory
13.5. || double vertical bar
The || represents a logical OR. The second command is executed only when the first
command fails (returns a non-zero exit status).
paul@barry:~$ echo first || echo second ; echo third
first
third
paul@barry:~$ zecho first || echo second ; echo third
-bash: zecho: command not found
second
third
paul@barry:~$
Another example of the same logical OR principle.
[paul@RHELv4u3 ~]$ cd gen || ls
[paul@RHELv4u3 gen]$ cd gen || ls
-bash: cd: gen: No such file or directory
file1 file3 File55 fileab FileAB
fileabc
file2 File4 FileA
Fileab fileab2
13.6. combining && and ||
You can use this logical AND and logical OR to write an if-then-else structure on the
command line. This example uses echo to display whether the rm command was successful.
paul@laika:~/test$ rm file1 && echo It worked! || echo It failed!
It worked!
paul@laika:~/test$ rm file1 && echo It worked! || echo It failed!
rm: cannot remove `file1': No such file or directory
It failed!
paul@laika:~/test$
137control operators
13.7. # pound sign
Everything written after a pound sign (#) is ignored by the shell. This is useful to write a
shell comment, but has no influence on the command execution or shell expansion.
paul@debian4:~$ mkdir test
paul@debian4:~$ cd test
paul@debian4:~/test$ ls
paul@debian4:~/test$
# we create a directory
#### we enter the directory
# is it empty ?
13.8. \ escaping special characters
The backslash \ character enables the use of control characters, but without the shell
interpreting it, this is called escaping characters.
[paul@RHELv4u3
hello ; world
[paul@RHELv4u3
hello
world
[paul@RHELv4u3
escaping \ # &
[paul@RHELv4u3
escaping \?*"'
~]$ echo hello \; world
~]$ echo hello\ \ \ world
~]$ echo escaping \\\ \#\ \&\ \"\ \'
" '
~]$ echo escaping \\\?\*\"\'
13.8.1. end of line backslash
Lines ending in a backslash are continued on the next line. The shell does not interpret the
newline character and will wait on shell expansion and execution of the command line until
a newline without backslash is encountered.
[paul@RHEL4b ~]$ echo This command line \
> is split in three \
> parts
This command line is split in three parts
[paul@RHEL4b ~]$
138control operators
13.9. practice: control operators
0. Each question can be answered by one command line!
1. When you type passwd, which file is executed ?
2. What kind of file is that ?
3. Execute the pwd command twice. (remember 0.)
4. Execute ls after cd /etc, but only if cd /etc did not error.
5. Execute cd /etc after cd etc, but only if cd etc fails.
6. Echo it worked when touch test42 works, and echo it failed when the touch failed. All
on one command line as a normal user (not root). Test this line in your home directory and
in /bin/ .
7. Execute sleep 6, what is this command doing ?
8. Execute sleep 200 in background (do not wait for it to finish).
9. Write a command line that executes rm file55. Your command line should print 'success'
if file55 is removed, and print 'failed' if there was a problem.
(optional)10. Use echo to display "Hello World with strange' characters \ * [ } ~ \
\ ." (including all quotes)
139control operators
13.10. solution: control operators
0. Each question can be answered by one command line!
1. When you type passwd, which file is executed ?
which passwd
2. What kind of file is that ?
file /usr/bin/passwd
3. Execute the pwd command twice. (remember 0.)
pwd ; pwd
4. Execute ls after cd /etc, but only if cd /etc did not error.
cd /etc && ls
5. Execute cd /etc after cd etc, but only if cd etc fails.
cd etc || cd /etc
6. Echo it worked when touch test42 works, and echo it failed when the touch failed. All
on one command line as a normal user (not root). Test this line in your home directory and
in /bin/ .
paul@deb503:~$ cd ; touch test42 && echo it worked || echo it failed
it worked
paul@deb503:~$ cd /bin; touch test42 && echo it worked || echo it failed
touch: cannot touch `test42': Permission denied
it failed
7. Execute sleep 6, what is this command doing ?
pausing for six seconds
8. Execute sleep 200 in background (do not wait for it to finish).
sleep 200 &
9. Write a command line that executes rm file55. Your command line should print 'success'
if file55 is removed, and print 'failed' if there was a problem.
rm file55 && echo success || echo failed
(optional)10. Use echo to display "Hello World with strange' characters \ * [ } ~ \
\ ." (including all quotes)
echo \"Hello World with strange\' characters \\ \* \[ \} \~ \\\\ \. \"
or
echo \""Hello World with strange' characters \ * [ } ~ \\ . "\"
140Chapter 14. shell variables
In this chapter we learn to manage environment variables in the shell. These variables are
often needed by applications.
141shell variables
14.1. $ dollar sign
Another important character interpreted by the shell is the dollar sign $. The shell will look
for an environment variable named like the string following the dollar sign and replace it
with the value of the variable (or with nothing if the variable does not exist).
These are some examples using $HOSTNAME, $USER, $UID, $SHELL, and $HOME.
[paul@RHELv4u3 ~]$ echo This is the $SHELL shell
This is the /bin/bash shell
[paul@RHELv4u3 ~]$ echo This is $SHELL on computer $HOSTNAME
This is /bin/bash on computer RHELv4u3.localdomain
[paul@RHELv4u3 ~]$ echo The userid of $USER is $UID
The userid of paul is 500
[paul@RHELv4u3 ~]$ echo My homedir is $HOME
My homedir is /home/paul
14.2. case sensitive
This example shows that shell variables are case sensitive!
[paul@RHELv4u3 ~]$ echo Hello $USER
Hello paul
[paul@RHELv4u3 ~]$ echo Hello $user
Hello
14.3. creating variables
This example creates the variable $MyVar and sets its value. It then uses echo to verify
the value.
[paul@RHELv4u3 gen]$ MyVar=555
[paul@RHELv4u3 gen]$ echo $MyVar
555
[paul@RHELv4u3 gen]$
142shell variables
14.4. quotes
Notice that double quotes still allow the parsing of variables, whereas single quotes prevent
this.
[paul@RHELv4u3
[paul@RHELv4u3
555
[paul@RHELv4u3
555
[paul@RHELv4u3
$MyVar
~]$ MyVar=555
~]$ echo $MyVar
~]$ echo "$MyVar"
~]$ echo '$MyVar'
The bash shell will replace variables with their value in double quoted lines, but not in single
quoted lines.
paul@laika:~$ city=Burtonville
paul@laika:~$ echo "We are in $city today."
We are in Burtonville today.
paul@laika:~$ echo 'We are in $city today.'
We are in $city today.
14.5. set
You can use the set command to display a list of environment variables. On Ubuntu and
Debian systems, the set command will also list shell functions after the shell variables. Use
set | more to see the variables then.
14.6. unset
Use the unset command to remove a variable from your shell environment.
[paul@RHEL4b
[paul@RHEL4b
8472
[paul@RHEL4b
[paul@RHEL4b
~]$ MyVar=8472
~]$ echo $MyVar
~]$ unset MyVar
~]$ echo $MyVar
[paul@RHEL4b ~]$
143shell variables
14.7. $PS1
The $PS1 variable determines your shell prompt. You can use backslash escaped special
characters like \u for the username or \w for the working directory. The bash manual has
a complete reference.
In this example we change the value of $PS1 a couple of times.
paul@deb503:~$ PS1=prompt
prompt
promptPS1='prompt '
prompt
prompt PS1='> '
>
> PS1='\u@\h$ '
paul@deb503$
paul@deb503$ PS1='\u@\h:\W$'
paul@deb503:~$
To avoid unrecoverable mistakes, you can set normal user prompts to green and the root
prompt to red. Add the following to your .bashrc for a green user prompt:
# color prompt by paul
RED='\[\033[01;31m\]'
WHITE='\[\033[01;00m\]'
GREEN='\[\033[01;32m\]'
BLUE='\[\033[01;34m\]'
export PS1="${debian_chroot:+($debian_chroot)}$GREEN\u$WHITE@$BLUE\h$WHITE\w\$ "
144shell variables
14.8. $PATH
The $PATH variable is determines where the shell is looking for commands to execute
(unless the command is builtin or aliased). This variable contains a list of directories,
separated by colons.
[[paul@RHEL4b ~]$ echo $PATH
/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin:
The shell will not look in the current directory for commands to execute! (Looking for
executables in the current directory provided an easy way to hack PC-DOS computers). If
you want the shell to look in the current directory, then add a . at the end of your $PATH.
[paul@RHEL4b ~]$ PATH=$PATH:.
[paul@RHEL4b ~]$ echo $PATH
/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin:.
[paul@RHEL4b ~]$
Your path might be different when using su instead of su - because the latter will take on
the environment of the target user. The root user typically has /sbin directories added to the
$PATH variable.
[paul@RHEL3 ~]$ su
Password:
[root@RHEL3 paul]# echo $PATH
/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin
[root@RHEL3 paul]# exit
[paul@RHEL3 ~]$ su -
Password:
[root@RHEL3 ~]# echo $PATH
/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin:
[root@RHEL3 ~]#
145shell variables
14.9. env
The env command without options will display a list of exported variables. The difference
with set with options is that set lists all variables, including those not exported to child shells.
But env can also be used to start a clean shell (a shell without any inherited environment).
The env -i command clears the environment for the subshell.
Notice in this screenshot that bash will set the $SHELL variable on startup.
[paul@RHEL4b ~]$ bash -c 'echo $SHELL $HOME $USER'
/bin/bash /home/paul paul
[paul@RHEL4b ~]$ env -i bash -c 'echo $SHELL $HOME $USER'
/bin/bash
[paul@RHEL4b ~]$
You can use the env command to set the $LANG, or any other, variable for just one instance
of bash with one command. The example below uses this to show the influence of the
$LANG variable on file globbing (see the chapter on file globbing).
[paul@RHEL4b test]$ env LANG=C bash -c 'ls File[a-z]'
Filea Fileb
[paul@RHEL4b test]$ env LANG=en_US.UTF-8 bash -c 'ls File[a-z]'
Filea FileA Fileb FileB
[paul@RHEL4b test]$
14.10. export
You can export shell variables to other shells with the export command. This will export
the variable to child shells.
[paul@RHEL4b
[paul@RHEL4b
[paul@RHEL4b
[paul@RHEL4b
three four
[paul@RHEL4b
[paul@RHEL4b
four
~]$
~]$
~]$
~]$
var3=three
var4=four
export var4
echo $var3 $var4
~]$ bash
~]$ echo $var3 $var4
But it will not export to the parent shell (previous screenshot continued).
[paul@RHEL4b
[paul@RHEL4b
four five
[paul@RHEL4b
exit
[paul@RHEL4b
three four
[paul@RHEL4b
~]$ export var5=five
~]$ echo $var3 $var4 $var5
~]$ exit
~]$ echo $var3 $var4 $var5
~]$
146shell variables
14.11. delineate variables
Until now, we have seen that bash interprets a variable starting from a dollar sign, continuing
until the first occurrence of a non-alphanumeric character that is not an underscore. In some
situations, this can be a problem. This issue can be resolved with curly braces like in this
example.
[paul@RHEL4b ~]$ prefix=Super
[paul@RHEL4b ~]$ echo Hello $prefixman and $prefixgirl
Hello and
[paul@RHEL4b ~]$ echo Hello ${prefix}man and ${prefix}girl
Hello Superman and Supergirl
[paul@RHEL4b ~]$
14.12. unbound variables
The example below tries to display the value of the $MyVar variable, but it fails because the
variable does not exist. By default the shell will display nothing when a variable is unbound
(does not exist).
[paul@RHELv4u3 gen]$ echo $MyVar
[paul@RHELv4u3 gen]$
There is, however, the nounset shell option that you can use to generate an error when a
variable does not exist.
paul@laika:~$ set -u
paul@laika:~$ echo $Myvar
bash: Myvar: unbound variable
paul@laika:~$ set +u
paul@laika:~$ echo $Myvar
paul@laika:~$
In the bash shell set -u is identical to set -o nounset and likewise set +u is identical to set
+o nounset.
147shell variables
14.13. practice: shell variables
1. Use echo to display Hello followed by your username. (use a bash variable!)
2. Create a variable answer with a value of 42.
3. Copy the value of $LANG to $MyLANG.
4. List all current shell variables.
5. List all exported shell variables.
6. Do the env and set commands display your variable ?
6. Destroy your answer variable.
7. Create two variables, and export one of them.
8. Display the exported variable in an interactive child shell.
9. Create a variable, give it the value 'Dumb', create another variable with value 'do'. Use
echo and the two variables to echo Dumbledore.
10. Find the list of backslash escaped characters in the manual of bash. Add the time to your
PS1 prompt.
148shell variables
14.14. solution: shell variables
1. Use echo to display Hello followed by your username. (use a bash variable!)
echo Hello $USER
2. Create a variable answer with a value of 42.
answer=42
3. Copy the value of $LANG to $MyLANG.
MyLANG=$LANG
4. List all current shell variables.
set
set|more on Ubuntu/Debian
5. List all exported shell variables.
env
export
declare -x
6. Do the env and set commands display your variable ?
env | more
set | more
6. Destroy your answer variable.
unset answer
7. Create two variables, and export one of them.
var1=1; export var2=2
8. Display the exported variable in an interactive child shell.
bash
echo $var2
9. Create a variable, give it the value 'Dumb', create another variable with value 'do'. Use
echo and the two variables to echo Dumbledore.
varx=Dumb; vary=do
echo ${varx}le${vary}re
solution by Yves from Dexia : echo $varx'le'$vary're'
solution by Erwin from Telenet : echo "$varx"le"$vary"re
10. Find the list of backslash escaped characters in the manual of bash. Add the time to your
PS1 prompt.
PS1='\t \u@\h \W$ '
149Chapter 15. shell embedding and
options
This chapter takes a brief look at child shells, embedded shells and shell options.
150shell embedding and options
15.1. shell embedding
Shells can be embedded on the command line, or in other words, the command line scan
can spawn new processes containing a fork of the current shell. You can use variables to
prove that new shells are created. In the screenshot below, the variable $var1 only exists in
the (temporary) sub shell.
[paul@RHELv4u3 gen]$ echo $var1
[paul@RHELv4u3 gen]$ echo $(var1=5;echo $var1)
5
[paul@RHELv4u3 gen]$ echo $var1
[paul@RHELv4u3 gen]$
You can embed a shell in an embedded shell, this is called nested embedding of shells.
This screenshot shows an embedded shell inside an embedded shell.
paul@deb503:~$ A=shell
paul@deb503:~$ echo $C$B$A $(B=sub;echo $C$B$A; echo $(C=sub;echo $C$B$A))
shell subshell subsubshell
15.1.1. backticks
Single embedding can be useful to avoid changing your current directory. The screenshot
below uses backticks instead of dollar-bracket to embed.
[paul@RHELv4u3 ~]$ echo `cd /etc; ls -d * | grep pass`
passwd passwd- passwd.OLD
[paul@RHELv4u3 ~]$
You can only use the $() notation to nest embedded shells, backticks cannot do this.
15.1.2. backticks or single quotes
Placing the embedding between backticks uses one character less than the dollar and
parenthesis combo. Be careful however, backticks are often confused with single quotes.
The technical difference between ' and ` is significant!
[paul@RHELv4u3 gen]$ echo `var1=5;echo $var1`
5
[paul@RHELv4u3 gen]$ echo 'var1=5;echo $var1'
var1=5;echo $var1
[paul@RHELv4u3 gen]$
151shell embedding and options
15.2. shell options
Both set and unset are builtin shell commands. They can be used to set options of the bash
shell itself. The next example will clarify this. By default, the shell will treat unset variables
as a variable having no value. By setting the -u option, the shell will treat any reference to
unset variables as an error. See the man page of bash for more information.
[paul@RHEL4b ~]$ echo $var123
[paul@RHEL4b ~]$ set -u
[paul@RHEL4b ~]$ echo $var123
-bash: var123: unbound variable
[paul@RHEL4b ~]$ set +u
[paul@RHEL4b ~]$ echo $var123
[paul@RHEL4b ~]$
To list all the set options for your shell, use echo $-. The noclobber (or -C) option will be
explained later in this book (in the I/O redirection chapter).
[paul@RHEL4b
himBH
[paul@RHEL4b
[paul@RHEL4b
himuBCH
[paul@RHEL4b
[paul@RHEL4b
himBH
[paul@RHEL4b
~]$ echo $-
~]$ set -C ; set -u
~]$ echo $-
~]$ set +C ; set +u
~]$ echo $-
~]$
When typing set without options, you get a list of all variables without function when the
shell is on posix mode. You can set bash in posix mode typing set -o posix.
152shell embedding and options
15.3. practice: shell embedding
1. Find the list of shell options in the man page of bash. What is the difference between set
-u and set -o nounset?
2. Activate nounset in your shell. Test that it shows an error message when using non-
existing variables.
3. Deactivate nounset.
4. Execute cd /var and ls in an embedded shell.
The echo command is only needed to show the result of the ls command. Omitting will result
in the shell trying to execute the first file as a command.
5. Create the variable embvar in an embedded shell and echo it. Does the variable exist in
your current shell now ?
6. Explain what "set -x" does. Can this be useful ?
(optional)7. Given the following screenshot, add exactly four characters to that command
line so that the total output is FirstMiddleLast.
[paul@RHEL4b ~]$ echo
First; echo
Middle; echo
Last
8. Display a long listing (ls -l) of the passwd command using the which command inside
an embedded shell.
153shell embedding and options
15.4. solution: shell embedding
1. Find the list of shell options in the man page of bash. What is the difference between set
-u and set -o nounset?
read the manual of bash (man bash), search for nounset -- both mean the same thing.
2. Activate nounset in your shell. Test that it shows an error message when using non-
existing variables.
set -u
OR
set -o nounset
Both these lines have the same effect.
3. Deactivate nounset.
set +u
OR
set +o nounset
4. Execute cd /var and ls in an embedded shell.
echo $(cd /var ; ls)
The echo command is only needed to show the result of the ls command. Omitting will result
in the shell trying to execute the first file as a command.
5. Create the variable embvar in an embedded shell and echo it. Does the variable exist in
your current shell now ?
echo $(embvar=emb;echo $embvar) ; echo $embvar #the last echo fails
$embvar does not exist in your current shell
6. Explain what "set -x" does. Can this be useful ?
It displays shell expansion for troubleshooting your command.
(optional)7. Given the following screenshot, add exactly four characters to that command
line so that the total output is FirstMiddleLast.
[paul@RHEL4b ~]$ echo
First; echo
Middle; echo
Last
echo -n First; echo -n Middle; echo Last
8. Display a long listing (ls -l) of the passwd command using the which command inside
an embedded shell.
ls -l $(which passwd)
154Chapter 16. shell history
The shell makes it easy for us to repeat commands, this chapter explains how.
155shell history
16.1. repeating the last command
To repeat the last command in bash, type !!. This is pronounced as bang bang.
paul@debian5:~/test42$ echo this will be repeated > file42.txt
paul@debian5:~/test42$ !!
echo this will be repeated > file42.txt
paul@debian5:~/test42$
16.2. repeating other commands
You can repeat other commands using one bang followed by one or more characters. The
shell will repeat the last command that started with those characters.
paul@debian5:~/test42$ touch file42
paul@debian5:~/test42$ cat file42
paul@debian5:~/test42$ !to
touch file42
paul@debian5:~/test42$
16.3. history
To see older commands, use history to display the shell command history (or use history
n to see the last n commands).
paul@debian5:~/test$ history 10
38 mkdir test
39 cd test
40 touch file1
41 echo hello > file2
42 echo It is very cold today > winter.txt
43 ls
44 ls -l
45 cp winter.txt summer.txt
46 ls -l
47 history 10
16.4. !n
When typing ! followed by the number preceding the command you want repeated, then the
shell will echo the command and execute it.
paul@debian5:~/test$ !43
ls
file1 file2 summer.txt
winter.txt
156shell history
16.5. Ctrl-r
Another option is to use ctrl-r to search in the history. In the screenshot below i only typed
ctrl-r followed by four characters apti and it finds the last command containing these four
consecutive characters.
paul@debian5:~$
(reverse-i-search)`apti': sudo aptitude install screen
16.6. $HISTSIZE
The $HISTSIZE variable determines the number of commands that will be remembered in
your current environment. Most distributions default this variable to 500 or 1000.
paul@debian5:~$ echo $HISTSIZE
500
You can change it to any value you like.
paul@debian5:~$ HISTSIZE=15000
paul@debian5:~$ echo $HISTSIZE
15000
16.7. $HISTFILE
The $HISTFILE variable points to the file that contains your history. The bash shell defaults
this value to ~/.bash_history.
paul@debian5:~$ echo $HISTFILE
/home/paul/.bash_history
A session history is saved to this file when you exit the session!
Closing a gnome-terminal with the mouse, or typing reboot as root will NOT save your
terminal's history.
16.8. $HISTFILESIZE
The number of commands kept in your history file can be set using $HISTFILESIZE.
paul@debian5:~$ echo $HISTFILESIZE
15000
157shell history
16.9. prevent recording a command
You can prevent a command from being recorded in history using a space prefix.
paul@debian8:~/github$ echo abc
abc
paul@debian8:~/github$ echo def
def
paul@debian8:~/github$ echo ghi
ghi
paul@debian8:~/github$ history 3
9501 echo abc
9502 echo ghi
9503 history 3
16.10. (optional)regular expressions
It is possible to use regular expressions when using the bang to repeat commands. The
screenshot below switches 1 into 2.
paul@debian5:~/test$ cat file1
paul@debian5:~/test$ !c:s/1/2
cat file2
hello
paul@debian5:~/test$
16.11. (optional) Korn shell history
Repeating a command in the Korn shell is very similar. The Korn shell also has the history
command, but uses the letter r to recall lines from history.
This screenshot shows the history command. Note the different meaning of the parameter.
$ history 17
17 clear
18 echo hoi
19 history 12
20 echo world
21 history 17
Repeating with r can be combined with the line numbers given by the history command, or
with the first few letters of the command.
$ r e
echo world
world
$ cd /etc
$ r
cd /etc
$
158shell history
16.12. practice: shell history
1. Issue the command echo The answer to the meaning of life, the universe and
everything is 42.
2. Repeat the previous command using only two characters (there are two solutions!)
3. Display the last 5 commands you typed.
4. Issue the long echo from question 1 again, using the line numbers you received from the
command in question 3.
5. How many commands can be kept in memory for your current shell session ?
6. Where are these commands stored when exiting the shell ?
7. How many commands can be written to the history file when exiting your current shell
session ?
8. Make sure your current bash shell remembers the next 5000 commands you type.
9. Open more than one console (by press Ctrl-shift-t in gnome-terminal, or by opening an
extra putty.exe in MS Windows) with the same user account. When is command history
written to the history file ?
159shell history
16.13. solution: shell history
1. Issue the command echo The answer to the meaning of life, the universe and
everything is 42.
echo The answer to the meaning of life, the universe and everything is 42
2. Repeat the previous command using only two characters (there are two solutions!)
!!
OR
!e
3. Display the last 5 commands you typed.
paul@ubu1010:~$ history 5
52 ls -l
53 ls
54 df -h | grep sda
55 echo The answer to the meaning of life, the universe and everything is 42
56 history 5
You will receive different line numbers.
4. Issue the long echo from question 1 again, using the line numbers you received from the
command in question 3.
paul@ubu1010:~$ !55
echo The answer to the meaning of life, the universe and everything is 42
The answer to the meaning of life, the universe and everything is 42
5. How many commands can be kept in memory for your current shell session ?
echo $HISTSIZE
6. Where are these commands stored when exiting the shell ?
echo $HISTFILE
7. How many commands can be written to the history file when exiting your current shell
session ?
echo $HISTFILESIZE
8. Make sure your current bash shell remembers the next 5000 commands you type.
HISTSIZE=5000
9. Open more than one console (by press Ctrl-shift-t in gnome-terminal, or by opening an
extra putty.exe in MS Windows) with the same user account. When is command history
written to the history file ?
when you type exit
160Chapter 17. file globbing
The shell is also responsible for file globbing (or dynamic filename generation). This chapter
will explain file globbing.
161file globbing
17.1. * asterisk
The asterisk * is interpreted by the shell as a sign to generate filenames, matching the asterisk
to any combination of characters (even none). When no path is given, the shell will use
filenames in the current directory. See the man page of glob(7) for more information. (This
is part of LPI topic 1.103.3.)
[paul@RHELv4u3 gen]$
file1 file2 file3
[paul@RHELv4u3 gen]$
File4 File55 FileA
[paul@RHELv4u3 gen]$
file1 file2 file3
[paul@RHELv4u3 gen]$
File55
[paul@RHELv4u3 gen]$
File55
[paul@RHELv4u3 gen]$
File55
[paul@RHELv4u3 gen]$
ls
File4 File55 FileA
ls File*
Fileab FileAB
ls file*
fileab fileabc
ls *ile55
fileab
Fileab
FileAB
fileabc
ls F*ile55
ls F*55
17.2. ? question mark
Similar to the asterisk, the question mark ? is interpreted by the shell as a sign to generate
filenames, matching the question mark with exactly one character.
[paul@RHELv4u3 gen]$ ls
file1 file2 file3 File4 File55
[paul@RHELv4u3 gen]$ ls File?
File4 FileA
[paul@RHELv4u3 gen]$ ls Fil?4
File4
[paul@RHELv4u3 gen]$ ls Fil??
File4 FileA
[paul@RHELv4u3 gen]$ ls File??
File55 Fileab FileAB
[paul@RHELv4u3 gen]$
FileA
162
fileab
Fileab
FileAB
fileabcfile globbing
17.3. [] square brackets
The square bracket [ is interpreted by the shell as a sign to generate filenames, matching
any of the characters between [ and the first subsequent ]. The order in this list between the
brackets is not important. Each pair of brackets is replaced by exactly one character.
[paul@RHELv4u3 gen]$ ls
file1 file2 file3 File4 File55 FileA fileab Fileab FileAB
[paul@RHELv4u3 gen]$ ls File[5A]
FileA
[paul@RHELv4u3 gen]$ ls File[A5]
FileA
[paul@RHELv4u3 gen]$ ls File[A5][5b]
File55
[paul@RHELv4u3 gen]$ ls File[a5][5b]
File55 Fileab
[paul@RHELv4u3 gen]$ ls File[a5][5b][abcdefghijklm]
ls: File[a5][5b][abcdefghijklm]: No such file or directory
[paul@RHELv4u3 gen]$ ls file[a5][5b][abcdefghijklm]
fileabc
[paul@RHELv4u3 gen]$
fileabc
You can also exclude characters from a list between square brackets with the exclamation
mark !. And you are allowed to make combinations of these wild cards.
[paul@RHELv4u3 gen]$
file1 file2 file3
[paul@RHELv4u3 gen]$
fileab
[paul@RHELv4u3 gen]$
file1 file2 file3
[paul@RHELv4u3 gen]$
fileab
[paul@RHELv4u3 gen]$
ls
File4 File55 FileA
ls file[a5][!Z]
ls file[!5]*
fileab fileabc
ls file[!5]?
163
fileab
Fileab
FileAB
fileabcfile globbing
17.4. a-z and 0-9 ranges
The bash shell will also understand ranges of characters between brackets.
[paul@RHELv4u3 gen]$ ls
file1 file3 File55 fileab FileAB
fileabc
file2 File4 FileA
Fileab fileab2
[paul@RHELv4u3 gen]$ ls file[a-z]*
fileab fileab2 fileabc
[paul@RHELv4u3 gen]$ ls file[0-9]
file1 file2 file3
[paul@RHELv4u3 gen]$ ls file[a-z][a-z][0-9]*
fileab2
[paul@RHELv4u3 gen]$
17.5. $LANG and square brackets
But, don't forget the influence of the LANG variable. Some languages include lower case
letters in an upper case range (and vice versa).
paul@RHELv4u4:~/test$ ls [A-Z]ile?
file1 file2 file3 File4
paul@RHELv4u4:~/test$ ls [a-z]ile?
file1 file2 file3 File4
paul@RHELv4u4:~/test$ echo $LANG
en_US.UTF-8
paul@RHELv4u4:~/test$ LANG=C
paul@RHELv4u4:~/test$ echo $LANG
C
paul@RHELv4u4:~/test$ ls [a-z]ile?
file1 file2 file3
paul@RHELv4u4:~/test$ ls [A-Z]ile?
File4
paul@RHELv4u4:~/test$
If $LC_ALL is set, then this will also need to be reset to prevent file globbing.
164file globbing
17.6. preventing file globbing
The screenshot below should be no surprise. The echo * will echo a * when in an empty
directory. And it will echo the names of all files when the directory is not empty.
paul@ubu1010:~$ mkdir test42
paul@ubu1010:~$ cd test42
paul@ubu1010:~/test42$ echo *
*
paul@ubu1010:~/test42$ touch file42 file33
paul@ubu1010:~/test42$ echo *
file33 file42
Globbing can be prevented using quotes or by escaping the special characters, as shown in
this screenshot.
paul@ubu1010:~/test42$
file33 file42
paul@ubu1010:~/test42$
*
paul@ubu1010:~/test42$
*
paul@ubu1010:~/test42$
*
echo *
echo \*
echo '*'
echo "*"
165file globbing
17.7. practice: shell globbing
1. Create a test directory and enter it.
2. Create the following files :
file1
file10
file11
file2
File2
File3
file33
fileAB
filea
fileA
fileAAA
file(
file 2
(the last one has 6 characters including a space)
3. List (with ls) all files starting with file
4. List (with ls) all files starting with File
5. List (with ls) all files starting with file and ending in a number.
6. List (with ls) all files starting with file and ending with a letter
7. List (with ls) all files starting with File and having a digit as fifth character.
8. List (with ls) all files starting with File and having a digit as fifth character and nothing
else.
9. List (with ls) all files starting with a letter and ending in a number.
10. List (with ls) all files that have exactly five characters.
11. List (with ls) all files that start with f or F and end with 3 or A.
12. List (with ls) all files that start with f have i or R as second character and end in a number.
13. List all files that do not start with the letter F.
14. Copy the value of $LANG to $MyLANG.
15. Show the influence of $LANG in listing A-Z or a-z ranges.
16. You receive information that one of your servers was cracked, the cracker probably
replaced the ls command. You know that the echo command is safe to use. Can echo replace
ls ? How can you list the files in the current directory with echo ?
17. Is there another command besides cd to change directories ?
166file globbing
17.8. solution: shell globbing
1. Create a test directory and enter it.
mkdir testdir; cd testdir
2. Create the following files :
file1
file10
file11
file2
File2
File3
file33
fileAB
filea
fileA
fileAAA
file(
file 2
(the last one has 6 characters including a space)
touch
touch
touch
touch
file1 file10 file11 file2 File2 File3
file33 fileAB filea fileA fileAAA
"file("
"file 2"
3. List (with ls) all files starting with file
ls file*
4. List (with ls) all files starting with File
ls File*
5. List (with ls) all files starting with file and ending in a number.
ls file*[0-9]
6. List (with ls) all files starting with file and ending with a letter
ls file*[a-z]
7. List (with ls) all files starting with File and having a digit as fifth character.
ls File[0-9]*
8. List (with ls) all files starting with File and having a digit as fifth character and nothing
else.
ls File[0-9]
9. List (with ls) all files starting with a letter and ending in a number.
ls [a-z]*[0-9]
10. List (with ls) all files that have exactly five characters.
167file globbing
ls ?????
11. List (with ls) all files that start with f or F and end with 3 or A.
ls [fF]*[3A]
12. List (with ls) all files that start with f have i or R as second character and end in a number.
ls f[iR]*[0-9]
13. List all files that do not start with the letter F.
ls [!F]*
14. Copy the value of $LANG to $MyLANG.
MyLANG=$LANG
15. Show the influence of $LANG in listing A-Z or a-z ranges.
see example in book
16. You receive information that one of your servers was cracked, the cracker probably
replaced the ls command. You know that the echo command is safe to use. Can echo replace
ls ? How can you list the files in the current directory with echo ?
echo *
17. Is there another command besides cd to change directories ?
pushd popd
168Part V. pipes and commandsTable of Contents
18. I/O redirection 171
18.1. stdin, stdout, and stderr 172
18.2. output redirection . 173
18.3. error redirection. 175
18.4. output redirection and pipes ..176
18.5. joining stdout and stderr .. 176
18.6. input redirection .177
18.7. confusing redirection .178
18.8. quick file clear .178
18.9. practice: input/output redirection .179
18.10. solution: input/output redirection 180
19. filters .81
19.1. cat .182
19.2. tee ?182
19.3. grep .182
19.4. cut
19.6. wc185
19.7. sort .186
19.8. uniq 187
19.9. comm .188
19.10. od"189
19.11. sed .190
19.12. pipe examples;191
19.13. practice: filters. 192
19.14. solution: filters ..193
20. basic Unix tools .195
20.1. find. 196
20.2. locate ..197
20.3. date .197
20.4. cal .198
20.5. sleep . 198
20.6. time199
20.7. gzip - gunzip .200
20.8. zcat - zmore . 200
20.9. bzip2 - bunzip2 . 201
20.10. bzcat - bzmore201
20.11. practice: basic Unix tools .202
20.12. solution: basic Unix tools 203
21. regular expressions 205
21.1. regex versions: 206
21.2. grep. 207
21.3. rename .212
21.4. sed . 215
21.5. bash history .219
170Chapter 18. I/O redirection
One of the powers of the Unix command line is the use of input/output redirection and
pipes.
This chapter explains redirection of input, output and error streams.
171I/O redirection
18.1. stdin, stdout, and stderr
The bash shell has three basic streams; it takes input from stdin (stream 0), it sends output
to stdout (stream 1) and it sends error messages to stderr (stream 2) .
The drawing below has a graphical interpretation of these three streams.
st dout (1)
st din (0)
bash
st derr (2)
The keyboard often serves as stdin, whereas stdout and stderr both go to the display. This
can be confusing to new Linux users because there is no obvious way to recognize stdout
from stderr. Experienced users know that separating output from errors can be very useful.
The next sections will explain how to redirect these streams.
172I/O redirection
18.2. output redirection
18.2.1. > stdout
stdout can be redirected with a greater than sign. While scanning the line, the shell will
see the > sign and will clear the file.
The > notation is in fact the abbreviation of 1> (stdout being referred to as stream 1).
[paul@RHELv4u3 ~]$ echo It is cold today!
It is cold today!
[paul@RHELv4u3 ~]$ echo It is cold today! > winter.txt
[paul@RHELv4u3 ~]$ cat winter.txt
It is cold today!
[paul@RHELv4u3 ~]$
Note that the bash shell effectively removes the redirection from the command line before
argument 0 is executed. This means that in the case of this command:
echo hello > greetings.txt
the shell only counts two arguments (echo = argument 0, hello = argument 1). The redirection
is removed before the argument counting takes place.
18.2.2. output file is erased
While scanning the line, the shell will see the > sign and will clear the file! Since this
happens before resolving argument 0, this means that even when the command fails, the
file will have been cleared!
[paul@RHELv4u3 ~]$ cat winter.txt
It is cold today!
[paul@RHELv4u3 ~]$ zcho It is cold today! > winter.txt
-bash: zcho: command not found
[paul@RHELv4u3 ~]$ cat winter.txt
[paul@RHELv4u3 ~]$
173I/O redirection
18.2.3. noclobber
Erasing a file while using > can be prevented by setting the noclobber option.
[paul@RHELv4u3 ~]$
It is cold today!
[paul@RHELv4u3 ~]$
[paul@RHELv4u3 ~]$
-bash: winter.txt:
[paul@RHELv4u3 ~]$
[paul@RHELv4u3 ~]$
cat winter.txt
set -o noclobber
echo It is cold today! > winter.txt
cannot overwrite existing file
set +o noclobber
18.2.4. overruling noclobber
The noclobber can be overruled with >|.
[paul@RHELv4u3 ~]$ set -o noclobber
[paul@RHELv4u3 ~]$ echo It is cold today! > winter.txt
-bash: winter.txt: cannot overwrite existing file
[paul@RHELv4u3 ~]$ echo It is very cold today! >| winter.txt
[paul@RHELv4u3 ~]$ cat winter.txt
It is very cold today!
[paul@RHELv4u3 ~]$
18.2.5. >> append
Use >> to append output to a file.
[paul@RHELv4u3 ~]$ echo It is cold today! > winter.txt
[paul@RHELv4u3 ~]$ cat winter.txt
It is cold today!
[paul@RHELv4u3 ~]$ echo Where is the summer ? >> winter.txt
[paul@RHELv4u3 ~]$ cat winter.txt
It is cold today!
Where is the summer ?
[paul@RHELv4u3 ~]$
174I/O redirection
18.3. error redirection
18.3.1. 2> stderr
Redirecting stderr is done with 2>. This can be very useful to prevent error messages from
cluttering your screen.
The screenshot below shows redirection of stdout to a file, and stderr to /dev/null. Writing
1> is the same as >.
[paul@RHELv4u3 ~]$ find / > allfiles.txt 2> /dev/null
[paul@RHELv4u3 ~]$
18.3.2. 2>&1
To redirect both stdout and stderr to the same file, use 2>&1.
[paul@RHELv4u3 ~]$ find / > allfiles_and_errors.txt 2>&1
[paul@RHELv4u3 ~]$
Note that the order of redirections is significant. For example, the command
ls > dirlist 2>&1
directs both standard output (file descriptor 1) and standard error (file descriptor 2) to the
file dirlist, while the command
ls 2>&1 > dirlist
directs only the standard output to file dirlist, because the standard error made a copy of the
standard output before the standard output was redirected to dirlist.
175I/O redirection
18.4. output redirection and pipes
By default you cannot grep inside stderr when using pipes on the command line, because
only stdout is passed.
paul@debian7:~$ rm file42 file33 file1201 | grep file42
rm: cannot remove %%%file42&*#: No such file or directory
rm: cannot remove ."!file33')&: No such file or directory
rm: cannot remove +(+file1201(+/: No such file or directory
With 2>&1 you can force stderr to go to stdout. This enables the next command in the
pipe to act on both streams.
paul@debian7:~$ rm file42 file33 file1201 2>&1 | grep file42
rm: cannot remove *"'file42-/$: No such file or directory
You cannot use both 1>&2 and 2>&1 to switch stdout and stderr.
paul@debian7:~$ rm file42 file33 file1201 2>&1 1>&2 | grep file42
rm: cannot remove ,!(file42".*: No such file or directory
paul@debian7:~$ echo file42 2>&1 1>&2 | sed 's/file42/FILE42/'
FILE42
You need a third stream to switch stdout and stderr after a pipe symbol.
paul@debian7:~$ echo file42 3>&1 1>&2 2>&3 | sed 's/file42/FILE42/'
file42
paul@debian7:~$ rm file42 3>&1 1>&2 2>&3 | sed 's/file42/FILE42/'
rm: cannot remove %+.FILE42*!(: No such file or directory
18.5. joining stdout and stderr
The &> construction will put both stdout and stderr in one stream (to a file).
paul@debian7:~$ rm file42 &> out_and_err
paul@debian7:~$ cat out_and_err
rm: cannot remove ,&)file42$,*: No such file or directory
paul@debian7:~$ echo file42 &> out_and_err
paul@debian7:~$ cat out_and_err
file42
paul@debian7:~$
176I/O redirection
18.6. input redirection
18.6.1. < stdin
Redirecting stdin is done with < (short for 0<).
[paul@RHEL4b ~]$ cat < text.txt
one
two
[paul@RHEL4b ~]$ tr 'onetw' 'ONEZZ' < text.txt
ONE
ZZO
[paul@RHEL4b ~]$
18.6.2. << here document
The here document (sometimes called here-is-document) is a way to append input until a
certain sequence (usually EOF) is encountered. The EOF marker can be typed literally or
can be called with Ctrl-D.
[paul@RHEL4b
> one
> two
> EOF
[paul@RHEL4b
one
two
[paul@RHEL4b
> brel
> brol
[paul@RHEL4b
brel
[paul@RHEL4b
~]$ cat <<EOF > text.txt
~]$ cat text.txt
~]$ cat <<brol > text.txt
~]$ cat text.txt
~]$
18.6.3. <<< here string
The here string can be used to directly pass strings to a command. The result is the same
as using echo string | command (but you have one less process running).
paul@ubu1110~$ base64 <<< linux-training.be
bGludXgtdHJhaW5pbmcuYmUK
paul@ubu1110~$ base64 -d <<< bGludXgtdHJhaW5pbmcuYmUK
linux-training.be
See rfc 3548 for more information about base64.
177I/O redirection
18.7. confusing redirection
The shell will scan the whole line before applying redirection. The following command line
is very readable and is correct.
cat winter.txt > snow.txt 2> errors.txt
But this one is also correct, but less readable.
2> errors.txt cat winter.txt > snow.txt
Even this will be understood perfectly by the shell.
< winter.txt > snow.txt 2> errors.txt cat
18.8. quick file clear
So what is the quickest way to clear a file ?
>foo
And what is the quickest way to clear a file when the noclobber option is set ?
>|bar
178I/O redirection
18.9. practice: input/output redirection
1. Activate the noclobber shell option.
2. Verify that noclobber is active by repeating an ls on /etc/ with redirected output to a file.
3. When listing all shell options, which character represents the noclobber option ?
4. Deactivate the noclobber option.
5. Make sure you have two shells open on the same computer. Create an empty tailing.txt
file. Then type tail -f tailing.txt. Use the second shell to append a line of text to that file.
Verify that the first shell displays this line.
6. Create a file that contains the names of five people. Use cat and output redirection to
create the file and use a here document to end the input.
179I/O redirection
18.10. solution: input/output redirection
1. Activate the noclobber shell option.
set -o noclobber
set -C
2. Verify that noclobber is active by repeating an ls on /etc/ with redirected output to a file.
ls /etc > etc.txt
ls /etc > etc.txt (should not work)
4. When listing all shell options, which character represents the noclobber option ?
echo $- (noclobber is visible as C)
5. Deactivate the noclobber option.
set +o noclobber
6. Make sure you have two shells open on the same computer. Create an empty tailing.txt
file. Then type tail -f tailing.txt. Use the second shell to append a line of text to that file.
Verify that the first shell displays this line.
paul@deb503:~$ > tailing.txt
paul@deb503:~$ tail -f tailing.txt
hello
world
in the other shell:
paul@deb503:~$ echo hello >> tailing.txt
paul@deb503:~$ echo world >> tailing.txt
7. Create a file that contains the names of five people. Use cat and output redirection to
create the file and use a here document to end the input.
paul@deb503:~$ cat > tennis.txt << ace
> Justine Henin
> Venus Williams
> Serena Williams
> Martina Hingis
> Kim Clijsters
> ace
paul@deb503:~$ cat tennis.txt
Justine Henin
Venus Williams
Serena Williams
Martina Hingis
Kim Clijsters
paul@deb503:~$
180Chapter 19. filters
Commands that are created to be used with a pipe are often called filters. These filters
are very small programs that do one specific thing very efficiently. They can be used as
building blocks.
This chapter will introduce you to the most common filters. The combination of simple
commands and filters in a long pipe allows you to design elegant solutions.
181filters
19.1. cat
When between two pipes, the cat command does nothing (except putting stdin on stdout).
[paul@RHEL4b pipes]$ tac count.txt | cat | cat | cat | cat | cat
five
four
three
two
one
[paul@RHEL4b pipes]$
19.2. tee
Writing long pipes in Unix is fun, but sometimes you may want intermediate results. This
is were tee comes in handy. The tee filter puts stdin on stdout and also into a file. So tee is
almost the same as cat, except that it has two identical outputs.
[paul@RHEL4b pipes]$ tac count.txt | tee temp.txt | tac
one
two
three
four
five
[paul@RHEL4b pipes]$ cat temp.txt
five
four
three
two
one
[paul@RHEL4b pipes]$
19.3. grep
The grep filter is famous among Unix users. The most common use of grep is to filter lines
of text containing (or not containing) a certain string.
[paul@RHEL4b pipes]$ cat tennis.txt
Amelie Mauresmo, Fra
Kim Clijsters, BEL
Justine Henin, Bel
Serena Williams, usa
Venus Williams, USA
[paul@RHEL4b pipes]$ cat tennis.txt | grep Williams
Serena Williams, usa
Venus Williams, USA
You can write this without the cat.
[paul@RHEL4b pipes]$ grep Williams tennis.txt
Serena Williams, usa
Venus Williams, USA
One of the most useful options of grep is grep -i which filters in a case insensitive way.
[paul@RHEL4b pipes]$ grep Bel tennis.txt
Justine Henin, Bel
[paul@RHEL4b pipes]$ grep -i Bel tennis.txt
182filters
Kim Clijsters, BEL
Justine Henin, Bel
[paul@RHEL4b pipes]$
Another very useful option is grep -v which outputs lines not matching the string.
[paul@RHEL4b pipes]$ grep -v Fra tennis.txt
Kim Clijsters, BEL
Justine Henin, Bel
Serena Williams, usa
Venus Williams, USA
[paul@RHEL4b pipes]$
And of course, both options can be combined to filter all lines not containing a case
insensitive string.
[paul@RHEL4b pipes]$ grep -vi usa tennis.txt
Amelie Mauresmo, Fra
Kim Clijsters, BEL
Justine Henin, Bel
[paul@RHEL4b pipes]$
With grep -A1 one line after the result is also displayed.
paul@debian5:~/pipes$ grep -A1 Henin tennis.txt
Justine Henin, Bel
Serena Williams, usa
With grep -B1 one line before the result is also displayed.
paul@debian5:~/pipes$ grep -B1 Henin tennis.txt
Kim Clijsters, BEL
Justine Henin, Bel
With grep -C1 (context) one line before and one after are also displayed. All three options
(A,B, and C) can display any number of lines (using e.g. A2, B4 or C20).
paul@debian5:~/pipes$ grep -C1 Henin tennis.txt
Kim Clijsters, BEL
Justine Henin, Bel
Serena Williams, usa
183filters
19.4. cut
The cut filter can select columns from files, depending on a delimiter or a count of bytes.
The screenshot below uses cut to filter for the username and userid in the /etc/passwd file.
It uses the colon as a delimiter, and selects fields 1 and 3.
[[paul@RHEL4b pipes]$ cut -d: -f1,3 /etc/passwd | tail -4
Figo:510
Pfaff:511
Harry:516
Hermione:517
[paul@RHEL4b pipes]$
When using a space as the delimiter for cut, you have to quote the space.
[paul@RHEL4b pipes]$ cut -d" " -f1 tennis.txt
Amelie
Kim
Justine
Serena
Venus
[paul@RHEL4b pipes]$
This example uses cut to display the second to the seventh character of /etc/passwd.
[paul@RHEL4b pipes]$ cut -c2-7 /etc/passwd | tail -4
igo:x:
faff:x
arry:x
ermion
[paul@RHEL4b pipes]$
19.5. tr
You can translate characters with tr. The screenshot shows the translation of all occurrences
of e to E.
[paul@RHEL4b pipes]$ cat tennis.txt | tr 'e' 'E'
AmEliE MaurEsmo, Fra
Kim ClijstErs, BEL
JustinE HEnin, BEl
SErEna Williams, usa
VEnus Williams, USA
Here we set all letters to uppercase by defining two ranges.
[paul@RHEL4b pipes]$ cat tennis.txt | tr 'a-z' 'A-Z'
AMELIE MAURESMO, FRA
KIM CLIJSTERS, BEL
JUSTINE HENIN, BEL
SERENA WILLIAMS, USA
VENUS WILLIAMS, USA
[paul@RHEL4b pipes]$
Here we translate all newlines to spaces.
[paul@RHEL4b pipes]$ cat count.txt
one
two
184filters
three
four
five
[paul@RHEL4b pipes]$ cat count.txt | tr '\n' ' '
one two three four five [paul@RHEL4b pipes]$
The tr -s filter can also be used to squeeze multiple occurrences of a character to one.
[paul@RHEL4b pipes]$ cat spaces.txt
one
two
three
four
five six
[paul@RHEL4b pipes]$ cat spaces.txt | tr -s ' '
one two three
four five six
[paul@RHEL4b pipes]$
You can also use tr to 'encrypt' texts with rot13.
[paul@RHEL4b pipes]$ cat count.txt | tr 'a-z' 'nopqrstuvwxyzabcdefghijklm'
bar
gjb
guerr
sbhe
svir
[paul@RHEL4b pipes]$ cat count.txt | tr 'a-z' 'n-za-m'
bar
gjb
guerr
sbhe
svir
[paul@RHEL4b pipes]$
This last example uses tr -d to delete characters.
paul@debian5:~/pipes$ cat tennis.txt | tr -d e
Amli Maursmo, Fra
Kim Clijstrs, BEL
Justin Hnin, Bl
Srna Williams, usa
Vnus Williams, USA
19.6. wc
Counting words, lines and characters is easy with wc.
[paul@RHEL4b pipes]$ wc
5 15 100 tennis.txt
[paul@RHEL4b pipes]$ wc
5 tennis.txt
[paul@RHEL4b pipes]$ wc
15 tennis.txt
[paul@RHEL4b pipes]$ wc
100 tennis.txt
[paul@RHEL4b pipes]$
tennis.txt
-l tennis.txt
-w tennis.txt
-c tennis.txt
185filters
19.7. sort
The sort filter will default to an alphabetical sort.
paul@debian5:~/pipes$ cat music.txt
Queen
Brel
Led Zeppelin
Abba
paul@debian5:~/pipes$ sort music.txt
Abba
Brel
Led Zeppelin
Queen
But the sort filter has many options to tweak its usage. This example shows sorting different
columns (column 1 or column 2).
[paul@RHEL4b pipes]$ sort -k1 country.txt
Belgium, Brussels, 10
France, Paris, 60
Germany, Berlin, 100
Iran, Teheran, 70
Italy, Rome, 50
[paul@RHEL4b pipes]$ sort -k2 country.txt
Germany, Berlin, 100
Belgium, Brussels, 10
France, Paris, 60
Italy, Rome, 50
Iran, Teheran, 70
The screenshot below shows the difference between an alphabetical sort and a numerical
sort (both on the third column).
[paul@RHEL4b pipes]$ sort -k3 country.txt
Belgium, Brussels, 10
Germany, Berlin, 100
Italy, Rome, 50
France, Paris, 60
Iran, Teheran, 70
[paul@RHEL4b pipes]$ sort -n -k3 country.txt
Belgium, Brussels, 10
Italy, Rome, 50
France, Paris, 60
Iran, Teheran, 70
Germany, Berlin, 100
186filters
19.8. uniq
With uniq you can remove duplicates from a sorted list.
paul@debian5:~/pipes$ cat music.txt
Queen
Brel
Queen
Abba
paul@debian5:~/pipes$ sort music.txt
Abba
Brel
Queen
Queen
paul@debian5:~/pipes$ sort music.txt |uniq
Abba
Brel
Queen
uniq can also count occurrences with the -c option.
paul@debian5:~/pipes$ sort music.txt |uniq -c
1 Abba
1 Brel
2 Queen
187filters
19.9. comm
Comparing streams (or files) can be done with the comm. By default comm will output
three columns. In this example, Abba, Cure and Queen are in both lists, Bowie and Sweet
are only in the first file, Turner is only in the second.
paul@debian5:~/pipes$ cat > list1.txt
Abba
Bowie
Cure
Queen
Sweet
paul@debian5:~/pipes$ cat > list2.txt
Abba
Cure
Queen
Turner
paul@debian5:~/pipes$ comm list1.txt list2.txt
Abba
Bowie
Cure
Queen
Sweet
Turner
The output of comm can be easier to read when outputting only a single column. The digits
point out which output columns should not be displayed.
paul@debian5:~/pipes$ comm -12 list1.txt list2.txt
Abba
Cure
Queen
paul@debian5:~/pipes$ comm -13 list1.txt list2.txt
Turner
paul@debian5:~/pipes$ comm -23 list1.txt list2.txt
Bowie
Sweet
188filters
19.10. od
European humans like to work with ascii characters, but computers store files in bytes. The
example below creates a simple file, and then uses od to show the contents of the file in
hexadecimal bytes
paul@laika:~/test$ cat > text.txt
abcdefg
1234567
paul@laika:~/test$ od -t x1 text.txt
0000000 61 62 63 64 65 66 67 0a 31 32 33 34 35 36 37 0a
0000020
The same file can also be displayed in octal bytes.
paul@laika:~/test$ od -b text.txt
0000000 141 142 143 144 145 146 147 012 061 062 063 064 065 066 067 012
0000020
And here is the file in ascii (or backslashed) characters.
paul@laika:~/test$ od -c text.txt
0000000
a
b
c
d
e
f
g
0000020
\n
189
1
2
3
4
5
6
7
\nfilters
19.11. sed
The stream editor sed can perform editing functions in the stream, using regular
expressions.
paul@debian5:~/pipes$ echo level5 | sed 's/5/42/'
level42
paul@debian5:~/pipes$ echo level5 | sed 's/level/jump/'
jump5
Add g for global replacements (all occurrences of the string per line).
paul@debian5:~/pipes$ echo level5 level7 | sed 's/level/jump/'
jump5 level7
paul@debian5:~/pipes$ echo level5 level7 | sed 's/level/jump/g'
jump5 jump7
With d you can remove lines from a stream containing a character.
paul@debian5:~/test42$ cat tennis.txt
Venus Williams, USA
Martina Hingis, SUI
Justine Henin, BE
Serena williams, USA
Kim Clijsters, BE
Yanina Wickmayer, BE
paul@debian5:~/test42$ cat tennis.txt | sed '/BE/d'
Venus Williams, USA
Martina Hingis, SUI
Serena williams, USA
190filters
19.12. pipe examples
19.12.1. who | wc
How many users are logged on to this system ?
[paul@RHEL4b pipes]$ who
root
tty1
Jul 25 10:50
paul
pts/0
Jul 25 09:29 (laika)
Harry
pts/1
Jul 25 12:26 (barry)
paul
pts/2
Jul 25 12:26 (pasha)
[paul@RHEL4b pipes]$ who | wc -l
4
19.12.2. who | cut | sort
Display a sorted list of logged on users.
[paul@RHEL4b pipes]$ who | cut -d' ' -f1 | sort
Harry
paul
paul
root
Display a sorted list of logged on users, but every user only once .
[paul@RHEL4b pipes]$ who | cut -d' ' -f1 | sort | uniq
Harry
paul
root
19.12.3. grep | cut
Display a list of all bash user accounts on this computer. Users accounts are explained in
detail later.
paul@debian5:~$ grep bash /etc/passwd
root:x:0:0:root:/root:/bin/bash
paul:x:1000:1000:paul,,,:/home/paul:/bin/bash
serena:x:1001:1001::/home/serena:/bin/bash
paul@debian5:~$ grep bash /etc/passwd | cut -d: -f1
root
paul
serena
191filters
19.13. practice: filters
1. Put a sorted list of all bash users in bashusers.txt.
2. Put a sorted list of all logged on users in onlineusers.txt.
3. Make a list of all filenames in /etc that contain the string conf in their filename.
4. Make a sorted list of all files in /etc that contain the case insensitive string conf in their
filename.
5. Look at the output of /sbin/ifconfig. Write a line that displays only ip address and the
subnet mask.
6. Write a line that removes all non-letters from a stream.
7. Write a line that receives a text file, and outputs all words on a separate line.
8. Write a spell checker on the command line. (There may be a dictionary in /usr/share/
dict/ .)
192filters
19.14. solution: filters
1. Put a sorted list of all bash users in bashusers.txt.
grep bash /etc/passwd | cut -d: -f1 | sort > bashusers.txt
2. Put a sorted list of all logged on users in onlineusers.txt.
who | cut -d' ' -f1 | sort > onlineusers.txt
3. Make a list of all filenames in /etc that contain the string conf in their filename.
ls /etc | grep conf
4. Make a sorted list of all files in /etc that contain the case insensitive string conf in their
filename.
ls /etc | grep -i conf | sort
5. Look at the output of /sbin/ifconfig. Write a line that displays only ip address and the
subnet mask.
/sbin/ifconfig | head -2 | grep 'inet ' | tr -s ' ' | cut -d' ' -f3,5
6. Write a line that removes all non-letters from a stream.
paul@deb503:~$ cat text
This is, yes really! , a text with ?&* too many str$ange# characters ;-)
paul@deb503:~$ cat text | tr -d ',!$?.*&^%#@;()-'
This is yes really a text with too many strange characters
7. Write a line that receives a text file, and outputs all words on a separate line.
paul@deb503:~$ cat text2
it is very cold today without the sun
paul@deb503:~$ cat text2 | tr ' ' '\n'
it
is
very
cold
today
without
the
sun
8. Write a spell checker on the command line. (There may be a dictionary in /usr/share/
dict/ .)
paul@rhel ~$ echo "The zun is shining today" > text
paul@rhel ~$ cat > DICT
is
shining
sun
the
193filters
today
paul@rhel ~$ cat text | tr 'A-Z ' 'a-z\n' | sort | uniq | comm -23 - DICT
zun
You could also add the solution from question number 6 to remove non-letters, and tr -s '
' to remove redundant spaces.
194Chapter 20. basic Unix tools
This chapter introduces commands to find or locate files and to compress files, together
with other common tools that were not discussed before. While the tools discussed here are
technically not considered filters, they can be used in pipes.
195basic Unix tools
20.1. find
The find command can be very useful at the start of a pipe to search for files. Here are some
examples. You might want to add 2>/dev/null to the command lines to avoid cluttering your
screen with error messages.
Find all files in /etc and put the list in etcfiles.txt
find /etc > etcfiles.txt
Find all files of the entire system and put the list in allfiles.txt
find / > allfiles.txt
Find files that end in .conf in the current directory (and all subdirs).
find . -name "*.conf"
Find files of type file (not directory, pipe or etc.) that end in .conf.
find . -type f -name "*.conf"
Find files of type directory that end in .bak .
find /data -type d -name "*.bak"
Find files that are newer than file42.txt
find . -newer file42.txt
Find can also execute another command on every file found. This example will look for
*.odf files and copy them to /backup/.
find /data -name "*.odf" -exec cp {} /backup/ \;
Find can also execute, after your confirmation, another command on every file found. This
example will remove *.odf files if you approve of it for every file found.
find /data -name "*.odf" -ok rm {} \;
196basic Unix tools
20.2. locate
The locate tool is very different from find in that it uses an index to locate files. This is a
lot faster than traversing all the directories, but it also means that it is always outdated. If
the index does not exist yet, then you have to create it (as root on Red Hat Enterprise Linux)
with the updatedb command.
[paul@RHEL4b ~]$ locate Samba
warning: locate: could not open database: /var/lib/slocate/slocate.db:...
warning: You need to run the 'updatedb' command (as root) to create th...
Please have a look at /etc/updatedb.conf to enable the daily cron job.
[paul@RHEL4b ~]$ updatedb
fatal error: updatedb: You are not authorized to create a default sloc...
[paul@RHEL4b ~]$ su -
Password:
[root@RHEL4b ~]# updatedb
[root@RHEL4b ~]#
Most Linux distributions will schedule the updatedb to run once every day.
20.3. date
The date command can display the date, time, time zone and more.
paul@rhel55 ~$ date
Sat Apr 17 12:44:30 CEST 2010
A date string can be customised to display the format of your choice. Check the man page
for more options.
paul@rhel55 ~$ date +'%A %d-%m-%Y'
Saturday 17-04-2010
Time on any Unix is calculated in number of seconds since 1969 (the first second being the
first second of the first of January 1970). Use date +%s to display Unix time in seconds.
paul@rhel55 ~$ date +%s
1271501080
When will this seconds counter reach two thousand million ?
paul@rhel55 ~$ date -d '1970-01-01 + 2000000000 seconds'
Wed May 18 04:33:20 CEST 2033
197basic Unix tools
20.4. cal
The cal command displays the current month, with the current day highlighted.
paul@rhel55 ~$ cal
April 2010
Su Mo Tu We Th Fr Sa
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30
You can select any month in the past or the future.
paul@rhel55
February
Su Mo Tu We
1 2 3 4
8 9 10 11
15 16 17 18
22 23 24 25
~$ cal 2 1970
1970
Th Fr Sa
5 6 7
12 13 14
19 20 21
26 27 28
20.5. sleep
The sleep command is sometimes used in scripts to wait a number of seconds. This example
shows a five second sleep.
paul@rhel55 ~$ sleep 5
paul@rhel55 ~$
198basic Unix tools
20.6. time
The time command can display how long it takes to execute a command. The date command
takes only a little time.
paul@rhel55 ~$ time date
Sat Apr 17 13:08:27 CEST 2010
real
user
sys
0m0.014s
0m0.008s
0m0.006s
The sleep 5 command takes five real seconds to execute, but consumes little cpu time.
paul@rhel55 ~$ time sleep 5
real
user
sys
0m5.018s
0m0.005s
0m0.011s
This bzip2 command compresses a file and uses a lot of cpu time.
paul@rhel55 ~$ time bzip2 text.txt
real
user
sys
0m2.368s
0m0.847s
0m0.539s
199basic Unix tools
20.7. gzip - gunzip
Users never have enough disk space, so compression comes in handy. The gzip command
can make files take up less space.
paul@rhel55 ~$ ls -lh text.txt
-rw-rw-r-- 1 paul paul 6.4M Apr 17 13:11 text.txt
paul@rhel55 ~$ gzip text.txt
paul@rhel55 ~$ ls -lh text.txt.gz
-rw-rw-r-- 1 paul paul 760K Apr 17 13:11 text.txt.gz
You can get the original back with gunzip.
paul@rhel55 ~$ gunzip text.txt.gz
paul@rhel55 ~$ ls -lh text.txt
-rw-rw-r-- 1 paul paul 6.4M Apr 17 13:11 text.txt
20.8. zcat - zmore
Text files that are compressed with gzip can be viewed with zcat and zmore.
paul@rhel55 ~$ head -4 text.txt
/
/opt
/opt/VBoxGuestAdditions-3.1.6
/opt/VBoxGuestAdditions-3.1.6/routines.sh
paul@rhel55 ~$ gzip text.txt
paul@rhel55 ~$ zcat text.txt.gz | head -4
/
/opt
/opt/VBoxGuestAdditions-3.1.6
/opt/VBoxGuestAdditions-3.1.6/routines.sh
200basic Unix tools
20.9. bzip2 - bunzip2
Files can also be compressed with bzip2 which takes a little more time than gzip, but
compresses better.
paul@rhel55 ~$ bzip2 text.txt
paul@rhel55 ~$ ls -lh text.txt.bz2
-rw-rw-r-- 1 paul paul 569K Apr 17 13:11 text.txt.bz2
Files can be uncompressed again with bunzip2.
paul@rhel55 ~$ bunzip2 text.txt.bz2
paul@rhel55 ~$ ls -lh text.txt
-rw-rw-r-- 1 paul paul 6.4M Apr 17 13:11 text.txt
20.10. bzcat - bzmore
And in the same way bzcat and bzmore can display files compressed with bzip2.
paul@rhel55 ~$ bzip2 text.txt
paul@rhel55 ~$ bzcat text.txt.bz2 | head -4
/
/opt
/opt/VBoxGuestAdditions-3.1.6
/opt/VBoxGuestAdditions-3.1.6/routines.sh
201basic Unix tools
20.11. practice: basic Unix tools
1. Explain the difference between these two commands. This question is very important. If
you don't know the answer, then look back at the shell chapter.
find /data -name "*.txt"
find /data -name *.txt
2. Explain the difference between these two statements. Will they both work when there are
200 .odf files in /data ? How about when there are 2 million .odf files ?
find /data -name "*.odf" > data_odf.txt
find /data/*.odf > data_odf.txt
3. Write a find command that finds all files created after January 30th 2010.
4. Write a find command that finds all *.odf files created in September 2009.
5. Count the number of *.conf files in /etc and all its subdirs.
6. Here are two commands that do the same thing: copy *.odf files to /backup/ . What would
be a reason to replace the first command with the second ? Again, this is an important
question.
cp -r /data/*.odf /backup/
find /data -name "*.odf" -exec cp {} /backup/ \;
7. Create a file called loctest.txt. Can you find this file with locate ? Why not ? How do
you make locate find this file ?
8. Use find and -exec to rename all .htm files to .html.
9. Issue the date command. Now display the date in YYYY/MM/DD format.
10. Issue the cal command. Display a calendar of 1582 and 1752. Notice anything special ?
202basic Unix tools
20.12. solution: basic Unix tools
1. Explain the difference between these two commands. This question is very important. If
you don't know the answer, then look back at the shell chapter.
find /data -name "*.txt"
find /data -name *.txt
When *.txt is quoted then the shell will not touch it. The find tool will look in the /data
for all files ending in .txt.
When *.txt is not quoted then the shell might expand this (when one or more files that ends
in .txt exist in the current directory). The find might show a different result, or can result
in a syntax error.
2. Explain the difference between these two statements. Will they both work when there are
200 .odf files in /data ? How about when there are 2 million .odf files ?
find /data -name "*.odf" > data_odf.txt
find /data/*.odf > data_odf.txt
The first find will output all .odf filenames in /data and all subdirectories. The shell will
redirect this to a file.
The second find will output all files named .odf in /data and will also output all files that
exist in directories named *.odf (in /data).
With two million files the command line would be expanded beyond the maximum that the
shell can accept. The last part of the command line would be lost.
3. Write a find command that finds all files created after January 30th 2010.
touch -t 201001302359 marker_date
find . -type f -newer marker_date
There is another solution :
find . -type f -newerat "20100130 23:59:59"
4. Write a find command that finds all *.odf files created in September 2009.
touch -t 200908312359 marker_start
touch -t 200910010000 marker_end
find . -type f -name "*.odf" -newer marker_start ! -newer marker_end
The exclamation mark ! -newer can be read as not newer.
5. Count the number of *.conf files in /etc and all its subdirs.
find /etc -type f -name '*.conf' | wc -l
6. Here are two commands that do the same thing: copy *.odf files to /backup/ . What would
be a reason to replace the first command with the second ? Again, this is an important
question.
cp -r /data/*.odf /backup/
203basic Unix tools
find /data -name "*.odf" -exec cp {} /backup/ \;
The first might fail when there are too many files to fit on one command line.
7. Create a file called loctest.txt. Can you find this file with locate ? Why not ? How do
you make locate find this file ?
You cannot locate this with locate because it is not yet in the index.
updatedb
8. Use find and -exec to rename all .htm files to .html.
paul@rhel55 ~$ find . -name '*.htm'
./one.htm
./two.htm
paul@rhel55 ~$ find . -name '*.htm' -exec mv {} {}l \;
paul@rhel55 ~$ find . -name '*.htm*'
./one.html
./two.html
9. Issue the date command. Now display the date in YYYY/MM/DD format.
date +%Y/%m/%d
10. Issue the cal command. Display a calendar of 1582 and 1752. Notice anything special ?
cal 1582
The calendars are different depending on the country. Check http://linux-training.be/files/
studentfiles/dates.txt
204Chapter 21. regular expressions
Regular expressions are a very powerful tool in Linux. They can be used with a variety of
programs like bash, vi, rename, grep, sed, and more.
This chapter introduces you to the basics of regular expressions.
205regular expressions
21.1. regex versions
There are three different versions of regular expression syntax:
BRE: Basic Regular Expressions
ERE: Extended Regular Expressions
PRCE: Perl Regular Expressions
Depending on the tool being used, one or more of these syntaxes can be used.
For example the grep tool has the -E option to force a string to be read as ERE while -G
forces BRE and -P forces PRCE.
Note that grep also has -F to force the string to be read literally.
The sed tool also has options to choose a regex syntax.
Read the manual of the tools you use!
206regular expressions
21.2. grep
21.2.1. print lines matching a pattern
grep is a popular Linux tool to search for lines that match a certain pattern. Below are some
examples of the simplest regular expressions.
This is the contents of the test file. This file contains three lines (or three newline characters).
paul@rhel65:~$ cat names
Tania
Laura
Valentina
When grepping for a single character, only the lines containing that character are returned.
paul@rhel65:~$ grep u names
Laura
paul@rhel65:~$ grep e names
Valentina
paul@rhel65:~$ grep i names
Tania
Valentina
The pattern matching in this example should be very straightforward; if the given character
occurs on a line, then grep will return that line.
21.2.2. concatenating characters
Two concatenated characters will have to be concatenated in the same way to have a match.
This example demonstrates that ia will match Tania but not Valentina and in will match
Valentina but not Tania.
paul@rhel65:~$ grep a names
Tania
Laura
Valentina
paul@rhel65:~$ grep ia names
Tania
paul@rhel65:~$ grep in names
Valentina
paul@rhel65:~$
207regular expressions
21.2.3. one or the other
PRCE and ERE both use the pipe symbol to signify OR. In this example we grep for lines
containing the letter i or the letter a.
paul@debian7:~$ cat list
Tania
Laura
paul@debian7:~$ grep -E 'i|a' list
Tania
Laura
Note that we use the -E switch of grep to force interpretion of our string as an ERE.
We need to escape the pipe symbol in a BRE to get the same logical OR.
paul@debian7:~$ grep -G 'i|a' list
paul@debian7:~$ grep -G 'i\|a' list
Tania
Laura
21.2.4. one or more
The * signifies zero, one or more occurences of the previous and the + signifies one or more
of the previous.
paul@debian7:~$ cat list2
ll
lol
lool
loool
paul@debian7:~$ grep -E 'o*' list2
ll
lol
lool
loool
paul@debian7:~$ grep -E 'o+' list2
lol
lool
loool
paul@debian7:~$
208regular expressions
21.2.5. match the end of a string
For the following examples, we will use this file.
paul@debian7:~$ cat names
Tania
Laura
Valentina
Fleur
Floor
The two examples below show how to use the dollar character to match the end of a string.
paul@debian7:~$ grep a$ names
Tania
Laura
Valentina
paul@debian7:~$ grep r$ names
Fleur
Floor
21.2.6. match the start of a string
The caret character (^) will match a string at the start (or the beginning) of a line.
Given the same file as above, here are two examples.
paul@debian7:~$ grep ^Val names
Valentina
paul@debian7:~$ grep ^F names
Fleur
Floor
Both the dollar sign and the little hat are called anchors in a regex.
209regular expressions
21.2.7. separating words
Regular expressions use a \b sequence to reference a word separator. Take for example this
file:
paul@debian7:~$ cat text
The governer is governing.
The winter is over.
Can you get over there?
Simply grepping for over will give too many results.
paul@debian7:~$ grep over text
The governer is governing.
The winter is over.
Can you get over there?
Surrounding the searched word with spaces is not a good solution (because other characters
can be word separators). This screenshot below show how to use \b to find only the searched
word:
paul@debian7:~$ grep '\bover\b' text
The winter is over.
Can you get over there?
paul@debian7:~$
Note that grep also has a -w option to grep for words.
paul@debian7:~$ cat text
The governer is governing.
The winter is over.
Can you get over there?
paul@debian7:~$ grep -w over text
The winter is over.
Can you get over there?
paul@debian7:~$
210regular expressions
21.2.8. grep features
Sometimes it is easier to combine a simple regex with grep options, than it is to write a more
complex regex. These options where discussed before:
grep
grep
grep
grep
grep
grep
-i
-v
-w
-A5
-B5
-C5
21.2.9. preventing shell expansion of a regex
The dollar sign is a special character, both for the regex and also for the shell (remember
variables and embedded shells). Therefore it is advised to always quote the regex, this
prevents shell expansion.
paul@debian7:~$ grep 'r$' names
Fleur
Floor
211regular expressions
21.3. rename
21.3.1. the rename command
On Debian Linux the /usr/bin/rename command is a link to /usr/bin/prename installed by
the perl package.
paul@pi ~ $ dpkg -S $(readlink -f $(which rename))
perl: /usr/bin/prename
Red Hat derived systems do not install the same rename command, so this section does not
describe rename on Red Hat (unless you copy the perl script manually).
There is often confusion on the internet about the rename command because solutions
that work fine in Debian (and Ubuntu, xubuntu, Mint, ...) cannot be used in Red Hat
(and CentOS, Fedora, ...).
21.3.2. perl
The rename command is actually a perl script that uses perl regular expressions. The
complete manual for these can be found by typing perldoc perlrequick (after installing
perldoc).
root@pi:~# aptitude install perl-doc
The following NEW packages will be installed:
perl-doc
0 packages upgraded, 1 newly installed, 0 to remove and 0 not upgraded.
Need to get 8,170 kB of archives. After unpacking 13.2 MB will be used.
Get: 1 http://mirrordirector.raspbian.org/raspbian/ wheezy/main perl-do...
Fetched 8,170 kB in 19s (412 kB/s)
Selecting previously unselected package perl-doc.
(Reading database ... 67121 files and directories currently installed.)
Unpacking perl-doc (from .../perl-doc_5.14.2-21+rpi2_all.deb) ...
Adding 'diversion of /usr/bin/perldoc to /usr/bin/perldoc.stub by perl-doc'
Processing triggers for man-db ...
Setting up perl-doc (5.14.2-21+rpi2) ...
root@pi:~# perldoc perlrequick
212regular expressions
21.3.3. well known syntax
The most common use of the rename is to search for filenames matching a certain string
and replacing this string with an other string.
This is often presented as s/string/other string/ as seen in this example:
paul@pi ~
abc
abc.conf
paul@pi ~
paul@pi ~
abc
abc.conf
$ ls
allfiles.TXT bllfiles.TXT Scratch
tennis2.TXT
backup
cllfiles.TXT temp.TXT tennis.TXT
$ rename 's/TXT/text/' *
$ ls
allfiles.text bllfiles.text Scratch
tennis2.text
backup
cllfiles.text temp.text tennis.text
And here is another example that uses rename with the well know syntax to change the
extensions of the same files once more:
paul@pi ~
abc
abc.conf
paul@pi ~
paul@pi ~
abc
abc.conf
paul@pi ~
$ ls
allfiles.text bllfiles.text Scratch
tennis2.text
backup
cllfiles.text temp.text tennis.text
$ rename 's/text/txt/' *.text
$ ls
allfiles.txt bllfiles.txt Scratch
tennis2.txt
backup
cllfiles.txt temp.txt tennis.txt
$
These two examples appear to work because the strings we used only exist at the end of the
filename. Remember that file extensions have no meaning in the bash shell.
The next example shows what can go wrong with this syntax.
paul@pi ~
paul@pi ~
paul@pi ~
abc
abc.conf
paul@pi ~
$ touch atxt.txt
$ rename 's/txt/problem/' atxt.txt
$ ls
allfiles.txt backup
cllfiles.txt
aproblem.txt bllfiles.txt Scratch
$
temp.txt
tennis2.txt
Only the first occurrence of the searched string is replaced.
213
tennis.txtregular expressions
21.3.4. a global replace
The syntax used in the previous example can be described as s/regex/replacement/. This
is simple and straightforward, you enter a regex between the first two slashes and a
replacement string between the last two.
This example expands this syntax only a little, by adding a modifier.
paul@pi ~ $ rename -n 's/TXT/txt/g' aTXT.TXT
aTXT.TXT renamed as atxt.txt
paul@pi ~ $
The syntax we use now can be described as s/regex/replacement/g where s signifies switch
and g stands for global.
Note that this example used the -n switch to show what is being done (instead of actually
renaming the file).
21.3.5. case insensitive replace
Another modifier that can be useful is i. this example shows how to replace a case insensitive
string with another string.
paul@debian7:~/files$ ls
file1.text file2.TEXT file3.txt
paul@debian7:~/files$ rename 's/.text/.txt/i' *
paul@debian7:~/files$ ls
file1.txt file2.txt file3.txt
paul@debian7:~/files$
21.3.6. renaming extensions
Command line Linux has no knowledge of MS-DOS like extensions, but many end users
and graphical application do use them.
Here is an example on how to use rename to only rename the file extension. It uses the
dollar sign to mark the ending of the filename.
paul@pi ~ $ ls *.txt
allfiles.txt bllfiles.txt cllfiles.txt really.txt.txt temp.txt
paul@pi ~ $ rename 's/.txt$/.TXT/' *.txt
paul@pi ~ $ ls *.TXT
allfiles.TXT bllfiles.TXT
cllfiles.TXT
really.txt.TXT
temp.TXT
tennis.TXT
paul@pi ~ $
tennis.txt
Note that the dollar sign in the regex means at the end. Without the dollar sign this
command would fail on the really.txt.txt file.
214regular expressions
21.4. sed
21.4.1. stream editor
The stream editor or short sed uses regex for stream editing.
In this example sed is used to replace a string.
echo Sunday | sed 's/Sun/Mon/'
Monday
The slashes can be replaced by a couple of other characters, which can be handy in some
cases to improve readability.
echo Sunday | sed 's:Sun:Mon:'
Monday
echo Sunday | sed 's_Sun_Mon_'
Monday
echo Sunday | sed 's|Sun|Mon|'
Monday
21.4.2. interactive editor
While sed is meant to be used in a stream, it can also be used interactively on a file.
paul@debian7:~/files$
paul@debian7:~/files$
Sunday
paul@debian7:~/files$
paul@debian7:~/files$
Monday
echo Sunday > today
cat today
sed -i 's/Sun/Mon/' today
cat today
215regular expressions
21.4.3. simple back referencing
The ampersand character can be used to reference the searched (and found) string.
In this example the ampersand is used to double the occurence of the found string.
echo Sunday | sed 's/Sun/&&/'
SunSunday
echo Sunday | sed 's/day/&&/'
Sundayday
21.4.4. back referencing
Parentheses (often called round brackets) are used to group sections of the regex so they
can leter be referenced.
Consider this simple example:
paul@debian7:~$ echo Sunday | sed 's_\(Sun\)_\1ny_'
Sunnyday
paul@debian7:~$ echo Sunday | sed 's_\(Sun\)_\1ny \1_'
Sunny Sunday
21.4.5. a dot for any character
In a regex a simple dot can signify any character.
paul@debian7:~$ echo 2014-04-01 | sed 's/....-..-../YYYY-MM-DD/'
YYYY-MM-DD
paul@debian7:~$ echo abcd-ef-gh | sed 's/....-..-../YYYY-MM-DD/'
YYYY-MM-DD
21.4.6. multiple back referencing
When more than one pair of parentheses is used, each of them can be referenced separately
by consecutive numbers.
paul@debian7:~$ echo 2014-04-01 | sed 's/\(....\)-\(..\)-\(..\)/\1+\2+\3/'
2014+04+01
paul@debian7:~$ echo 2014-04-01 | sed 's/\(....\)-\(..\)-\(..\)/\3:\2:\1/'
01:04:2014
This feature is called grouping.
216regular expressions
21.4.7. white space
The \s can refer to white space such as a space or a tab.
This example looks for white spaces (\s) globally and replaces them with 1 space.
paul@debian7:~$ echo -e 'today\tis\twarm'
today
is
warm
paul@debian7:~$ echo -e 'today\tis\twarm' | sed 's_\s_ _g'
today is warm
21.4.8. optional occurrence
A question mark signifies that the previous is optional.
The example below searches for three consecutive letter o, but the third o is optional.
paul@debian7:~$ cat list2
ll
lol
lool
loool
paul@debian7:~$ grep -E 'ooo?' list2
lool
loool
paul@debian7:~$ cat list2 | sed 's/ooo\?/A/'
ll
lol
lAl
lAl
217regular expressions
21.4.9. exactly n times
You can demand an exact number of times the oprevious has to occur.
This example wants exactly three o's.
paul@debian7:~$ cat list2
ll
lol
lool
loool
paul@debian7:~$ grep -E 'o{3}' list2
loool
paul@debian7:~$ cat list2 | sed 's/o\{3\}/A/'
ll
lol
lool
lAl
paul@debian7:~$
21.4.10. between n and m times
And here we demand exactly from minimum 2 to maximum 3 times.
paul@debian7:~$
ll
lol
lool
loool
paul@debian7:~$
lool
loool
paul@debian7:~$
lool
loool
paul@debian7:~$
ll
lol
lAl
lAl
paul@debian7:~$
cat list2
grep -E 'o{2,3}' list2
grep 'o\{2,3\}' list2
cat list2 | sed 's/o\{2,3\}/A/'
218regular expressions
21.5. bash history
The bash shell can also interprete some regular expressions.
This example shows how to manipulate the exclamation mask history feature of the bash
shell.
paul@debian7:~$ mkdir hist
paul@debian7:~$ cd hist/
paul@debian7:~/hist$ touch file1 file2 file3
paul@debian7:~/hist$ ls -l file1
-rw-r--r-- 1 paul paul 0 Apr 15 22:07 file1
paul@debian7:~/hist$ !l
ls -l file1
-rw-r--r-- 1 paul paul 0 Apr 15 22:07 file1
paul@debian7:~/hist$ !l:s/1/3
ls -l file3
-rw-r--r-- 1 paul paul 0 Apr 15 22:07 file3
paul@debian7:~/hist$
This also works with the history numbers in bash.
paul@debian7:~/hist$ history 6
2089 mkdir hist
2090 cd hist/
2091 touch file1 file2 file3
2092 ls -l file1
2093 ls -l file3
2094 history 6
paul@debian7:~/hist$ !2092
ls -l file1
-rw-r--r-- 1 paul paul 0 Apr 15 22:07 file1
paul@debian7:~/hist$ !2092:s/1/2
ls -l file2
-rw-r--r-- 1 paul paul 0 Apr 15 22:07 file2
paul@debian7:~/hist$
219Part VI. viTable of Contents
221Chapter 22. Introduction to vi
The vi editor is installed on almost every Unix. Linux will very often install vim (vi
improved) which is similar. Every system administrator should know vi(m), because it is
an easy tool to solve problems.
The vi editor is not intuitive, but once you get to know it, vi becomes a very powerful
application. Most Linux distributions will include the vimtutor which is a 45 minute lesson
in vi(m).
222Introduction to vi
22.1. command mode and insert mode
The vi editor starts in command mode. In command mode, you can type commands. Some
commands will bring you into insert mode. In insert mode, you can type text. The escape
key will return you to command mode.
Table 22.1. getting to command mode
key action
Esc set vi(m) in command mode.
22.2. start typing (a A i I o O)
The difference between a A i I o and O is the location where you can start typing. a will
append after the current character and A will append at the end of the line. i will insert before
the current character and I will insert at the beginning of the line. o will put you in a new
line after the current line and O will put you in a new line before the current line.
Table 22.2. switch to insert mode
command
action
a start typing after the current character
A start typing at the end of the current line
i start typing before the current character
I start typing at the start of the current line
o start typing on a new line after the current line
O start typing on a new line before the current line
223Introduction to vi
22.3. replace and delete a character (r x X)
When in command mode (it doesn't hurt to hit the escape key more than once) you can use
the x key to delete the current character. The big X key (or shift x) will delete the character
left of the cursor. Also when in command mode, you can use the r key to replace one single
character. The r key will bring you in insert mode for just one key press, and will return you
immediately to command mode.
Table 22.3. replace and delete
command
action
x delete the character below the cursor
X delete the character before the cursor
r replace the character below the cursor
p paste after the cursor (here the last deleted character)
xp switch two characters
22.4. undo and repeat (u .)
When in command mode, you can undo your mistakes with u. You can do your mistakes
twice with . (in other words, the . will repeat your last command).
Table 22.4. undo and repeat
command
action
u undo the last action
. repeat the last action
22.5. cut, copy and paste a line (dd yy p P)
When in command mode, dd will cut the current line. yy will copy the current line. You can
paste the last copied or cut line after (p) or before (P) the current line.
Table 22.5. cut, copy and paste a line
command
action
dd cut the current line
yy (yank yank) copy the current line
p paste after the current line
P paste before the current line
224Introduction to vi
22.6. cut, copy and paste lines (3dd 2yy)
When in command mode, before typing dd or yy, you can type a number to repeat the
command a number of times. Thus, 5dd will cut 5 lines and 4yy will copy (yank) 4 lines.
That last one will be noted by vi in the bottom left corner as "4 line yanked".
Table 22.6. cut, copy and paste lines
command
action
3dd cut three lines
4yy copy four lines
22.7. start and end of a line (0 or ^ and $)
When in command mode, the 0 and the caret ^ will bring you to the start of the current line,
whereas the $ will put the cursor at the end of the current line. You can add 0 and $ to the d
command, d0 will delete every character between the current character and the start of the
line. Likewise d$ will delete everything from the current character till the end of the line.
Similarly y0 and y$ will yank till start and end of the current line.
Table 22.7. start and end of line
command
action
0 jump to start of current line
^ jump to start of current line
$ jump to end of current line
d0 delete until start of line
d$ delete until end of line
22.8. join two lines (J) and more
When in command mode, pressing J will append the next line to the current line. With yyp
you duplicate a line and with ddp you switch two lines.
Table 22.8. join two lines
command
J
action
join two lines
yyp duplicate a line
ddp switch two lines
225Introduction to vi
22.9. words (w b)
When in command mode, w will jump to the next word and b will move to the previous
word. w and b can also be combined with d and y to copy and cut words (dw db yw yb).
Table 22.9. words
command
action
w forward one word
b back one word
3w forward three words
dw delete one word
yw yank (copy) one word
5yb yank five words back
7dw delete seven words
22.10. save (or not) and exit (:w :q :q! )
Pressing the colon : will allow you to give instructions to vi (technically speaking, typing
the colon will open the ex editor). :w will write (save) the file, :q will quit an unchanged
file without saving, and :q! will quit vi discarding any changes. :wq will save and quit and
is the same as typing ZZ in command mode.
Table 22.10. save and exit vi
command
:w
:w fname
:q
action
save (write)
save as fname
quit
:wq save and quit
ZZ save and quit
:q! quit (discarding your changes)
:w! save (and write to non-writable file!)
The last one is a bit special. With :w! vi will try to chmod the file to get write permission
(this works when you are the owner) and will chmod it back when the write succeeds. This
should always work when you are root (and the file system is writable).
22.11. Searching (/ ?)
When in command mode typing / will allow you to search in vi for strings (can be a regular
expression). Typing /foo will do a forward search for the string foo and typing ?bar will do
a backward search for bar.
Table 22.11. searching
command
/string
action
forward search for string
226Introduction to vi
command
action
?string
backward search for string
n
go to next occurrence of search string
/^string forward search string at beginning of line
/string$ forward search string at end of line
/br[aeio]l
search for bral brel bril and brol
/\<he\>
search for the word he (and not for here or the)
22.12. replace all ( :1,$ s/foo/bar/g )
To replace all occurrences of the string foo with bar, first switch to ex mode with : . Then
tell vi which lines to use, for example 1,$ will do the replace all from the first to the last
line. You can write 1,5 to only process the first five lines. The s/foo/bar/g will replace all
occurrences of foo with bar.
Table 22.12. replace
command
action
:4,8 s/foo/bar/g replace foo with bar on lines 4 to 8
:1,$ s/foo/bar/g replace foo with bar on all lines
22.13. reading files (:r :r !cmd)
When in command mode, :r foo will read the file named foo, :r !foo will execute the
command foo. The result will be put at the current location. Thus :r !ls will put a listing of
the current directory in your text file.
Table 22.13. read files and input
command
action
:r fname (read) file fname and paste contents
:r !cmd execute cmd and paste its output
22.14. text buffers
There are 36 buffers in vi to store text. You can use them with the " character.
Table 22.14. text buffers
command
action
"add delete current line and put text in buffer a
"g7yy copy seven lines into buffer g
"ap
paste from buffer a
22.15. multiple files
You can edit multiple files with vi. Here are some tips.
227Introduction to vi
Table 22.15. multiple files
command
vi file1 file2 file3
:args
action
start editing three files
lists files and marks active file
:n start editing the next file
:e toggle with last edited file
:rew
rewind file pointer to first file
22.16. abbreviations
With :ab you can put abbreviations in vi. Use :una to undo the abbreviation.
Table 22.16. abbreviations
command
:ab str long string
:una str
action
abbreviate str to be 'long string'
un-abbreviate str
228Introduction to vi
22.17. key mappings
Similarly to their abbreviations, you can use mappings with :map for command mode and
:map! for insert mode.
This example shows how to set the F6 function key to toggle between set number and set
nonumber. The <bar> separates the two commands, set number! toggles the state and set
number? reports the current state.
:map <F6> :set number!<bar>set number?<CR>
22.18. setting options
Some options that you can set in vim.
:set number ( also try :se nu )
:set nonumber
:syntax on
:syntax off
:set all (list all options)
:set tabstop=8
:set tx
(CR/LF style endings)
:set notx
You can set these options (and much more) in ~/.vimrc for vim or in ~/.exrc for standard vi.
paul@barry:~$ cat ~/.vimrc
set number
set tabstop=8
set textwidth=78
map <F6> :set number!<bar>set number?<CR>
paul@barry:~$
229Introduction to vi
22.19. practice: vi(m)
1. Start the vimtutor and do some or all of the exercises. You might need to run aptitude
install vim on xubuntu.
2. What 3 key sequence in command mode will duplicate the current line.
3. What 3 key sequence in command mode will switch two lines' place (line five becomes
line six and line six becomes line five).
4. What 2 key sequence in command mode will switch a character's place with the next one.
5. vi can understand macro's. A macro can be recorded with q followed by the name of
the macro. So qa will record the macro named a. Pressing q again will end the recording.
You can recall the macro with @ followed by the name of the macro. Try this example: i 1
'Escape Key' qa yyp 'Ctrl a' q 5@a (Ctrl a will increase the number with one).
6. Copy /etc/passwd to your ~/passwd. Open the last one in vi and press Ctrl v. Use the arrow
keys to select a Visual Block, you can copy this with y or delete it with d. Try pasting it.
7. What does dwwP do when you are at the beginning of a word in a sentence ?
230Introduction to vi
22.20. solution: vi(m)
1. Start the vimtutor and do some or all of the exercises. You might need to run aptitude
install vim on xubuntu.
vimtutor
2. What 3 key sequence in command mode will duplicate the current line.
yyp
3. What 3 key sequence in command mode will switch two lines' place (line five becomes
line six and line six becomes line five).
ddp
4. What 2 key sequence in command mode will switch a character's place with the next one.
xp
5. vi can understand macro's. A macro can be recorded with q followed by the name of
the macro. So qa will record the macro named a. Pressing q again will end the recording.
You can recall the macro with @ followed by the name of the macro. Try this example: i 1
'Escape Key' qa yyp 'Ctrl a' q 5@a (Ctrl a will increase the number with one).
6. Copy /etc/passwd to your ~/passwd. Open the last one in vi and press Ctrl v. Use the arrow
keys to select a Visual Block, you can copy this with y or delete it with d. Try pasting it.
cp /etc/passwd ~
vi passwd
(press Ctrl-V)
7. What does dwwP do when you are at the beginning of a word in a sentence ?
dwwP can switch the current word with the next word.
231Part VII. scriptingTable of Content
233Chapter 23. scripting introduction
Shells like bash and Korn have support for programming constructs that can be saved as
scripts. These scripts in turn then become more shell commands. Many Linux commands
are scripts. User profile scripts are run when a user logs on and init scripts are run when
a daemon is stopped or started.
This means that system administrators also need basic knowledge of scripting to understand
how their servers and their applications are started, updated, upgraded, patched, maintained,
configured and removed, and also to understand how a user environment is built.
The goal of this chapter is to give you enough information to be able to read and understand
scripts. Not to become a writer of complex scripts.
234scripting introduction
23.1. prerequisites
You should have read and understood part III shell expansion and part IV pipes and
commands before starting this chapter.
23.2. hello world
Just like in every programming course, we start with a simple hello_world script. The
following script will output Hello World.
echo Hello World
After creating this simple script in vi or with echo, you'll have to chmod +x hello_world
to make it executable. And unless you add the scripts directory to your path, you'll have to
type the path to the script for the shell to be able to find it.
[paul@RHEL4a
[paul@RHEL4a
[paul@RHEL4a
Hello World
[paul@RHEL4a
~]$ echo echo Hello World > hello_world
~]$ chmod +x hello_world
~]$ ./hello_world
~]$
23.3. she-bang
Let's expand our example a little further by putting #!/bin/bash on the first line of the script.
The #! is called a she-bang (sometimes called sha-bang), where the she-bang is the first
two characters of the script.
#!/bin/bash
echo Hello World
You can never be sure which shell a user is running. A script that works flawlessly in bash
might not work in ksh, csh, or dash. To instruct a shell to run your script in a certain shell,
you can start your script with a she-bang followed by the shell it is supposed to run in. This
script will run in a bash shell.
#!/bin/bash
echo -n hello
echo A bash subshell `echo -n hello`
This script will run in a Korn shell (unless /bin/ksh is a hard link to /bin/bash). The /etc/
shells file contains a list of shells on your system.
#!/bin/ksh
echo -n hello
echo a Korn subshell `echo -n hello`
235scripting introduction
23.4. comment
Let's expand our example a little further by adding comment lines.
#!/bin/bash
#
# Hello World Script
#
echo Hello World
23.5. variables
Here is a simple example of a variable inside a script.
#!/bin/bash
#
# simple variable in script
#
var1=4
echo var1 = $var1
Scripts can contain variables, but since scripts are run in their own shell, the variables do
not survive the end of the script.
[paul@RHEL4a ~]$ echo $var1
[paul@RHEL4a ~]$ ./vars
var1 = 4
[paul@RHEL4a ~]$ echo $var1
[paul@RHEL4a ~]$
23.6. sourcing a script
Luckily, you can force a script to run in the same shell; this is called sourcing a script.
[paul@RHEL4a ~]$ source ./vars
var1 = 4
[paul@RHEL4a ~]$ echo $var1
4
[paul@RHEL4a ~]$
The above is identical to the below.
[paul@RHEL4a ~]$ . ./vars
var1 = 4
[paul@RHEL4a ~]$ echo $var1
4
[paul@RHEL4a ~]$
236scripting introduction
23.7. troubleshooting a script
Another way to run a script in a separate shell is by typing bash with the name of the script
as a parameter.
paul@debian6~/test$ bash runme
42
Expanding this to bash -x allows you to see the commands that the shell is executing (after
shell expansion).
paul@debian6~/test$ bash -x runme
+ var4=42
+ echo 42
42
paul@debian6~/test$ cat runme
# the runme script
var4=42
echo $var4
paul@debian6~/test$
Notice the absence of the commented (#) line, and the replacement of the variable before
execution of echo.
23.8. prevent setuid root spoofing
Some user may try to perform setuid based script root spoofing. This is a rare but possible
attack. To improve script security and to avoid interpreter spoofing, you need to add -- after
the #!/bin/bash, which disables further option processing so the shell will not accept any
options.
#!/bin/bash -
or
#!/bin/bash --
Any arguments after the -- are treated as filenames and arguments. An argument of - is
equivalent to --.
237scripting introduction
23.9. practice: introduction to scripting
0. Give each script a different name, keep them for later!
1. Write a script that outputs the name of a city.
2. Make sure the script runs in the bash shell.
3. Make sure the script runs in the Korn shell.
4. Create a script that defines two variables, and outputs their value.
5. The previous script does not influence your current shell (the variables do not exist outside
of the script). Now run the script so that it influences your current shell.
6. Is there a shorter way to source the script ?
7. Comment your scripts so that you know what they are doing.
238scripting introduction
23.10. solution: introduction to scripting
0. Give each script a different name, keep them for later!
1. Write a script that outputs the name of a city.
$ echo 'echo Antwerp' > first.bash
$ chmod +x first.bash
$ ./first.bash
Antwerp
2. Make sure the script runs in the bash shell.
$ cat first.bash
#!/bin/bash
echo Antwerp
3. Make sure the script runs in the Korn shell.
$ cat first.bash
#!/bin/ksh
echo Antwerp
Note that while first.bash will technically work as a Korn shell script, the name ending
in .bash is confusing.
4. Create a script that defines two variables, and outputs their value.
$ cat second.bash
#!/bin/bash
var33=300
var42=400
echo $var33 $var42
5. The previous script does not influence your current shell (the variables do not exist outside
of the script). Now run the script so that it influences your current shell.
source second.bash
6. Is there a shorter way to source the script ?
. ./second.bash
7. Comment your scripts so that you know what they are doing.
$ cat second.bash
#!/bin/bash
# script to test variables and sourcing
# define two variables
var33=300
var42=400
# output the value of these variables
echo $var33 $var42
239Chapter 24. scripting loops
240scripting loops
24.1. test [ ]
The test command can test whether something is true or false. Let's start by testing whether
10 is greater than 55.
[paul@RHEL4b ~]$ test 10 -gt 55 ; echo $?
1
[paul@RHEL4b ~]$
The test command returns 1 if the test fails. And as you see in the next screenshot, test returns
0 when a test succeeds.
[paul@RHEL4b ~]$ test 56 -gt 55 ; echo $?
0
[paul@RHEL4b ~]$
If you prefer true and false, then write the test like this.
[paul@RHEL4b ~]$ test 56 -gt 55 && echo true || echo false
true
[paul@RHEL4b ~]$ test 6 -gt 55 && echo true || echo false
false
The test command can also be written as square brackets, the screenshot below is identical
to the one above.
[paul@RHEL4b ~]$ [ 56 -gt 55 ] && echo true || echo false
true
[paul@RHEL4b ~]$ [ 6 -gt 55 ] && echo true || echo false
false
Below are some example tests. Take a look at man test to see more options for tests.
[
[
[
[
[
[
[
[
[
[
[
-d foo ]
-e bar ]
'/etc' = $PWD ]
$1 != 'secret' ]
55 -lt $bar ]
$foo -ge 1000 ]
"abc" < $bar ]
-f foo ]
-r bar ]
foo -nt bar ]
-o nounset ]
Does the directory foo exist ?
Does the file bar exist ?
Is the string /etc equal to the variable $PWD ?
Is the first parameter different from secret ?
Is 55 less than the value of $bar ?
Is the value of $foo greater or equal to 1000 ?
Does abc sort before the value of $bar ?
Is foo a regular file ?
Is bar a readable file ?
Is file foo newer than file bar ?
Is the shell option nounset set ?
Tests can be combined with logical AND and OR.
paul@RHEL4b:~$ [ 66 -gt 55 -a 66 -lt 500 ] && echo true || echo false
true
paul@RHEL4b:~$ [ 66 -gt 55 -a 660 -lt 500 ] && echo true || echo false
false
paul@RHEL4b:~$ [ 66 -gt 55 -o 660 -lt 500 ] && echo true || echo false
true
241scripting loops
24.2. if then else
The if then else construction is about choice. If a certain condition is met, then execute
something, else execute something else. The example below tests whether a file exists, and
if the file exists then a proper message is echoed.
#!/bin/bash
if [ -f isit.txt ]
then echo isit.txt exists!
else echo isit.txt not found!
fi
If we name the above script 'choice', then it executes like this.
[paul@RHEL4a scripts]$ ./choice
isit.txt not found!
[paul@RHEL4a scripts]$ touch isit.txt
[paul@RHEL4a scripts]$ ./choice
isit.txt exists!
[paul@RHEL4a scripts]$
24.3. if then elif
You can nest a new if inside an else with elif. This is a simple example.
#!/bin/bash
count=42
if [ $count -eq 42 ]
then
echo "42 is correct."
elif [ $count -gt 42 ]
then
echo "Too much."
else
echo "Not enough."
fi
24.4. for loop
The example below shows the syntax of a classical for loop in bash.
for i in 1 2 4
do
echo $i
done
An example of a for loop combined with an embedded shell.
#!/bin/ksh
for counter in `seq 1 20`
do
echo counting from 1 to 20, now at $counter
sleep 1
done
The same example as above can be written without the embedded shell using the bash
{from..to} shorthand.
242scripting loops
#!/bin/bash
for counter in {1..20}
do
echo counting from 1 to 20, now at $counter
sleep 1
done
This for loop uses file globbing (from the shell expansion). Putting the instruction on the
command line has identical functionality.
kahlan@solexp11$ ls
count.ksh go.ksh
kahlan@solexp11$ for file in *.ksh ; do cp $file $file.backup ; done
kahlan@solexp11$ ls
count.ksh count.ksh.backup go.ksh go.ksh.backup
24.5. while loop
Below a simple example of a while loop.
i=100;
while [ $i -ge 0 ] ;
do
echo Counting down, from 100 to 0, now at $i;
let i--;
done
Endless loops can be made with while true or while : , where the colon is the equivalent
of no operation in the Korn and bash shells.
#!/bin/ksh
# endless loop
while :
do
echo hello
sleep 1
done
24.6. until loop
Below a simple example of an until loop.
let i=100;
until [ $i -le 0 ] ;
do
echo Counting down, from 100 to 1, now at $i;
let i--;
done
243scripting loops
24.7. practice: scripting tests and loops
1. Write a script that uses a for loop to count from 3 to 7.
2. Write a script that uses a for loop to count from 1 to 17000.
3. Write a script that uses a while loop to count from 3 to 7.
4. Write a script that uses an until loop to count down from 8 to 4.
5. Write a script that counts the number of files ending in .txt in the current directory.
6. Wrap an if statement around the script so it is also correct when there are zero files ending
in .txt.
244scripting loops
24.8. solution: scripting tests and loops
1. Write a script that uses a for loop to count from 3 to 7.
#!/bin/bash
for i in 3 4 5 6 7
do
echo Counting from 3 to 7, now at $i
done
2. Write a script that uses a for loop to count from 1 to 17000.
#!/bin/bash
for i in `seq 1 17000`
do
echo Counting from 1 to 17000, now at $i
done
3. Write a script that uses a while loop to count from 3 to 7.
#!/bin/bash
i=3
while [ $i -le 7 ]
do
echo Counting from 3 to 7, now at $i
let i=i+1
done
4. Write a script that uses an until loop to count down from 8 to 4.
#!/bin/bash
i=8
until [ $i -lt 4 ]
do
echo Counting down from 8 to 4, now at $i
let i=i-1
done
5. Write a script that counts the number of files ending in .txt in the current directory.
#!/bin/bash
let i=0
for file in *.txt
do
let i++
done
echo "There are $i files ending in .txt"
6. Wrap an if statement around the script so it is also correct when there are zero files ending
in .txt.
#!/bin/bash
ls *.txt > /dev/null 2>&1
if [ $? -ne 0 ]
245scripting loops
then echo "There are 0 files ending in .txt"
else
let i=0
for file in *.txt
do
let i++
done
echo "There are $i files ending in .txt"
fi
246Chapter 25. scripting parameters
247scripting parameters
25.1. script parameters
A bash shell script can have parameters. The numbering you see in the script below
continues if you have more parameters. You also have special parameters containing the
number of parameters, a string of all of them, and also the process id, and the last return
code. The man page of bash has a full list.
#!/bin/bash
echo The first argument is $1
echo The second argument is $2
echo The third argument is $3
echo
echo
echo
echo
\$
\#
\?
\*
$$
$#
$?
$*
PID of the script
count arguments
last return code
all the arguments
Below is the output of the script above in action.
[paul@RHEL4a scripts]$ ./pars one two three
The first argument is one
The second argument is two
The third argument is three
$ 5610 PID of the script
# 3 count arguments
? 0 last return code
* one two three all the arguments
Once more the same script, but with only two parameters.
[paul@RHEL4a scripts]$ ./pars 1 2
The first argument is 1
The second argument is 2
The third argument is
$ 5612 PID of the script
# 2 count arguments
? 0 last return code
* 1 2 all the arguments
[paul@RHEL4a scripts]$
Here is another example, where we use $0. The $0 parameter contains the name of the script.
paul@debian6~$ cat myname
echo this script is called $0
paul@debian6~$ ./myname
this script is called ./myname
paul@debian6~$ mv myname test42
paul@debian6~$ ./test42
this script is called ./test42
248scripting parameters
25.2. shift through parameters
The shift statement can parse all parameters one by one. This is a sample script.
kahlan@solexp11$ cat shift.ksh
#!/bin/ksh
if [ "$#" == "0" ]
then
echo You have to give at least one parameter.
exit 1
fi
while (( $# ))
do
echo You gave me $1
shift
done
Below is some sample output of the script above.
kahlan@solexp11$ ./shift.ksh one
You gave me one
kahlan@solexp11$ ./shift.ksh one two three 1201 "33 42"
You gave me one
You gave me two
You gave me three
You gave me 1201
You gave me 33 42
kahlan@solexp11$ ./shift.ksh
You have to give at least one parameter.
25.3. runtime input
You can ask the user for input with the read command in a script.
#!/bin/bash
echo -n Enter a number:
read number
249scripting parameters
25.4. sourcing a config file
The source (as seen in the shell chapters) can be used to source a configuration file.
Below a sample configuration file for an application.
[paul@RHEL4a scripts]$ cat myApp.conf
# The config file of myApp
# Enter the path here
myAppPath=/var/myApp
# Enter the number of quines here
quines=5
And here an application that uses this file.
[paul@RHEL4a scripts]$ cat myApp.bash
#!/bin/bash
#
# Welcome to the myApp application
#
. ./myApp.conf
echo There are $quines quines
The running application can use the values inside the sourced configuration file.
[paul@RHEL4a scripts]$ ./myApp.bash
There are 5 quines
[paul@RHEL4a scripts]$
250scripting parameters
25.5. get script options with getopts
The getopts function allows you to parse options given to a command. The following script
allows for any combination of the options a, f and z.
kahlan@solexp11$ cat options.ksh
#!/bin/ksh
while getopts ":afz" option;
do
case $option in
a)
echo received -a
;;
f)
echo received -f
;;
z)
echo received -z
;;
*)
echo "invalid option -$OPTARG"
;;
esac
done
This is sample output from the script above. First we use correct options, then we enter twice
an invalid option.
kahlan@solexp11$ ./options.ksh
kahlan@solexp11$ ./options.ksh -af
received -a
received -f
kahlan@solexp11$ ./options.ksh -zfg
received -z
received -f
invalid option -g
kahlan@solexp11$ ./options.ksh -a -b -z
received -a
invalid option -b
received -z
251scripting parameters
You can also check for options that need an argument, as this example shows.
kahlan@solexp11$ cat argoptions.ksh
#!/bin/ksh
while getopts ":af:z" option;
do
case $option in
a)
echo received -a
;;
f)
echo received -f with $OPTARG
;;
z)
echo received -z
;;
:)
echo "option -$OPTARG needs an argument"
;;
*)
echo "invalid option -$OPTARG"
;;
esac
done
This is sample output from the script above.
kahlan@solexp11$ ./argoptions.ksh -a -f hello -z
received -a
received -f with hello
received -z
kahlan@solexp11$ ./argoptions.ksh -zaf 42
received -z
received -a
received -f with 42
kahlan@solexp11$ ./argoptions.ksh -zf
received -z
option -f needs an argument
25.6. get shell options with shopt
You can toggle the values of variables controlling optional shell behaviour with the shopt
built-in shell command. The example below first verifies whether the cdspell option is set;
it is not. The next shopt command sets the value, and the third shopt command verifies that
the option really is set. You can now use minor spelling mistakes in the cd command. The
man page of bash has a complete list of options.
paul@laika:~$
1
paul@laika:~$
paul@laika:~$
0
paul@laika:~$
/etc
shopt -q cdspell ; echo $?
shopt -s cdspell
shopt -q cdspell ; echo $?
cd /Etc
252scripting parameters
25.7. practice: parameters and options
1. Write a script that receives four parameters, and outputs them in reverse order.
2. Write a script that receives two parameters (two filenames) and outputs whether those
files exist.
3. Write a script that asks for a filename. Verify existence of the file, then verify that you
own the file, and whether it is writable. If not, then make it writable.
4. Make a configuration file for the previous script. Put a logging switch in the config file,
logging means writing detailed output of everything the script does to a log file in /tmp.
253scripting parameters
25.8. solution: parameters and options
1. Write a script that receives four parameters, and outputs them in reverse order.
echo $4 $3 $2 $1
2. Write a script that receives two parameters (two filenames) and outputs whether those
files exist.
#!/bin/bash
if [ -f $1 ]
then echo $1 exists!
else echo $1 not found!
fi
if [ -f $2 ]
then echo $2 exists!
else echo $2 not found!
fi
3. Write a script that asks for a filename. Verify existence of the file, then verify that you
own the file, and whether it is writable. If not, then make it writable.
4. Make a configuration file for the previous script. Put a logging switch in the config file,
logging means writing detailed output of everything the script does to a log file in /tmp.
254Chapter 26. more scripting
255more scripting
26.1. eval
eval reads arguments as input to the shell (the resulting commands are executed). This allows
using the value of a variable as a variable.
paul@deb503:~/test42$ answer=42
paul@deb503:~/test42$ word=answer
paul@deb503:~/test42$ eval x=\$$word ; echo $x
42
Both in bash and Korn the arguments can be quoted.
kahlan@solexp11$ answer=42
kahlan@solexp11$ word=answer
kahlan@solexp11$ eval "y=\$$word" ; echo $y
42
Sometimes the eval is needed to have correct parsing of arguments. Consider this example
where the date command receives one parameter 1 week ago.
paul@debian6~$ date --date="1 week ago"
Thu Mar 8 21:36:25 CET 2012
When we set this command in a variable, then executing that variable fails unless we use
eval.
paul@debian6~$ lastweek='date --date="1 week ago"'
paul@debian6~$ $lastweek
date: extra operand `ago"'
Try `date --help' for more information.
paul@debian6~$ eval $lastweek
Thu Mar 8 21:36:39 CET 2012
26.2. (( ))
The (( )) allows for evaluation of numerical expressions.
paul@deb503:~/test42$
true
paul@deb503:~/test42$
false
paul@deb503:~/test42$
paul@deb503:~/test42$
true
paul@deb503:~/test42$
true
paul@deb503:~/test42$
paul@deb503:~/test42$
false
(( 42 > 33 )) && echo true || echo false
(( 42 > 1201 )) && echo true || echo false
var42=42
(( 42 == var42 )) && echo true || echo false
(( 42 == $var42 )) && echo true || echo false
var42=33
(( 42 == var42 )) && echo true || echo false
256more scripting
26.3. let
The let built-in shell function instructs the shell to perform an evaluation of arithmetic
expressions. It will return 0 unless the last arithmetic expression evaluates to 0.
[paul@RHEL4b
7
[paul@RHEL4b
20
[paul@RHEL4b
18
[paul@RHEL4b
30
~]$ let x="3 + 4" ; echo $x
~]$ let x="10 + 100/10" ; echo $x
~]$ let x="10-2+100/10" ; echo $x
~]$ let x="10*2+100/10" ; echo $x
The shell can also convert between different bases.
[paul@RHEL4b
255
[paul@RHEL4b
192
[paul@RHEL4b
168
[paul@RHEL4b
56
[paul@RHEL4b
63
[paul@RHEL4b
192
~]$ let x="0xFF" ; echo $x
~]$ let x="0xC0" ; echo $x
~]$ let x="0xA8" ; echo $x
~]$ let x="8#70" ; echo $x
~]$ let x="8#77" ; echo $x
~]$ let x="16#c0" ; echo $x
There is a difference between assigning a variable directly, or using let to evaluate the
arithmetic expressions (even if it is just assigning a value).
kahlan@solexp11$
kahlan@solexp11$
15 017 0x0f
kahlan@solexp11$
kahlan@solexp11$
15 15 15
dec=15 ; oct=017 ; hex=0x0f
echo $dec $oct $hex
let dec=15 ; let oct=017 ; let hex=0x0f
echo $dec $oct $hex
257more scripting
26.4. case
You can sometimes simplify nested if statements with a case construct.
[paul@RHEL4b ~]$ ./help
What animal did you see ? lion
You better start running fast!
[paul@RHEL4b ~]$ ./help
What animal did you see ? dog
Don't worry, give it a cookie.
[paul@RHEL4b ~]$ cat help
#!/bin/bash
#
# Wild Animals Helpdesk Advice
#
echo -n "What animal did you see ? "
read animal
case $animal in
"lion" | "tiger")
echo "You better start running fast!"
;;
"cat")
echo "Let that mouse go..."
;;
"dog")
echo "Don't worry, give it a cookie."
;;
"chicken" | "goose" | "duck" )
echo "Eggs for breakfast!"
;;
"liger")
echo "Approach and say 'Ah you big fluffy kitty...'."
;;
"babelfish")
echo "Did it fall out your ear ?"
;;
*)
echo "You discovered an unknown animal, name it!"
;;
esac
[paul@RHEL4b ~]$
258more scripting
26.5. shell functions
Shell functions can be used to group commands in a logical way.
kahlan@solexp11$ cat funcs.ksh
#!/bin/ksh
function greetings {
echo Hello World!
echo and hello to $USER to!
}
echo We will now call a function
greetings
echo The end
This is sample output from this script with a function.
kahlan@solexp11$ ./funcs.ksh
We will now call a function
Hello World!
and hello to kahlan to!
The end
A shell function can also receive parameters.
kahlan@solexp11$ cat addfunc.ksh
#!/bin/ksh
function plus {
let result="$1 + $2"
echo $1 + $2 = $result
}
plus 3 10
plus 20 13
plus 20 22
This script produces the following output.
kahlan@solexp11$ ./addfunc.ksh
3 + 10 = 13
20 + 13 = 33
20 + 22 = 42
259more scripting
26.6. practice : more scripting
1. Write a script that asks for two numbers, and outputs the sum and product (as shown here).
Enter a number: 5
Enter another number: 2
Sum:
Product:
5 + 2 = 7
5 x 2 = 10
2. Improve the previous script to test that the numbers are between 1 and 100, exit with an
error if necessary.
3. Improve the previous script to congratulate the user if the sum equals the product.
4. Write a script with a case insensitive case statement, using the shopt nocasematch option.
The nocasematch option is reset to the value it had before the scripts started.
5. If time permits (or if you are waiting for other students to finish this practice), take a look
at Linux system scripts in /etc/init.d and /etc/rc.d and try to understand them. Where does
execution of a script start in /etc/init.d/samba ? There are also some hidden scripts in ~, we
will discuss them later.
260more scripting
26.7. solution : more scripting
1. Write a script that asks for two numbers, and outputs the sum and product (as shown here).
Enter a number: 5
Enter another number: 2
Sum:
Product:
5 + 2 = 7
5 x 2 = 10
#!/bin/bash
echo -n "Enter a number : "
read n1
echo -n "Enter another number : "
read n2
let sum="$n1+$n2"
let pro="$n1*$n2"
echo -e "Sum\t: $n1 + $n2 = $sum"
echo -e "Product\t: $n1 * $n2 = $pro"
2. Improve the previous script to test that the numbers are between 1 and 100, exit with an
error if necessary.
echo -n "Enter a number between 1 and 100 : "
read n1
if [ $n1 -lt 1 -o $n1 -gt 100 ]
then
echo Wrong number...
exit 1
fi
3. Improve the previous script to congratulate the user if the sum equals the product.
if [ $sum -eq $pro ]
then echo Congratulations $sum == $pro
fi
4. Write a script with a case insensitive case statement, using the shopt nocasematch option.
The nocasematch option is reset to the value it had before the scripts started.
#!/bin/bash
#
# Wild Animals Case Insensitive Helpdesk Advice
#
if shopt -q nocasematch; then
nocase=yes;
else
nocase=no;
shopt -s nocasematch;
fi
echo -n "What animal did you see ? "
read animal
case $animal in
261more scripting
"lion" | "tiger")
echo "You better start running fast!"
;;
"cat")
echo "Let that mouse go..."
;;
"dog")
echo "Don't worry, give it a cookie."
;;
"chicken" | "goose" | "duck" )
echo "Eggs for breakfast!"
;;
"liger")
echo "Approach and say 'Ah you big fluffy kitty.'"
;;
"babelfish")
echo "Did it fall out your ear ?"
;;
*)
echo "You discovered an unknown animal, name it!"
;;
esac
if [ nocase = yes ] ; then
shopt -s nocasematch;
else
shopt -u nocasematch;
fi
5. If time permits (or if you are waiting for other students to finish this practice), take a look
at Linux system scripts in /etc/init.d and /etc/rc.d and try to understand them. Where does
execution of a script start in /etc/init.d/samba ? There are also some hidden scripts in ~, we
will discuss them later.
262Part VIII. local user managementTable of Contents
304Chapter 27. introduction to users
This little chapter will teach you how to identify your user account on a Unix computer using
commands like who am i, id, and more.
In a second part you will learn how to become another user with the su command.
And you will learn how to run a program as another user with sudo.
266introduction to users
27.1. whoami
The whoami command tells you your username.
[paul@centos7 ~]$ whoami
paul
[paul@centos7 ~]$
27.2. who
The who command will give you information about who is logged on the system.
[paul@centos7 ~]$ who
root
pts/0
2014-10-10 23:07 (10.104.33.101)
paul
pts/1
2014-10-10 23:30 (10.104.33.101)
laura
pts/2
2014-10-10 23:34 (10.104.33.96)
tania
pts/3
2014-10-10 23:39 (10.104.33.91)
[paul@centos7 ~]$
27.3. who am i
With who am i the who command will display only the line pointing to your current session.
[paul@centos7 ~]$ who am i
paul
pts/1
2014-10-10 23:30 (10.104.33.101)
[paul@centos7 ~]$
27.4. w
The w command shows you who is logged on and what they are doing.
[paul@centos7 ~]$ w
23:34:07 up 31 min, 2 users, load average: 0.00, 0.01, 0.02
USER
TTY
LOGIN@
IDLE
JCPU
PCPU WHAT
root
pts/0
23:07
15.00s 0.01s 0.01s top
paul
pts/1
23:30
7.00s 0.00s 0.00s w
[paul@centos7 ~]$
27.5. id
The id command will give you your user id, primary group id, and a list of the groups that
you belong to.
paul@debian7:~$ id
uid=1000(paul) gid=1000(paul) groups=1000(paul)
On RHEL/CentOS you will also get SELinux context information with this command.
[root@centos7 ~]# id
uid=0(root) gid=0(root) groups=0(root) context=unconfined_u:unconfined_r\
:unconfined_t:s0-s0:c0.c1023
267introduction to users
27.6. su to another user
The su command allows a user to run a shell as another user.
laura@debian7:~$ su tania
Password:
tania@debian7:/home/laura$
27.7. su to root
Yes you can also su to become root, when you know the root password.
laura@debian7:~$ su root
Password:
root@debian7:/home/laura#
27.8. su as root
You need to know the password of the user you want to substitute to, unless your are logged
in as root. The root user can become any existing user without knowing that user's password.
root@debian7:~# id
uid=0(root) gid=0(root) groups=0(root)
root@debian7:~# su - valentina
valentina@debian7:~$
27.9. su - $username
By default, the su command maintains the same shell environment. To become another user
and also get the target user's environment, issue the su - command followed by the target
username.
root@debian7:~# su laura
laura@debian7:/root$ exit
exit
root@debian7:~# su - laura
laura@debian7:~$ pwd
/home/laura
27.10. su -
When no username is provided to su or su -, the command will assume root is the target.
tania@debian7:~$ su -
Password:
root@debian7:~#
268introduction to users
27.11. run a program as another user
The sudo program allows a user to start a program with the credentials of another user.
Before this works, the system administrator has to set up the /etc/sudoers file. This can be
useful to delegate administrative tasks to another user (without giving the root password).
The screenshot below shows the usage of sudo. User paul received the right to run useradd
with the credentials of root. This allows paul to create new users on the system without
becoming root and without knowing the root password.
First the command fails for paul.
paul@debian7:~$ /usr/sbin/useradd -m valentina
useradd: Permission denied.
useradd: cannot lock /etc/passwd; try again later.
But with sudo it works.
paul@debian7:~$ sudo /usr/sbin/useradd -m valentina
[sudo] password for paul:
paul@debian7:~$
27.12. visudo
Check the man page of visudo before playing with the /etc/sudoers file. Editing the sudoers
is out of scope for this fundamentals book.
paul@rhel65:~$ apropos visudo
visudo
(8) - edit the sudoers file
paul@rhel65:~$
269introduction to users
27.13. sudo su -
On some Linux systems like Ubuntu and Xubuntu, the root user does not have a password
set. This means that it is not possible to login as root (extra security). To perform tasks as
root, the first user is given all sudo rights via the /etc/sudoers. In fact all users that are
members of the admin group can use sudo to run all commands as root.
root@laika:~# grep admin /etc/sudoers
# Members of the admin group may gain root privileges
%admin ALL=(ALL) ALL
The end result of this is that the user can type sudo su - and become root without having to
enter the root password. The sudo command does require you to enter your own password.
Thus the password prompt in the screenshot below is for sudo, not for su.
paul@laika:~$ sudo su -
Password:
root@laika:~#
27.14. sudo logging
Using sudo without authorization will result in a severe warning:
paul@rhel65:~$ sudo su -
We trust you have received the usual lecture from the local System
Administrator. It usually boils down to these three things:
#1) Respect the privacy of others.
#2) Think before you type.
#3) With great power comes great responsibility.
[sudo] password for paul:
paul is not in the sudoers file.
paul@rhel65:~$
This incident will be reported.
The root user can see this in the /var/log/secure on Red Hat and in /var/log/auth.log on
Debian).
root@rhel65:~# tail /var/log/secure | grep sudo | tr -s ' '
Apr 13 16:03:42 rhel65 sudo: paul : user NOT in sudoers ; TTY=pts/0 ; PWD=\
/home/paul ; USER=root ; COMMAND=/bin/su -
root@rhel65:~#
270introduction to users
27.15. practice: introduction to users
1. Run a command that displays only your currently logged on user name.
2. Display a list of all logged on users.
3. Display a list of all logged on users including the command they are running at this very
moment.
4. Display your user name and your unique user identification (userid).
5. Use su to switch to another user account (unless you are root, you will need the password
of the other account). And get back to the previous account.
6. Now use su - to switch to another user and notice the difference.
Note that su - gets you into the home directory of Tania.
7. Try to create a new user account (when using your normal user account). this should fail.
(Details on adding user accounts are explained in the next chapter.)
8. Now try the same, but with sudo before your command.
271introduction to users
27.16. solution: introduction to users
1. Run a command that displays only your currently logged on user name.
laura@debian7:~$ whoami
laura
laura@debian7:~$ echo $USER
laura
2. Display a list of all logged on users.
laura@debian7:~$ who
laura
pts/0
laura@debian7:~$
2014-10-13 07:22 (10.104.33.101)
3. Display a list of all logged on users including the command they are running at this very
moment.
laura@debian7:~$ w
07:47:02 up 16 min, 2 users, load average: 0.00, 0.00,
USER
TTY
FROM
LOGIN@
IDLE
JCPU
root
pts/0
10.104.33.101
07:30
6.00s 0.04s
root
pts/1
10.104.33.101
07:46
6.00s 0.01s
laura@debian7:~$
0.00
PCPU WHAT
0.00s w
0.00s sleep 42
4. Display your user name and your unique user identification (userid).
laura@debian7:~$ id
uid=1005(laura) gid=1007(laura) groups=1007(laura)
laura@debian7:~$
5. Use su to switch to another user account (unless you are root, you will need the password
of the other account). And get back to the previous account.
laura@debian7:~$ su tania
Password:
tania@debian7:/home/laura$ id
uid=1006(tania) gid=1008(tania) groups=1008(tania)
tania@debian7:/home/laura$ exit
laura@debian7:~$
6. Now use su - to switch to another user and notice the difference.
laura@debian7:~$ su - tania
Password:
tania@debian7:~$ pwd
/home/tania
tania@debian7:~$ logout
laura@debian7:~$
Note that su - gets you into the home directory of Tania.
272introduction to users
7. Try to create a new user account (when using your normal user account). this should fail.
(Details on adding user accounts are explained in the next chapter.)
laura@debian7:~$ useradd valentina
-su: useradd: command not found
laura@debian7:~$ /usr/sbin/useradd valentina
useradd: Permission denied.
useradd: cannot lock /etc/passwd; try again later.
It is possible that useradd is located in /sbin/useradd on your computer.
8. Now try the same, but with sudo before your command.
laura@debian7:~$ sudo /usr/sbin/useradd valentina
[sudo] password for laura:
laura is not in the sudoers file. This incident will be reported.
laura@debian7:~$
Notice that laura has no permission to use the sudo on this system.
273Chapter 28. user management
This chapter will teach you how to use useradd, usermod and userdel to create, modify
and remove user accounts.
You will need root access on a Linux computer to complete this chapter.
274user management
28.1. user management
User management on Linux can be done in three complementary ways. You can use the
graphical tools provided by your distribution. These tools have a look and feel that depends
on the distribution. If you are a novice Linux user on your home system, then use the
graphical tool that is provided by your distribution. This will make sure that you do not run
into problems.
Another option is to use command line tools like useradd, usermod, gpasswd, passwd and
others. Server administrators are likely to use these tools, since they are familiar and very
similar across many different distributions. This chapter will focus on these command line
tools.
A third and rather extremist way is to edit the local configuration files directly using vi (or
vipw/vigr). Do not attempt this as a novice on production systems!
28.2. /etc/passwd
The local user database on Linux (and on most Unixes) is /etc/passwd.
[root@RHEL5 ~]# tail /etc/passwd
inge:x:518:524:art dealer:/home/inge:/bin/ksh
ann:x:519:525:flute player:/home/ann:/bin/bash
frederik:x:520:526:rubius poet:/home/frederik:/bin/bash
steven:x:521:527:roman emperor:/home/steven:/bin/bash
pascale:x:522:528:artist:/home/pascale:/bin/ksh
geert:x:524:530:kernel developer:/home/geert:/bin/bash
wim:x:525:531:master damuti:/home/wim:/bin/bash
sandra:x:526:532:radish stresser:/home/sandra:/bin/bash
annelies:x:527:533:sword fighter:/home/annelies:/bin/bash
laura:x:528:534:art dealer:/home/laura:/bin/ksh
As you can see, this file contains seven columns separated by a colon. The columns contain
the username, an x, the user id, the primary group id, a description, the name of the home
directory, and the login shell.
More information can be found by typing man 5 passwd.
[root@RHEL5 ~]# man 5 passwd
28.3. root
The root user also called the superuser is the most powerful account on your Linux system.
This user can do almost anything, including the creation of other users. The root user always
has userid 0 (regardless of the name of the account).
[root@RHEL5 ~]# head -1 /etc/passwd
root:x:0:0:root:/root:/bin/bash
275user management
28.4. useradd
You can add users with the useradd command. The example below shows how to add a
user named yanina (last parameter) and at the same time forcing the creation of the home
directory (-m), setting the name of the home directory (-d), and setting a description (-c).
[root@RHEL5 ~]# useradd -m -d /home/yanina -c "yanina wickmayer" yanina
[root@RHEL5 ~]# tail -1 /etc/passwd
yanina:x:529:529:yanina wickmayer:/home/yanina:/bin/bash
The user named yanina received userid 529 and primary group id 529.
28.5. /etc/default/useradd
Both Red Hat Enterprise Linux and Debian/Ubuntu have a file called /etc/default/useradd
that contains some default user options. Besides using cat to display this file, you can also
use useradd -D.
[root@RHEL4 ~]# useradd -D
GROUP=100
HOME=/home
INACTIVE=-1
EXPIRE=
SHELL=/bin/bash
SKEL=/etc/skel
28.6. userdel
You can delete the user yanina with userdel. The -r option of userdel will also remove the
home directory.
[root@RHEL5 ~]# userdel -r yanina
28.7. usermod
You can modify the properties of a user with the usermod command. This example uses
usermod to change the description of the user harry.
[root@RHEL4 ~]# tail -1 /etc/passwd
harry:x:516:520:harry potter:/home/harry:/bin/bash
[root@RHEL4 ~]# usermod -c 'wizard' harry
[root@RHEL4 ~]# tail -1 /etc/passwd
harry:x:516:520:wizard:/home/harry:/bin/bash
276user management
28.8. creating home directories
The easiest way to create a home directory is to supply the -m option with useradd (it is
likely set as a default option on Linux).
A less easy way is to create a home directory manually with mkdir which also requires
setting the owner and the permissions on the directory with chmod and chown (both
commands are discussed in detail in another chapter).
[root@RHEL5 ~]# mkdir /home/laura
[root@RHEL5 ~]# chown laura:laura /home/laura
[root@RHEL5 ~]# chmod 700 /home/laura
[root@RHEL5 ~]# ls -ld /home/laura/
drwx------ 2 laura laura 4096 Jun 24 15:17 /home/laura/
28.9. /etc/skel/
When using useradd the -m option, the /etc/skel/ directory is copied to the newly created
home directory. The /etc/skel/ directory contains some (usually hidden) files that contain
profile settings and default values for applications. In this way /etc/skel/ serves as a default
home directory and as a default user profile.
[root@RHEL5 ~]# ls
total 48
drwxr-xr-x 2 root
drwxr-xr-x 97 root
-rw-r--r-- 1 root
-rw-r--r-- 1 root
-rw-r--r-- 1 root
-la /etc/skel/
root 4096 Apr 1 00:11 .
root 12288 Jun 24 15:36 ..
root
24 Jul 12 2006 .bash_logout
root
176 Jul 12 2006 .bash_profile
root
124 Jul 12 2006 .bashrc
28.10. deleting home directories
The -r option of userdel will make sure that the home directory is deleted together with the
user account.
[root@RHEL5 ~]# ls -ld /home/wim/
drwx------ 2 wim wim 4096 Jun 24 15:19 /home/wim/
[root@RHEL5 ~]# userdel -r wim
[root@RHEL5 ~]# ls -ld /home/wim/
ls: /home/wim/: No such file or directory
277user management
28.11. login shell
The /etc/passwd file specifies the login shell for the user. In the screenshot below you can
see that user annelies will log in with the /bin/bash shell, and user laura with the /bin/ksh
shell.
[root@RHEL5 ~]# tail -2 /etc/passwd
annelies:x:527:533:sword fighter:/home/annelies:/bin/bash
laura:x:528:534:art dealer:/home/laura:/bin/ksh
You can use the usermod command to change the shell for a user.
[root@RHEL5 ~]# usermod -s /bin/bash laura
[root@RHEL5 ~]# tail -1 /etc/passwd
laura:x:528:534:art dealer:/home/laura:/bin/bash
28.12. chsh
Users can change their login shell with the chsh command. First, user harry obtains a list of
available shells (he could also have done a cat /etc/shells) and then changes his login shell
to the Korn shell (/bin/ksh). At the next login, harry will default into ksh instead of bash.
[laura@centos7 ~]$ chsh -l
/bin/sh
/bin/bash
/sbin/nologin
/usr/bin/sh
/usr/bin/bash
/usr/sbin/nologin
/bin/ksh
/bin/tcsh
/bin/csh
[laura@centos7 ~]$
Note that the -l option does not exist on Debian and that the above screenshot assumes that
ksh and csh shells are installed.
The screenshot below shows how laura can change her default shell (active on next login).
[laura@centos7 ~]$ chsh -s /bin/ksh
Changing shell for laura.
Password:
Shell changed.
278user management
28.13. practice: user management
1. Create a user account named serena, including a home directory and a description (or
comment) that reads Serena Williams. Do all this in one single command.
2. Create a user named venus, including home directory, bash shell, a description that reads
Venus Williams all in one single command.
3. Verify that both users have correct entries in /etc/passwd, /etc/shadow and /etc/group.
4. Verify that their home directory was created.
5. Create a user named einstime with /bin/date as his default logon shell.
7. What happens when you log on with the einstime user ? Can you think of a useful real
world example for changing a user's login shell to an application ?
8. Create a file named welcome.txt and make sure every new user will see this file in their
home directory.
9. Verify this setup by creating (and deleting) a test user account.
10. Change the default login shell for the serena user to /bin/bash. Verify before and after
you make this change.
279user management
28.14. solution: user management
1. Create a user account named serena, including a home directory and a description (or
comment) that reads Serena Williams. Do all this in one single command.
root@debian7:~# useradd -m -c 'Serena Williams' serena
2. Create a user named venus, including home directory, bash shell, a description that reads
Venus Williams all in one single command.
root@debian7:~# useradd -m -c "Venus Williams" -s /bin/bash venus
3. Verify that both users have correct entries in /etc/passwd, /etc/shadow and /etc/group.
root@debian7:~# tail -2 /etc/passwd
serena:x:1008:1010:Serena Williams:/home/serena:/bin/sh
venus:x:1009:1011:Venus Williams:/home/venus:/bin/bash
root@debian7:~# tail -2 /etc/shadow
serena:!:16358:0:99999:7:::
venus:!:16358:0:99999:7:::
root@debian7:~# tail -2 /etc/group
serena:x:1010:
venus:x:1011:
4. Verify that their home directory was created.
root@debian7:~# ls -lrt /home | tail -2
drwxr-xr-x 2 serena
serena
4096 Oct 15 10:50 serena
drwxr-xr-x 2 venus
venus
4096 Oct 15 10:59 venus
root@debian7:~#
5. Create a user named einstime with /bin/date as his default logon shell.
root@debian7:~# useradd -s /bin/date einstime
Or even better:
root@debian7:~# useradd -s $(which date) einstime
7. What happens when you log on with the einstime user ? Can you think of a useful real
world example for changing a user's login shell to an application ?
root@debian7:~# su - einstime
Wed Oct 15 11:05:56 UTC 2014 # You get the output of the date command
root@debian7:~#
It can be useful when users need to access only one application on the server. Just logging
in opens the application for them, and closing the application automatically logs them out.
280user management
8. Create a file named welcome.txt and make sure every new user will see this file in their
home directory.
root@debian7:~# echo Hello > /etc/skel/welcome.txt
9. Verify this setup by creating (and deleting) a test user account.
root@debian7:~# useradd -m test
root@debian7:~# ls -l /home/test
total 4
-rw-r--r-- 1 test test 6 Oct 15 11:16 welcome.txt
root@debian7:~# userdel -r test
root@debian7:~#
10. Change the default login shell for the serena user to /bin/bash. Verify before and after
you make this change.
root@debian7:~# grep serena /etc/passwd
serena:x:1008:1010:Serena Williams:/home/serena:/bin/sh
root@debian7:~# usermod -s /bin/bash serena
root@debian7:~# grep serena /etc/passwd
serena:x:1008:1010:Serena Williams:/home/serena:/bin/bash
root@debian7:~#
281Chapter 29. user passwords
This chapter will tell you more about passwords for local users.
Three methods for setting passwords are explained; using the passwd command, using
openssel passwd, and using the crypt function in a C program.
The chapter will also discuss password settings and disabling, suspending or locking
accounts.
282user passwords
29.1. passwd
Passwords of users can be set with the passwd command. Users will have to provide their
old password before twice entering the new one.
[tania@centos7 ~]$ passwd
Changing password for user tania.
Changing password for tania.
(current) UNIX password:
New password:
BAD PASSWORD: The password is shorter than 8 characters
New password:
BAD PASSWORD: The password is a palindrome
New password:
BAD PASSWORD: The password is too similar to the old one
passwd: Have exhausted maximum number of retries for service
As you can see, the passwd tool will do some basic verification to prevent users from using
too simple passwords. The root user does not have to follow these rules (there will be
a warning though). The root user also does not have to provide the old password before
entering the new password twice.
root@debian7:~# passwd tania
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
29.2. shadow file
User passwords are encrypted and kept in /etc/shadow. The /etc/shadow file is read only
and can only be read by root. We will see in the file permissions section how it is possible
for users to change their password. For now, you will have to know that users can change
their password with the /usr/bin/passwd command.
[root@centos7 ~]# tail -4 /etc/shadow
paul:$6$ikp2Xta5BT.Tml.p$2TZjNnOYNNQKpwLJqoGJbVsZG5/Fti8ovBRd.VzRbiDSl7TEq\
IaSMH.TeBKnTS/SjlMruW8qffC0JNORW.BTW1:16338:0:99999:7:::
tania:$6$8Z/zovxj$9qvoqT8i9KIrmN.k4EQwAF5ryz5yzNwEvYjAa9L5XVXQu.z4DlpvMREH\
eQpQzvRnqFdKkVj17H5ST.c79HDZw0:16356:0:99999:7:::
laura:$6$glDuTY5e$/NYYWLxfHgZFWeoujaXSMcR.Mz.lGOxtcxFocFVJNb98nbTPhWFXfKWG\
SyYh1WCv6763Wq54.w24Yr3uAZBOm/:16356:0:99999:7:::
valentina:$6$jrZa6PVI$1uQgqR6En9mZB6mKJ3LXRB4CnFko6LRhbh.v4iqUk9MVreui1lv7\
GxHOUDSKA0N55ZRNhGHa6T2ouFnVno/0o1:16356:0:99999:7:::
[root@centos7 ~]#
The /etc/shadow file contains nine colon separated columns. The nine fields contain (from
left to right) the user name, the encrypted password (note that only inge and laura have an
encrypted password), the day the password was last changed (day 1 is January 1, 1970),
number of days the password must be left unchanged, password expiry day, warning number
of days before password expiry, number of days after expiry before disabling the account,
and the day the account was disabled (again, since 1970). The last field has no meaning yet.
All the passwords in the screenshot above are hashes of hunter2.
283user passwords
29.3. encryption with passwd
Passwords are stored in an encrypted format. This encryption is done by the crypt function.
The easiest (and recommended) way to add a user with a password to the system is to add
the user with the useradd -m user command, and then set the user's password with passwd.
[root@RHEL4 ~]# useradd -m xavier
[root@RHEL4 ~]# passwd xavier
Changing password for user xavier.
New UNIX password:
Retype new UNIX password:
passwd: all authentication tokens updated successfully.
[root@RHEL4 ~]#
29.4. encryption with openssl
Another way to create users with a password is to use the -p option of useradd, but that
option requires an encrypted password. You can generate this encrypted password with the
openssl passwd command.
The openssl passwd command will generate several distinct hashes for the same password,
for this it uses a salt.
paul@rhel65:~$ openssl passwd hunter2
86jcUNlnGDFpY
paul@rhel65:~$ openssl passwd hunter2
Yj7mDO9OAnvq6
paul@rhel65:~$ openssl passwd hunter2
YqDcJeGoDbzKA
paul@rhel65:~$
This salt can be chosen and is visible as the first two characters of the hash.
paul@rhel65:~$ openssl passwd -salt 42 hunter2
42ZrbtP1Ze8G.
paul@rhel65:~$ openssl passwd -salt 42 hunter2
42ZrbtP1Ze8G.
paul@rhel65:~$ openssl passwd -salt 42 hunter2
42ZrbtP1Ze8G.
paul@rhel65:~$
This example shows how to create a user with password.
root@rhel65:~# useradd -m -p $(openssl passwd hunter2) mohamed
Note that this command puts the password in your command history!
284user passwords
29.5. encryption with crypt
A third option is to create your own C program using the crypt function, and compile this
into a command.
paul@rhel65:~$ cat MyCrypt.c
#include <stdio.h>
#define __USE_XOPEN
#include <unistd.h>
int main(int argc, char** argv)
{
if(argc==3)
{
printf("%s\n", crypt(argv[1],argv[2]));
}
else
{
printf("Usage: MyCrypt $password $salt\n" );
}
return 0;
}
This little program can be compiled with gcc like this.
paul@rhel65:~$ gcc MyCrypt.c -o MyCrypt -lcrypt
To use it, we need to give two parameters to MyCrypt. The first is the unencrypted password,
the second is the salt. The salt is used to perturb the encryption algorithm in one of 4096
different ways. This variation prevents two users with the same password from having the
same entry in /etc/shadow.
paul@rhel65:~$ ./MyCrypt hunter2 42
42ZrbtP1Ze8G.
paul@rhel65:~$ ./MyCrypt hunter2 33
33d6taYSiEUXI
Did you notice that the first two characters of the password are the salt?
The standard output of the crypt function is using the DES algorithm which is old and can
be cracked in minutes. A better method is to use md5 passwords which can be recognized
by a salt starting with $1$.
paul@rhel65:~$ ./MyCrypt hunter2 '$1$42'
$1$42$7l6Y3xT5282XmZrtDOF9f0
paul@rhel65:~$ ./MyCrypt hunter2 '$6$42'
$6$42$OqFFAVnI3gTSYG0yI9TZWX9cpyQzwIop7HwpG1LLEsNBiMr4w6OvLX1KDa./UpwXfrFk1i...
The md5 salt can be up to eight characters long. The salt is displayed in /etc/shadow between
the second and third $, so never use the password as the salt!
paul@rhel65:~$ ./MyCrypt hunter2 '$1$hunter2'
$1$hunter2$YVxrxDmidq7Xf8Gdt6qM2.
285user passwords
29.6. /etc/login.defs
The /etc/login.defs file contains some default settings for user passwords like password
aging and length settings. (You will also find the numerical limits of user ids and group ids
and whether or not a home directory should be created by default).
root@rhel65:~# grep ^PASS /etc/login.defs
PASS_MAX_DAYS
99999
PASS_MIN_DAYS
0
PASS_MIN_LEN
5
PASS_WARN_AGE
7
Debian also has this file.
root@debian7:~# grep PASS /etc/login.defs
# PASS_MAX_DAYS
Maximum number of days a password may be used.
# PASS_MIN_DAYS
Minimum number of days allowed between password changes.
# PASS_WARN_AGE
Number of days warning given before a password expires.
PASS_MAX_DAYS
99999
PASS_MIN_DAYS
0
PASS_WARN_AGE
7
#PASS_CHANGE_TRIES
#PASS_ALWAYS_WARN
#PASS_MIN_LEN
#PASS_MAX_LEN
# NO_PASSWORD_CONSOLE
root@debian7:~#
29.7. chage
The chage command can be used to set an expiration date for a user account (-E), set a
minimum (-m) and maximum (-M) password age, a password expiration date, and set the
number of warning days before the password expiration date. Much of this functionality is
also available from the passwd command. The -l option of chage will list these settings for
a user.
root@rhel65:~# chage -l paul
Last password change
Password expires
Password inactive
Account expires
Minimum number of days between password change
Maximum number of days between password change
Number of days of warning before password expires
root@rhel65:~#
286
:
:
:
:
:
:
:
Mar 27, 2014
never
never
never
0
99999
7user passwords
29.8. disabling a password
Passwords in /etc/shadow cannot begin with an exclamation mark. When the second field
in /etc/passwd starts with an exclamation mark, then the password can not be used.
Using this feature is often called locking, disabling, or suspending a user account. Besides
vi (or vipw) you can also accomplish this with usermod.
The first command in the next screenshot will show the hashed password of laura in /etc/
shadow. The next command disables the password of laura, making it impossible for Laura
to authenticate using this password.
root@debian7:~# grep laura /etc/shadow | cut -c1-70
laura:$6$JYj4JZqp$stwwWACp3OtE1R2aZuE87j.nbW.puDkNUYVk7mCHfCVMa3CoDUJV
root@debian7:~# usermod -L laura
As you can see below, the password hash is simply preceded with an exclamation mark.
root@debian7:~# grep laura /etc/shadow | cut -c1-70
laura:!$6$JYj4JZqp$stwwWACp3OtE1R2aZuE87j.nbW.puDkNUYVk7mCHfCVMa3CoDUJ
root@debian7:~#
The root user (and users with sudo rights on su) still will be able to su into the laura account
(because the password is not needed here). Also note that laura will still be able to login
if she has set up passwordless ssh!
root@debian7:~# su - laura
laura@debian7:~$
You can unlock the account again with usermod -U.
root@debian7:~# usermod -U laura
root@debian7:~# grep laura /etc/shadow | cut -c1-70
laura:$6$JYj4JZqp$stwwWACp3OtE1R2aZuE87j.nbW.puDkNUYVk7mCHfCVMa3CoDUJV
Watch out for tiny differences in the command line options of passwd, usermod, and
useradd on different Linux distributions. Verify the local files when using features like
"disabling, suspending, or locking" on user accounts and their passwords.
29.9. editing local files
If you still want to manually edit the /etc/passwd or /etc/shadow, after knowing these
commands for password management, then use vipw instead of vi(m) directly. The vipw
tool will do proper locking of the file.
[root@RHEL5 ~]# vipw /etc/passwd
vipw: the password file is busy (/etc/ptmp present)
287user passwords
29.10. practice: user passwords
1. Set the password for serena to hunter2.
2. Also set a password for venus and then lock the venus user account with usermod. Verify
the locking in /etc/shadow before and after you lock it.
3. Use passwd -d to disable the serena password. Verify the serena line in /etc/shadow
before and after disabling.
4. What is the difference between locking a user account and disabling a user account's
password like we just did with usermod -L and passwd -d?
5. Try changing the password of serena to serena as serena.
6. Make sure serena has to change her password in 10 days.
7. Make sure every new user needs to change their password every 10 days.
8. Take a backup as root of /etc/shadow. Use vi to copy an encrypted hunter2 hash from
venus to serena. Can serena now log on with hunter2 as a password ?
9. Why use vipw instead of vi ? What could be the problem when using vi or vim ?
10. Use chsh to list all shells (only works on RHEL/CentOS/Fedora), and compare to cat /
etc/shells.
11. Which useradd option allows you to name a home directory ?
12. How can you see whether the password of user serena is locked or unlocked ? Give a
solution with grep and a solution with passwd.
288user passwords
29.11. solution: user passwords
1. Set the password for serena to hunter2.
root@debian7:~# passwd serena
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
2. Also set a password for venus and then lock the venus user account with usermod. Verify
the locking in /etc/shadow before and after you lock it.
root@debian7:~# passwd venus
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
root@debian7:~# grep venus /etc/shadow | cut -c1-70
venus:$6$gswzXICW$uSnKFV1kFKZmTPaMVS4AvNA/KO27OxN0v5LHdV9ed0gTyXrjUeM/
root@debian7:~# usermod -L venus
root@debian7:~# grep venus /etc/shadow | cut -c1-70
venus:!$6$gswzXICW$uSnKFV1kFKZmTPaMVS4AvNA/KO27OxN0v5LHdV9ed0gTyXrjUeM
Note that usermod -L precedes the password hash with an exclamation mark (!).
3. Use passwd -d to disable the serena password. Verify the serena line in /etc/shadow
before and after disabling.
root@debian7:~# grep serena /etc/shadow | cut -c1-70
serena:$6$Es/omrPE$F2Ypu8kpLrfKdW0v/UIwA5jrYyBD2nwZ/dt.i/IypRgiPZSdB/B
root@debian7:~# passwd -d serena
passwd: password expiry information changed.
root@debian7:~# grep serena /etc/shadow
serena::16358:0:99999:7:::
root@debian7:~#
4. What is the difference between locking a user account and disabling a user account's
password like we just did with usermod -L and passwd -d?
Locking will prevent the user from logging on to the system with his password by putting
a ! in front of the password in /etc/shadow.
Disabling with passwd will erase the password from /etc/shadow.
5. Try changing the password of serena to serena as serena.
log on as serena, then execute: passwd serena... it should fail!
6. Make sure serena has to change her password in 10 days.
chage -M 10 serena
7. Make sure every new user needs to change their password every 10 days.
vi /etc/login.defs (and change PASS_MAX_DAYS to 10)
289user passwords
8. Take a backup as root of /etc/shadow. Use vi to copy an encrypted hunter2 hash from
venus to serena. Can serena now log on with hunter2 as a password ?
Yes.
9. Why use vipw instead of vi ? What could be the problem when using vi or vim ?
vipw will give a warning when someone else is already using that file (with vipw).
10. Use chsh to list all shells (only works on RHEL/CentOS/Fedora), and compare to cat /
etc/shells.
chsh -l
cat /etc/shells
11. Which useradd option allows you to name a home directory ?
-d
12. How can you see whether the password of user serena is locked or unlocked ? Give a
solution with grep and a solution with passwd.
grep serena /etc/shadow
passwd -S serena
290Chapter 30. user profiles
Logged on users have a number of preset (and customized) aliases, variables, and functions,
but where do they come from ? The shell uses a number of startup files that are executed
(or rather sourced) whenever the shell is invoked. What follows is an overview of startup
scripts.
291user profiles
30.1. system profile
Both the bash and the ksh shell will verify the existence of /etc/profile and source it if it
exists.
When reading this script, you will notice (both on Debian and on Red Hat Enterprise Linux)
that it builds the PATH environment variable (among others). The script might also change
the PS1 variable, set the HOSTNAME and execute even more scripts like /etc/inputrc
This screenshot uses grep to show PATH manipulation in /etc/profile on Debian.
root@debian7:~# grep PATH /etc/profile
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
PATH="/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games"
export PATH
root@debian7:~#
This screenshot uses grep to show PATH manipulation in /etc/profile on RHEL7/CentOS7.
[root@centos7 ~]# grep PATH /etc/profile
case ":${PATH}:" in
PATH=$PATH:$1
PATH=$1:$PATH
export PATH USER LOGNAME MAIL HOSTNAME HISTSIZE HISTCONTROL
[root@centos7 ~]#
The root user can use this script to set aliases, functions, and variables for every user on
the system.
30.2. ~/.bash_profile
When this file exists in the home directory, then bash will source it. On Debian Linux 5/6/7
this file does not exist by default.
RHEL7/CentOS7 uses a small ~/.bash_profile where it checks for the existence of
~/.bashrc and then sources it. It also adds $HOME/bin to the $PATH variable.
[root@rhel7 ~]# cat /home/paul/.bash_profile
# .bash_profile
# Get the aliases and functions
if [ -f ~/.bashrc ]; then
. ~/.bashrc
fi
# User specific environment and startup programs
PATH=$PATH:$HOME/.local/bin:$HOME/bin
export PATH
[root@rhel7 ~]#
292user profiles
30.3. ~/.bash_login
When .bash_profile does not exist, then bash will check for ~/.bash_login and source it.
Neither Debian nor Red Hat have this file by default.
30.4. ~/.profile
When neither ~/.bash_profile and ~/.bash_login exist, then bash will verify the existence
of ~/.profile and execute it. This file does not exist by default on Red Hat.
On Debian this script can execute ~/.bashrc and will add $HOME/bin to the $PATH
variable.
root@debian7:~# tail -11 /home/paul/.profile
if [ -n "$BASH_VERSION" ]; then
# include .bashrc if it exists
if [ -f "$HOME/.bashrc" ]; then
. "$HOME/.bashrc"
fi
fi
# set PATH so it includes user's private bin if it exists
if [ -d "$HOME/bin" ] ; then
PATH="$HOME/bin:$PATH"
fi
RHEL/CentOS does not have this file by default.
30.5. ~/.bashrc
The ~/.bashrc script is often sourced by other scripts. Let us take a look at what it does
by default.
Red Hat uses a very simple ~/.bashrc, checking for /etc/bashrc and sourcing it. It also leaves
room for custom aliases and functions.
[root@rhel7 ~]# cat /home/paul/.bashrc
# .bashrc
# Source global definitions
if [ -f /etc/bashrc ]; then
. /etc/bashrc
fi
# Uncomment the following line if you don't like systemctl's auto-paging feature:
# export SYSTEMD_PAGER=
# User specific aliases and functions
On Debian this script is quite a bit longer and configures $PS1, some history variables and
a number af active and inactive aliases.
root@debian7:~# wc -l /home/paul/.bashrc
110 /home/paul/.bashrc
293user profiles
30.6. ~/.bash_logout
When exiting bash, it can execute ~/.bash_logout.
Debian use this opportunity to clear the console screen.
serena@deb503:~$ cat .bash_logout
# ~/.bash_logout: executed by bash(1) when login shell exits.
# when leaving the console clear the screen to increase privacy
if [ "$SHLVL" = 1 ]; then
[ -x /usr/bin/clear_console ] && /usr/bin/clear_console -q
fi
Red Hat Enterprise Linux 5 will simple call the /usr/bin/clear command in this script.
[serena@rhel53 ~]$ cat .bash_logout
# ~/.bash_logout
/usr/bin/clear
Red Hat Enterprise Linux 6 and 7 create this file, but leave it empty (except for a comment).
paul@rhel65:~$ cat .bash_logout
# ~/.bash_logout
294user profiles
30.7. Debian overview
Below is a table overview of when Debian is running any of these bash startup scripts.
Table 30.1. Debian User Environment
script su su - ssh gdm
~./bashrc no yes yes yes
~/.profile no yes yes yes
/etc/profile no yes yes yes
/etc/bash.bashrc yes no no yes
30.8. RHEL5 overview
Below is a table overview of when Red Hat Enterprise Linux 5 is running any of these bash
startup scripts.
Table 30.2. Red Hat User Environment
script su su - ssh gdm
~./bashrc yes yes yes yes
~/.bash_profile no yes yes yes
/etc/profile no yes yes yes
/etc/bashrc yes yes yes yes
295user profiles
30.9. practice: user profiles
1. Make a list of all the profile files on your system.
2. Read the contents of each of these, often they source extra scripts.
3. Put a unique variable, alias and function in each of those files.
4. Try several different ways to obtain a shell (su, su -, ssh, tmux, gnome-terminal, Ctrl-
alt-F1, ...) and verify which of your custom variables, aliases and function are present in
your environment.
5. Do you also know the order in which they are executed?
6. When an application depends on a setting in $HOME/.profile, does it matter whether
$HOME/.bash_profile exists or not ?
296user profiles
30.10. solution: user profiles
1. Make a list of all the profile files on your system.
ls -a ~ ; ls -l /etc/pro* /etc/bash*
2. Read the contents of each of these, often they source extra scripts.
3. Put a unique variable, alias and function in each of those files.
4. Try several different ways to obtain a shell (su, su -, ssh, tmux, gnome-terminal, Ctrl-
alt-F1, ...) and verify which of your custom variables, aliases and function are present in
your environment.
5. Do you also know the order in which they are executed?
same name aliases, functions and variables will overwrite each other
6. When an application depends on a setting in $HOME/.profile, does it matter whether
$HOME/.bash_profile exists or not ?
Yes it does matter. (man bash /INVOCATION)
297Chapter 31. groups
Users can be listed in groups. Groups allow you to set permissions on the group level instead
of having to set permissions for every individual user.
Every Unix or Linux distribution will have a graphical tool to manage groups. Novice users
are advised to use this graphical tool. More experienced users can use command line tools to
manage users, but be careful: Some distributions do not allow the mixed use of GUI and CLI
tools to manage groups (YaST in Novell Suse). Senior administrators can edit the relevant
files directly with vi or vigr.
298groups
31.1. groupadd
Groups can be created with the groupadd command. The example below shows the creation
of five (empty) groups.
root@laika:~#
root@laika:~#
root@laika:~#
root@laika:~#
root@laika:~#
groupadd
groupadd
groupadd
groupadd
groupadd
tennis
football
snooker
formula1
salsa
31.2. group file
Users can be a member of several groups. Group membership is defined by the /etc/group
file.
root@laika:~# tail -5 /etc/group
tennis:x:1006:
football:x:1007:
snooker:x:1008:
formula1:x:1009:
salsa:x:1010:
root@laika:~#
The first field is the group's name. The second field is the group's (encrypted) password (can
be empty). The third field is the group identification or GID. The fourth field is the list of
members, these groups have no members.
31.3. groups
A user can type the groups command to see a list of groups where the user belongs to.
[harry@RHEL4b ~]$ groups
harry sports
[harry@RHEL4b ~]$
299groups
31.4. usermod
Group membership can be modified with the useradd or usermod command.
root@laika:~# usermod -a -G tennis inge
root@laika:~# usermod -a -G tennis katrien
root@laika:~# usermod -a -G salsa katrien
root@laika:~# usermod -a -G snooker sandra
root@laika:~# usermod -a -G formula1 annelies
root@laika:~# tail -5 /etc/group
tennis:x:1006:inge,katrien
football:x:1007:
snooker:x:1008:sandra
formula1:x:1009:annelies
salsa:x:1010:katrien
root@laika:~#
Be careful when using usermod to add users to groups. By default, the usermod command
will remove the user from every group of which he is a member if the group is not listed in
the command! Using the -a (append) switch prevents this behaviour.
31.5. groupmod
You can change the group name with the groupmod command.
root@laika:~# groupmod -n darts snooker
root@laika:~# tail -5 /etc/group
tennis:x:1006:inge,katrien
football:x:1007:
formula1:x:1009:annelies
salsa:x:1010:katrien
darts:x:1008:sandra
31.6. groupdel
You can permanently remove a group with the groupdel command.
root@laika:~# groupdel tennis
root@laika:~#
300groups
31.7. gpasswd
You can delegate control of group membership to another user with the gpasswd command.
In the example below we delegate permissions to add and remove group members to serena
for the sports group. Then we su to serena and add harry to the sports group.
[root@RHEL4b ~]# gpasswd -A serena sports
[root@RHEL4b ~]# su - serena
[serena@RHEL4b ~]$ id harry
uid=516(harry) gid=520(harry) groups=520(harry)
[serena@RHEL4b ~]$ gpasswd -a harry sports
Adding user harry to group sports
[serena@RHEL4b ~]$ id harry
uid=516(harry) gid=520(harry) groups=520(harry),522(sports)
[serena@RHEL4b ~]$ tail -1 /etc/group
sports:x:522:serena,venus,harry
[serena@RHEL4b ~]$
Group administrators do not have to be a member of the group. They can remove themselves
from a group, but this does not influence their ability to add or remove members.
[serena@RHEL4b ~]$ gpasswd -d serena sports
Removing user serena from group sports
[serena@RHEL4b ~]$ exit
Information about group administrators is kept in the /etc/gshadow file.
[root@RHEL4b ~]# tail -1 /etc/gshadow
sports:!:serena:venus,harry
[root@RHEL4b ~]#
To remove all group administrators from a group, use the gpasswd command to set an empty
administrators list.
[root@RHEL4b ~]# gpasswd -A "" sports
301groups
31.8. newgrp
You can start a child shell with a new temporary primary group using the newgrp
command.
root@rhel65:~# mkdir prigroup
root@rhel65:~# cd prigroup/
root@rhel65:~/prigroup# touch standard.txt
root@rhel65:~/prigroup# ls -l
total 0
-rw-r--r--. 1 root root 0 Apr 13 17:49 standard.txt
root@rhel65:~/prigroup# echo $SHLVL
1
root@rhel65:~/prigroup# newgrp tennis
root@rhel65:~/prigroup# echo $SHLVL
2
root@rhel65:~/prigroup# touch newgrp.txt
root@rhel65:~/prigroup# ls -l
total 0
-rw-r--r--. 1 root tennis 0 Apr 13 17:49 newgrp.txt
-rw-r--r--. 1 root root
0 Apr 13 17:49 standard.txt
root@rhel65:~/prigroup# exit
exit
root@rhel65:~/prigroup#
31.9. vigr
Similar to vipw, the vigr command can be used to manually edit the /etc/group file, since
it will do proper locking of the file. Only experienced senior administrators should use vi
or vigr to manage groups.
302groups
31.10. practice: groups
1. Create the groups tennis, football and sports.
2. In one command, make venus a member of tennis and sports.
3. Rename the football group to foot.
4. Use vi to add serena to the tennis group.
5. Use the id command to verify that serena is a member of tennis.
6. Make someone responsible for managing group membership of foot and sports. Test that
it works.
303groups
31.11. solution: groups
1. Create the groups tennis, football and sports.
groupadd tennis ; groupadd football ; groupadd sports
2. In one command, make venus a member of tennis and sports.
usermod -a -G tennis,sports venus
3. Rename the football group to foot.
groupmod -n foot football
4. Use vi to add serena to the tennis group.
vi /etc/group
5. Use the id command to verify that serena is a member of tennis.
id (and after logoff logon serena should be member)
6. Make someone responsible for managing group membership of foot and sports. Test that
it works.
gpasswd -A (to make manager)
gpasswd -a (to add member)
304Part IX. file securityTable of Contents
306Chapter 32. standard file permissions
This chapter contains details about basic file security through file ownership and file
permissions.
307standard file permissions
32.1. file ownership
32.1.1. user owner and group owner
The users and groups of a system can be locally managed in /etc/passwd and /etc/group,
or they can be in a NIS, LDAP, or Samba domain. These users and groups can own files.
Actually, every file has a user owner and a group owner, as can be seen in the following
screenshot.
paul@rhel65:~/owners$ ls -lh
total 636K
-rw-r--r--. 1 paul snooker 1.1K
-rw-r--r--. 1 paul paul
626K
-rw-r--r--. 1 root tennis
185
-rw-rw-r--. 1 root root
0
paul@rhel65:~/owners$
Apr
Apr
Apr
Apr
8
8
8
8
18:47
18:46
18:46
18:47
data.odt
file1
file2
stuff.txt
User paul owns three files; file1 has paul as user owner and has the group paul as group
owner, data.odt is group owned by the group snooker, file2 by the group tennis.
The last file is called stuff.txt and is owned by the root user and the root group.
32.1.2. listing user accounts
You can use the following command to list all local user accounts.
paul@debian7~$ cut -d: -f1 /etc/passwd | column
root
ntp
sam
bert
daemon
mysql
tom
rino
bin
paul
wouter
antonio
sys
maarten
robrecht
simon
sync
kevin
bilal
sven
games
yuri
dimitri
wouter2
man
william
ahmed
tarik
lp
yves
dylan
jan
mail
kris
robin
ian
news
hamid
matthias
ivan
uucp
vladimir
ben
azeddine
proxy
abiy
mike
eric
www-data
david
kevin2
kamel
backup
chahid
kenzo
ischa
list
stef
aaron
bart
irc
joeri
lorenzo
omer
gnats
glenn
jens
kurt
nobody
yannick
ruben
steve
libuuid
christof
jelle
constantin
Debian-exim
george
stefaan
sam2
statd
joost
marc
bjorn
sshd
arno
thomas
ronald
308
naomi
matthias2
bram
fabrice
chimene
messagebus
roger
frank
toon
rinus
eddy
bram2
keith
jesse
frederick
hans
dries
steve2
tomas
johan
tom2standard file permissions
32.1.3. chgrp
You can change the group owner of a file using the chgrp command.
root@rhel65:/home/paul/owners# ls -l file2
-rw-r--r--. 1 root tennis 185 Apr 8 18:46 file2
root@rhel65:/home/paul/owners# chgrp snooker file2
root@rhel65:/home/paul/owners# ls -l file2
-rw-r--r--. 1 root snooker 185 Apr 8 18:46 file2
root@rhel65:/home/paul/owners#
32.1.4. chown
The user owner of a file can be changed with chown command.
root@laika:/home/paul#
-rw-r--r-- 1 root paul
root@laika:/home/paul#
root@laika:/home/paul#
-rw-r--r-- 1 paul paul
ls -l FileForPaul
0 2008-08-06 14:11 FileForPaul
chown paul FileForPaul
ls -l FileForPaul
0 2008-08-06 14:11 FileForPaul
You can also use chown to change both the user owner and the group owner.
root@laika:/home/paul# ls -l FileForPaul
-rw-r--r-- 1 paul paul 0 2008-08-06 14:11 FileForPaul
root@laika:/home/paul# chown root:project42 FileForPaul
root@laika:/home/paul# ls -l FileForPaul
-rw-r--r-- 1 root project42 0 2008-08-06 14:11 FileForPaul
309standard file permissions
32.2. list of special files
When you use ls -l, for each file you can see ten characters before the user and group owner.
The first character tells us the type of file. Regular files get a -, directories get a d, symbolic
links are shown with an l, pipes get a p, character devices a c, block devices a b, and sockets
an s.
Table 32.1. Unix special files
first character file type
- normal file
d directory
l symbolic link
p named pipe
b block device
c character device
s socket
Below a screenshot of a character device (the console) and a block device (the hard disk).
paul@debian6lt~$ ls -ld /dev/console /dev/sda
crw-------
1 root root 5, 1 Mar 15 12:45 /dev/console
brw-rw----
1 root disk 8, 0 Mar 15 12:45 /dev/sda
And here you can see a directory, a regular file and a symbolic link.
paul@debian6lt~$ ls
drwxr-xr-x 128 root
-rw-r--r--
1 root
lrwxrwxrwx
1 root
-ld /etc /etc/hosts /etc/motd
root 12288 Mar 15 18:34 /etc
root
372 Dec 10 17:36 /etc/hosts
root
13 Dec 5 10:36 /etc/motd -> /var/run/motd
310standard file permissions
32.3. permissions
32.3.1. rwx
The nine characters following the file type denote the permissions in three triplets. A
permission can be r for read access, w for write access, and x for execute. You need the r
permission to list (ls) the contents of a directory. You need the x permission to enter (cd) a
directory. You need the w permission to create files in or remove files from a directory.
Table 32.2. standard Unix file permissions
permission on a file on a directory
r (read) read file contents (cat) read directory contents (ls)
w (write) change file contents (vi) create files in (touch)
x (execute) execute the file enter the directory (cd)
32.3.2. three sets of rwx
We already know that the output of ls -l starts with ten characters for each file. This
screenshot shows a regular file (because the first character is a - ).
paul@RHELv4u4:~/test$ ls -l proc42.bash
-rwxr-xr-- 1 paul proj 984 Feb 6 12:01 proc42.bash
Below is a table describing the function of all ten characters.
Table 32.3. Unix file permissions position
position characters function
1 - this is a regular file
2-4 rwx permissions for the user owner
5-7 r-x permissions for the group owner
8-10 r-- permissions for others
When you are the user owner of a file, then the user owner permissions apply to you. The
rest of the permissions have no influence on your access to the file.
When you belong to the group that is the group owner of a file, then the group owner
permissions apply to you. The rest of the permissions have no influence on your access to
the file.
When you are not the user owner of a file and you do not belong to the group owner, then
the others permissions apply to you. The rest of the permissions have no influence on your
access to the file.
311standard file permissions
32.3.3. permission examples
Some example combinations on files and directories are seen in this screenshot. The name
of the file explains the permissions.
paul@laika:~/perms$ ls
total 12K
drwxr-xr-x 2 paul paul
-rwxrwxrwx 1 paul paul
-r--r----- 1 paul paul
-rwxrwx--- 1 paul paul
dr-xr-x--- 2 paul paul
dr-x------ 2 paul paul
paul@laika:~/perms$
-lh
4.0K
0
0
0
4.0K
4.0K
2007-02-07
2007-02-07
2007-02-07
2007-02-07
2007-02-07
2007-02-07
22:26
22:21
22:21
22:21
22:25
22:25
AllEnter_UserCreateDelete
EveryoneFullControl.txt
OnlyOwnersRead.txt
OwnersAll_RestNothing.txt
UserAndGroupEnter
OnlyUserEnter
To summarise, the first rwx triplet represents the permissions for the user owner. The
second triplet corresponds to the group owner; it specifies permissions for all members
of that group. The third triplet defines permissions for all other users that are not the user
owner and are not a member of the group owner.
312standard file permissions
32.3.4. setting permissions (chmod)
Permissions can be changed with chmod. The first example gives the user owner execute
permissions.
paul@laika:~/perms$ ls -l permissions.txt
-rw-r--r-- 1 paul paul 0 2007-02-07 22:34 permissions.txt
paul@laika:~/perms$ chmod u+x permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rwxr--r-- 1 paul paul 0 2007-02-07 22:34 permissions.txt
This example removes the group owners read permission.
paul@laika:~/perms$ chmod g-r permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rwx---r-- 1 paul paul 0 2007-02-07 22:34 permissions.txt
This example removes the others read permission.
paul@laika:~/perms$ chmod o-r permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rwx------ 1 paul paul 0 2007-02-07 22:34 permissions.txt
This example gives all of them the write permission.
paul@laika:~/perms$ chmod a+w permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rwx-w--w- 1 paul paul 0 2007-02-07 22:34 permissions.txt
You don't even have to type the a.
paul@laika:~/perms$ chmod +x permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rwx-wx-wx 1 paul paul 0 2007-02-07 22:34 permissions.txt
You can also set explicit permissions.
paul@laika:~/perms$ chmod u=rw permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rw--wx-wx 1 paul paul 0 2007-02-07 22:34 permissions.txt
Feel free to make any kind of combination.
paul@laika:~/perms$ chmod u=rw,g=rw,o=r permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rw-rw-r-- 1 paul paul 0 2007-02-07 22:34 permissions.txt
Even fishy combinations are accepted by chmod.
paul@laika:~/perms$ chmod u=rwx,ug+rw,o=r permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rwxrw-r-- 1 paul paul 0 2007-02-07 22:34 permissions.txt
313standard file permissions
32.3.5. setting octal permissions
Most Unix administrators will use the old school octal system to talk about and set
permissions. Look at the triplet bitwise, equating r to 4, w to 2, and x to 1.
Table 32.4. Octal permissions
binary octal permission
000 0 ---
001 1 --x
010 2 -w-
011 3 -wx
100 4 r--
101 5 r-x
110 6 rw-
111 7 rwx
This makes 777 equal to rwxrwxrwx and by the same logic, 654 mean rw-r-xr-- . The chmod
command will accept these numbers.
paul@laika:~/perms$ chmod 777 permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rwxrwxrwx 1 paul paul 0 2007-02-07 22:34 permissions.txt
paul@laika:~/perms$ chmod 664 permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rw-rw-r-- 1 paul paul 0 2007-02-07 22:34 permissions.txt
paul@laika:~/perms$ chmod 750 permissions.txt
paul@laika:~/perms$ ls -l permissions.txt
-rwxr-x--- 1 paul paul 0 2007-02-07 22:34 permissions.txt
314standard file permissions
32.3.6. umask
When creating a file or directory, a set of default permissions are applied. These default
permissions are determined by the umask. The umask specifies permissions that you do
not want set on by default. You can display the umask with the umask command.
[Harry@RHEL4b
0002
[Harry@RHEL4b
[Harry@RHEL4b
-rw-rw-r-- 1
[Harry@RHEL4b
~]$ umask
~]$ touch test
~]$ ls -l test
Harry Harry 0 Jul 24 06:03 test
~]$
As you can also see, the file is also not executable by default. This is a general security
feature among Unixes; newly created files are never executable by default. You have to
explicitly do a chmod +x to make a file executable. This also means that the 1 bit in the
umask has no meaning--a umask of 0022 is the same as 0033.
32.3.7. mkdir -m
When creating directories with mkdir you can use the -m option to set the mode. This
screenshot explains.
paul@debian5~$ mkdir -m 700 MyDir
paul@debian5~$ mkdir -m 777 Public
paul@debian5~$ ls -dl MyDir/ Public/
drwx------ 2 paul paul 4096 2011-10-16 19:16 MyDir/
drwxrwxrwx 2 paul paul 4096 2011-10-16 19:16 Public/
32.3.8. cp -p
To preserve permissions and time stamps from source files, use cp -p.
paul@laika:~/perms$ cp file* cp
paul@laika:~/perms$ cp -p file* cpp
paul@laika:~/perms$ ll *
-rwx------ 1 paul paul
0 2008-08-25 13:26 file33
-rwxr-x--- 1 paul paul
0 2008-08-25 13:26 file42
cp:
total 0
-rwx------ 1 paul paul 0 2008-08-25 13:34 file33
-rwxr-x--- 1 paul paul 0 2008-08-25 13:34 file42
cpp:
total 0
-rwx------ 1 paul paul 0 2008-08-25 13:26 file33
-rwxr-x--- 1 paul paul 0 2008-08-25 13:26 file42
315standard file permissions
32.4. practice: standard file permissions
1. As normal user, create a directory ~/permissions. Create a file owned by yourself in there.
2. Copy a file owned by root from /etc/ to your permissions dir, who owns this file now ?
3. As root, create a file in the users ~/permissions directory.
4. As normal user, look at who owns this file created by root.
5. Change the ownership of all files in ~/permissions to yourself.
6. Make sure you have all rights to these files, and others can only read.
7. With chmod, is 770 the same as rwxrwx--- ?
8. With chmod, is 664 the same as r-xr-xr-- ?
9. With chmod, is 400 the same as r-------- ?
10. With chmod, is 734 the same as rwxr-xr-- ?
11a. Display the umask in octal and in symbolic form.
11b. Set the umask to 077, but use the symbolic format to set it. Verify that this works.
12. Create a file as root, give only read to others. Can a normal user read this file ? Test
writing to this file with vi.
13a. Create a file as normal user, give only read to others. Can another normal user read this
file ? Test writing to this file with vi.
13b. Can root read this file ? Can root write to this file with vi ?
14. Create a directory that belongs to a group, where every member of that group can read
and write to files, and create files. Make sure that people can only delete their own files.
316standard file permissions
32.5. solution: standard file permissions
1. As normal user, create a directory ~/permissions. Create a file owned by yourself in there.
mkdir ~/permissions ; touch ~/permissions/myfile.txt
2. Copy a file owned by root from /etc/ to your permissions dir, who owns this file now ?
cp /etc/hosts ~/permissions/
The copy is owned by you.
3. As root, create a file in the users ~/permissions directory.
(become root)# touch /home/username/permissions/rootfile
4. As normal user, look at who owns this file created by root.
ls -l ~/permissions
The file created by root is owned by root.
5. Change the ownership of all files in ~/permissions to yourself.
chown user ~/permissions/*
You cannot become owner of the file that belongs to root.
6. Make sure you have all rights to these files, and others can only read.
chmod 644 (on files)
chmod 755 (on directories)
7. With chmod, is 770 the same as rwxrwx--- ?
yes
8. With chmod, is 664 the same as r-xr-xr-- ?
No
9. With chmod, is 400 the same as r-------- ?
yes
10. With chmod, is 734 the same as rwxr-xr-- ?
no
11a. Display the umask in octal and in symbolic form.
umask ; umask -S
11b. Set the umask to 077, but use the symbolic format to set it. Verify that this works.
umask -S u=rwx,go=
317standard file permissions
12. Create a file as root, give only read to others. Can a normal user read this file ? Test
writing to this file with vi.
(become root)
# echo hello > /home/username/root.txt
# chmod 744 /home/username/root.txt
(become user)
vi ~/root.txt
13a. Create a file as normal user, give only read to others. Can another normal user read this
file ? Test writing to this file with vi.
echo hello > file ; chmod 744 file
Yes, others can read this file
13b. Can root read this file ? Can root write to this file with vi ?
Yes, root can read and write to this file. Permissions do not apply to root.
14. Create a directory that belongs to a group, where every member of that group can read
and write to files, and create files. Make sure that people can only delete their own files.
mkdir /home/project42 ; groupadd project42
chgrp project42 /home/project42 ; chmod 775 /home/project42
You can not yet do the last part of this exercise...
318Chapter 33. advanced file
permissions
319advanced file permissions
33.1. sticky bit on directory
You can set the sticky bit on a directory to prevent users from removing files that they do
not own as a user owner. The sticky bit is displayed at the same location as the x permission
for others. The sticky bit is represented by a t (meaning x is also there) or a T (when there
is no x for others).
root@RHELv4u4:~# mkdir /project55
root@RHELv4u4:~# ls -ld /project55
drwxr-xr-x 2 root root 4096 Feb 7 17:38 /project55
root@RHELv4u4:~# chmod +t /project55/
root@RHELv4u4:~# ls -ld /project55
drwxr-xr-t 2 root root 4096 Feb 7 17:38 /project55
root@RHELv4u4:~#
The sticky bit can also be set with octal permissions, it is binary 1 in the first of four triplets.
root@RHELv4u4:~# chmod 1775 /project55/
root@RHELv4u4:~# ls -ld /project55
drwxrwxr-t 2 root root 4096 Feb 7 17:38 /project55
root@RHELv4u4:~#
You will typically find the sticky bit on the /tmp directory.
root@barry:~# ls -ld /tmp
drwxrwxrwt 6 root root 4096 2009-06-04 19:02 /tmp
33.2. setgid bit on directory
setgid can be used on directories to make sure that all files inside the directory are owned
by the group owner of the directory. The setgid bit is displayed at the same location as the x
permission for group owner. The setgid bit is represented by an s (meaning x is also there)
or a S (when there is no x for the group owner). As this example shows, even though root
does not belong to the group proj55, the files created by root in /project55 will belong to
proj55 since the setgid is set.
root@RHELv4u4:~# groupadd proj55
root@RHELv4u4:~# chown root:proj55 /project55/
root@RHELv4u4:~# chmod 2775 /project55/
root@RHELv4u4:~# touch /project55/fromroot.txt
root@RHELv4u4:~# ls -ld /project55/
drwxrwsr-x 2 root proj55 4096 Feb 7 17:45 /project55/
root@RHELv4u4:~# ls -l /project55/
total 4
-rw-r--r-- 1 root proj55 0 Feb 7 17:45 fromroot.txt
root@RHELv4u4:~#
You can use the find command to find all setgid directories.
paul@laika:~$ find / -type d -perm -2000 2> /dev/null
/var/log/mysql
/var/log/news
/var/local
...
320advanced file permissions
33.3. setgid and setuid on regular files
These two permissions cause an executable file to be executed with the permissions of the
file owner instead of the executing owner. This means that if any user executes a program
that belongs to the root user, and the setuid bit is set on that program, then the program
runs as root. This can be dangerous, but sometimes this is good for security.
Take the example of passwords; they are stored in /etc/shadow which is only readable by
root. (The root user never needs permissions anyway.)
root@RHELv4u4:~# ls -l /etc/shadow
-r-------- 1 root root 1260 Jan 21 07:49 /etc/shadow
Changing your password requires an update of this file, so how can normal non-root users
do this? Let's take a look at the permissions on the /usr/bin/passwd.
root@RHELv4u4:~# ls -l /usr/bin/passwd
-r-s--x--x 1 root root 21200 Jun 17 2005 /usr/bin/passwd
When running the passwd program, you are executing it with root credentials.
You can use the find command to find all setuid programs.
paul@laika:~$ find /usr/bin -type f -perm -04000
/usr/bin/arping
/usr/bin/kgrantpty
/usr/bin/newgrp
/usr/bin/chfn
/usr/bin/sudo
/usr/bin/fping6
/usr/bin/passwd
/usr/bin/gpasswd
...
In most cases, setting the setuid bit on executables is sufficient. Setting the setgid bit will
result in these programs to run with the credentials of their group owner.
33.4. setuid on sudo
The sudo binary has the setuid bit set, so any user can run it with the effective userid of root.
paul@rhel65:~$ ls -l $(which sudo)
---s--x--x. 1 root root 123832 Oct
paul@rhel65:~$
7
2013 /usr/bin/sudo
321advanced file permissions
33.5. practice: sticky, setuid and setgid bits
1a. Set up a directory, owned by the group sports.
1b. Members of the sports group should be able to create files in this directory.
1c. All files created in this directory should be group-owned by the sports group.
1d. Users should be able to delete only their own user-owned files.
1e. Test that this works!
2. Verify the permissions on /usr/bin/passwd. Remove the setuid, then try changing your
password as a normal user. Reset the permissions back and try again.
3. If time permits (or if you are waiting for other students to finish this practice), read about
file attributes in the man page of chattr and lsattr. Try setting the i attribute on a file and
test that it works.
322advanced file permissions
33.6. solution: sticky, setuid and setgid bits
1a. Set up a directory, owned by the group sports.
groupadd sports
mkdir /home/sports
chown root:sports /home/sports
1b. Members of the sports group should be able to create files in this directory.
chmod 770 /home/sports
1c. All files created in this directory should be group-owned by the sports group.
chmod 2770 /home/sports
1d. Users should be able to delete only their own user-owned files.
chmod +t /home/sports
1e. Test that this works!
Log in with different users (group members and others and root), create files and watch the
permissions. Try changing and deleting files...
2. Verify the permissions on /usr/bin/passwd. Remove the setuid, then try changing your
password as a normal user. Reset the permissions back and try again.
root@deb503:~# ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 31704 2009-11-14 15:41 /usr/bin/passwd
root@deb503:~# chmod 755 /usr/bin/passwd
root@deb503:~# ls -l /usr/bin/passwd
-rwxr-xr-x 1 root root 31704 2009-11-14 15:41 /usr/bin/passwd
A normal user cannot change password now.
root@deb503:~# chmod 4755 /usr/bin/passwd
root@deb503:~# ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root 31704 2009-11-14 15:41 /usr/bin/passwd
3. If time permits (or if you are waiting for other students to finish this practice), read about
file attributes in the man page of chattr and lsattr. Try setting the i attribute on a file and
test that it works.
paul@laika:~$ sudo su -
[sudo] password for paul:
root@laika:~# mkdir attr
root@laika:~# cd attr/
root@laika:~/attr# touch file42
root@laika:~/attr# lsattr
------------------ ./file42
root@laika:~/attr# chattr +i file42
323advanced file permissions
root@laika:~/attr# lsattr
----i------------- ./file42
root@laika:~/attr# rm -rf file42
rm: cannot remove `file42': Operation not permitted
root@laika:~/attr# chattr -i file42
root@laika:~/attr# rm -rf file42
root@laika:~/attr#
324Chapter 34. access control lists
Standard Unix permissions might not be enough for some organisations. This chapter
introduces access control lists or acl's to further protect files and directories.
325access control lists
34.1. acl in /etc/fstab
File systems that support access control lists, or acls, have to be mounted with the acl
option listed in /etc/fstab. In the example below, you can see that the root file system has
acl support, whereas /home/data does not.
root@laika:~# tail -4 /etc/fstab
/dev/sda1
/
ext3
/dev/sdb2
/home/data
auto
pasha:/home/r
/home/pasha
nfs
wolf:/srv/data
/home/wolf
nfs
acl,relatime
noacl,defaults
defaults
defaults
0
0
0
0
1
0
0
0
34.2. getfacl
Reading acls can be done with /usr/bin/getfacl. This screenshot shows how to read the acl
of file33 with getfacl.
paul@laika:~/test$ getfacl file33
# file: file33
# owner: paul
# group: paul
user::rw-
group::r--
mask::rwx
other::r--
34.3. setfacl
Writing or changing acls can be done with /usr/bin/setfacl. These screenshots show how
to change the acl of file33 with setfacl.
First we add user sandra with octal permission 7 to the acl.
paul@laika:~/test$ setfacl -m u:sandra:7 file33
Then we add the group tennis with octal permission 6 to the acl of the same file.
paul@laika:~/test$ setfacl -m g:tennis:6 file33
The result is visible with getfacl.
paul@laika:~/test$ getfacl file33
# file: file33
# owner: paul
# group: paul
user::rw-
user:sandra:rwx
group::r--
group:tennis:rw-
mask::rwx
other::r--
326access control lists
34.4. remove an acl entry
The -x option of the setfacl command will remove an acl entry from the targeted file.
paul@laika:~/test$
paul@laika:~/test$
user:sandra:rwx
paul@laika:~/test$
paul@laika:~/test$
setfacl -m u:sandra:7 file33
getfacl file33 | grep sandra
setfacl -x sandra file33
getfacl file33 | grep sandra
Note that omitting the u or g when defining the acl for an account will default it to a user
account.
34.5. remove the complete acl
The -b option of the setfacl command will remove the acl from the targeted file.
paul@laika:~/test$ setfacl -b file33
paul@laika:~/test$ getfacl file33
# file: file33
# owner: paul
# group: paul
user::rw-
group::r--
other::r--
34.6. the acl mask
The acl mask defines the maximum effective permissions for any entry in the acl. This
mask is calculated every time you execute the setfacl or chmod commands.
You can prevent the calculation by using the --no-mask switch.
paul@laika:~/test$ setfacl --no-mask -m u:sandra:7 file33
paul@laika:~/test$ getfacl file33
# file: file33
# owner: paul
# group: paul
user::rw-
user:sandra:rwx
#effective:rw-
group::r--
mask::rw-
other::r--
327access control lists
34.7. eiciel
Desktop users might want to use eiciel to manage acls with a graphical tool.
You will need to install eiciel and nautilus-actions to have an extra tab in nautilus to
manage acls.
paul@laika:~$ sudo aptitude install eiciel nautilus-actions
328Chapter 35. file links
An average computer using Linux has a file system with many hard links and symbolic
links.
To understand links in a file system, you first have to understand what an inode is.
329file links
35.1. inodes
35.1.1. inode contents
An inode is a data structure that contains metadata about a file. When the file system stores
a new file on the hard disk, it stores not only the contents (data) of the file, but also extra
properties like the name of the file, the creation date, its permissions, the owner of the file,
and more. All this information (except the name of the file and the contents of the file) is
stored in the inode of the file.
The ls -l command will display some of the inode contents, as seen in this screenshot.
root@rhel53 ~# ls -ld /home/project42/
drwxr-xr-x 4 root pro42 4.0K Mar 27 14:29 /home/project42/
35.1.2. inode table
The inode table contains all of the inodes and is created when you create the file system
(with mkfs). You can use the df -i command to see how many inodes are used and free on
mounted file systems.
root@rhel53 ~# df -i
Filesystem
Inodes
IUsed
IFree IUse% Mounted on
/dev/mapper/VolGroup00-LogVol00
4947968 115326 4832642
3% /
/dev/hda1
26104
45
26059
1% /boot
tmpfs
64417
1
64416
1% /dev/shm
/dev/sda1
262144
2207 259937
1% /home/project42
/dev/sdb1
74400
5519
68881
8% /home/project33
/dev/sdb5
0
0
0
- /home/sales
/dev/sdb6
100744
11 100733
1% /home/research
In the df -i screenshot above you can see the inode usage for several mounted file systems.
You don't see numbers for /dev/sdb5 because it is a fat file system.
35.1.3. inode number
Each inode has a unique number (the inode number). You can see the inode numbers with
the ls -li command.
paul@RHELv4u4:~/test$ touch file1
paul@RHELv4u4:~/test$ touch file2
paul@RHELv4u4:~/test$ touch file3
paul@RHELv4u4:~/test$ ls -li
total 12
817266 -rw-rw-r-- 1 paul paul 0 Feb
817267 -rw-rw-r-- 1 paul paul 0 Feb
817268 -rw-rw-r-- 1 paul paul 0 Feb
paul@RHELv4u4:~/test$
5 15:38 file1
5 15:38 file2
5 15:38 file3
These three files were created one after the other and got three different inodes (the first
column). All the information you see with this ls command resides in the inode, except for
the filename (which is contained in the directory).
330file links
35.1.4. inode and file contents
Let's put some data in one of the files.
paul@RHELv4u4:~/test$ ls -li
total 16
817266 -rw-rw-r-- 1 paul paul 0 Feb
817270 -rw-rw-r-- 1 paul paul 92 Feb
817268 -rw-rw-r-- 1 paul paul 0 Feb
paul@RHELv4u4:~/test$ cat file2
It is winter now and it is very cold.
We do not like the cold, we prefer hot
paul@RHELv4u4:~/test$
5 15:38 file1
5 15:42 file2
5 15:38 file3
summer nights.
The data that is displayed by the cat command is not in the inode, but somewhere else on
the disk. The inode contains a pointer to that data.
35.2. about directories
35.2.1. a directory is a table
A directory is a special kind of file that contains a table which maps filenames to inodes.
Listing our current directory with ls -ali will display the contents of the directory file.
paul@RHELv4u4:~/test$
total 32
817262 drwxrwxr-x
2
800768 drwx------ 16
817266 -rw-rw-r--
1
817270 -rw-rw-r--
1
817268 -rw-rw-r--
1
paul@RHELv4u4:~/test$
ls -ali
paul
paul
paul
paul
paul
paul 4096 Feb
paul 4096 Feb
paul
0 Feb
paul
92 Feb
paul
0 Feb
5
5
5
5
5
15:42
15:42
15:38
15:42
15:38
.
..
file1
file2
file3
35.2.2. . and ..
You can see five names, and the mapping to their five inodes. The dot . is a mapping to itself,
and the dotdot .. is a mapping to the parent directory. The three other names are mappings
to different inodes.
331file links
35.3. hard links
35.3.1. creating hard links
When we create a hard link to a file with ln, an extra entry is added in the directory. A new
file name is mapped to an existing inode.
paul@RHELv4u4:~/test$ ln file2 hardlink_to_file2
paul@RHELv4u4:~/test$ ls -li
total 24
817266 -rw-rw-r-- 1 paul paul 0 Feb 5 15:38 file1
817270 -rw-rw-r-- 2 paul paul 92 Feb 5 15:42 file2
817268 -rw-rw-r-- 1 paul paul 0 Feb 5 15:38 file3
817270 -rw-rw-r-- 2 paul paul 92 Feb 5 15:42 hardlink_to_file2
paul@RHELv4u4:~/test$
Both files have the same inode, so they will always have the same permissions and the same
owner. Both files will have the same content. Actually, both files are equal now, meaning
you can safely remove the original file, the hardlinked file will remain. The inode contains
a counter, counting the number of hard links to itself. When the counter drops to zero, then
the inode is emptied.
35.3.2. finding hard links
You can use the find command to look for files with a certain inode. The screenshot below
shows how to search for all filenames that point to inode 817270. Remember that an inode
number is unique to its partition.
paul@RHELv4u4:~/test$ find / -inum 817270 2> /dev/null
/home/paul/test/file2
/home/paul/test/hardlink_to_file2
332file links
35.4. symbolic links
Symbolic links (sometimes called soft links) do not link to inodes, but create a name to
name mapping. Symbolic links are created with ln -s. As you can see below, the symbolic
link gets an inode of its own.
paul@RHELv4u4:~/test$ ln -s file2 symlink_to_file2
paul@RHELv4u4:~/test$ ls -li
total 32
817273 -rw-rw-r-- 1 paul paul 13 Feb 5 17:06 file1
817270 -rw-rw-r-- 2 paul paul 106 Feb 5 17:04 file2
817268 -rw-rw-r-- 1 paul paul
0 Feb 5 15:38 file3
817270 -rw-rw-r-- 2 paul paul 106 Feb 5 17:04 hardlink_to_file2
817267 lrwxrwxrwx 1 paul paul
5 Feb 5 16:55 symlink_to_file2 -> file2
paul@RHELv4u4:~/test$
Permissions on a symbolic link have no meaning, since the permissions of the target apply.
Hard links are limited to their own partition (because they point to an inode), symbolic links
can link anywhere (other file systems, even networked).
35.5. removing links
Links can be removed with rm.
paul@laika:~$
paul@laika:~$
paul@laika:~$
paul@laika:~$
paul@laika:~$
touch data.txt
ln -s data.txt sl_data.txt
ln data.txt hl_data.txt
rm sl_data.txt
rm hl_data.txt
333file links
35.6. practice : links
1. Create two files named winter.txt and summer.txt, put some text in them.
2. Create a hard link to winter.txt named hlwinter.txt.
3. Display the inode numbers of these three files, the hard links should have the same inode.
4. Use the find command to list the two hardlinked files
5. Everything about a file is in the inode, except two things : name them!
6. Create a symbolic link to summer.txt called slsummer.txt.
7. Find all files with inode number 2. What does this information tell you ?
8. Look at the directories /etc/init.d/ /etc/rc2.d/ /etc/rc3.d/ ... do you see the links ?
9. Look in /lib with ls -l...
10. Use find to look in your home directory for regular files that do not(!) have one hard link.
334file links
35.7. solution : links
1. Create two files named winter.txt and summer.txt, put some text in them.
echo cold > winter.txt ; echo hot > summer.txt
2. Create a hard link to winter.txt named hlwinter.txt.
ln winter.txt hlwinter.txt
3. Display the inode numbers of these three files, the hard links should have the same inode.
ls -li winter.txt summer.txt hlwinter.txt
4. Use the find command to list the two hardlinked files
find . -inum xyz #replace xyz with the inode number
5. Everything about a file is in the inode, except two things : name them!
The name of the file is in a directory, and the contents is somewhere on the disk.
6. Create a symbolic link to summer.txt called slsummer.txt.
ln -s summer.txt slsummer.txt
7. Find all files with inode number 2. What does this information tell you ?
It tells you there is more than one inode table (one for every formatted partition + virtual
file systems)
8. Look at the directories /etc/init.d/ /etc/rc.d/ /etc/rc3.d/ ... do you see the links ?
ls -l /etc/init.d
ls -l /etc/rc2.d
ls -l /etc/rc3.d
9. Look in /lib with ls -l...
ls -l /lib
10. Use find to look in your home directory for regular files that do not(!) have one hard link.
find ~ ! -links 1 -type f
335Part X. AppendicesTable of Contents
344Appendix A. keyboard settings
A.1. about keyboard layout
Many people (like US-Americans) prefer the default US-qwerty keyboard layout. So when
you are not from the USA and want a local keyboard layout on your system, then the best
practice is to select this keyboard at installation time. Then the keyboard layout will always
be correct. Also, whenever you use ssh to remotely manage a Linux system, your local
keyboard layout will be used, independent of the server keyboard configuration. So you will
not find much information on changing keyboard layout on the fly on linux, because not
many people need it. Below are some tips to help you.
A.2. X Keyboard Layout
This is the relevant portion in /etc/X11/xorg.conf, first for Belgian azerty, then for US-
qwerty.
[paul@RHEL5 ~]$ grep -i xkb /etc/X11/xorg.conf
Option
"XkbModel" "pc105"
Option
"XkbLayout" "be"
[paul@RHEL5 ~]$ grep -i xkb /etc/X11/xorg.conf
Option
"XkbModel" "pc105"
Option
"XkbLayout" "us"
When in Gnome or KDE or any other graphical environment, look in the graphical menu in
preferences, there will be a keyboard section to choose your layout. Use the graphical menu
instead of editing xorg.conf.
A.3. shell keyboard layout
When in bash, take a look in the /etc/sysconfig/keyboard file. Below a sample US-qwerty
configuration, followed by a Belgian azerty configuration.
[paul@RHEL5 ~]$ cat /etc/sysconfig/keyboard
KEYBOARDTYPE="pc"
KEYTABLE="us"
[paul@RHEL5 ~]$ cat /etc/sysconfig/keyboard
KEYBOARDTYPE="pc"
KEYTABLE="be-latin1"
The keymaps themselves can be found in /usr/share/keymaps or /lib/kbd/keymaps.
[paul@RHEL5 ~]$ ls -l /lib/kbd/keymaps/
total 52
drwxr-xr-x 2 root root 4096 Apr 1 00:14 amiga
338keyboard settings
drwxr-xr-x
drwxr-xr-x
drwxr-xr-x
drwxr-xr-x
lrwxrwxrwx
drwxr-xr-x
2
8
2
4
1
2
root
root
root
root
root
root
root
root
root
root
root
root
4096
4096
4096
4096
3
4096
Apr
Apr
Apr
Apr
Apr
Apr
1
1
1
1
1
1
00:14
00:14
00:14
00:14
00:14
00:14
339
atari
i386
include
mac
ppc -> mac
sunAppendix B. hardware
B.1. buses
B.1.1. about buses
Hardware components communicate with the Central Processing Unit or cpu over a bus.
The most common buses today are usb, pci, agp, pci-express and pcmcia aka pc-card.
These are all Plag and Play buses.
Older x86 computers often had isa buses, which can be configured using jumpers or dip
switches.
B.1.2. /proc/bus
To list the buses recognised by the Linux kernel on your computer, look at the contents of
the /proc/bus/ directory (screenshot from Ubuntu 7.04 and RHEL4u4 below).
root@laika:~# ls /proc/bus/
input pccard pci usb
[root@RHEL4b ~]# ls /proc/bus/
input pci usb
Can you guess which of these two screenshots was taken on a laptop ?
B.1.3. /usr/sbin/lsusb
To list all the usb devices connected to your system, you could read the contents of /proc/
bus/usb/devices (if it exists) or you could use the more readable output of lsusb, which is
executed here on a SPARC system with Ubuntu.
root@shaka:~# lsusb
Bus 001 Device 002: ID 0430:0100 Sun Microsystems, Inc. 3-button Mouse
Bus 001 Device 003: ID 0430:0005 Sun Microsystems, Inc. Type 6 Keyboard
Bus 001 Device 001: ID 04b0:0136 Nikon Corp. Coolpix 7900 (storage)
root@shaka:~#
B.1.4. /var/lib/usbutils/usb.ids
The /var/lib/usbutils/usb.ids file contains a gzipped list of all known usb devices.
paul@barry:~$ zmore /var/lib/usbutils/usb.ids | head
------> /var/lib/usbutils/usb.ids <------
#
# List of USB ID's
#
# Maintained by Vojtech Pavlik <vojtech@suse.cz>
340hardware
# If you have any new entries, send them to the maintainer.
# The latest version can be obtained from
# http://www.linux-usb.org/usb.ids
#
# $Id: usb.ids,v 1.225 2006/07/13 04:18:02 dbrownell Exp $
B.1.5. /usr/sbin/lspci
To get a list of all pci devices connected, you could take a look at /proc/bus/pci or run lspci
(partial output below).
paul@laika:~$ lspci
...
00:06.0 FireWire (IEEE 1394): Texas Instruments TSB43AB22/A IEEE-139...
00:08.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL-816...
00:09.0 Multimedia controller: Philips Semiconductors SAA7133/SAA713...
00:0a.0 Network controller: RaLink RT2500 802.11g Cardbus/mini-PCI
00:0f.0 RAID bus controller: VIA Technologies, Inc. VIA VT6420 SATA ...
00:0f.1 IDE interface: VIA Technologies, Inc. VT82C586A/B/VT82C686/A...
00:10.0 USB Controller: VIA Technologies, Inc. VT82xxxxx UHCI USB 1....
00:10.1 USB Controller: VIA Technologies, Inc. VT82xxxxx UHCI USB 1....
...
B.2. interrupts
B.2.1. about interrupts
An interrupt request or IRQ is a request from a device to the CPU. A device raises an
interrupt when it requires the attention of the CPU (could be because the device has data
ready to be read by the CPU).
Since the introduction of pci, irq's can be shared among devices.
Interrupt 0 is always reserved for the timer, interrupt 1 for the keyboard. IRQ 2 is used as a
channel for IRQ's 8 to 15, and thus is the same as IRQ 9.
B.2.2. /proc/interrupts
You can see a listing of interrupts on your system in /proc/interrupts.
paul@laika:~$ cat /proc/interrupts
CPU0
CPU1
0: 1320048
555 IO-APIC-edge
1:
10224
7 IO-APIC-edge
7:
0
0 IO-APIC-edge
8:
2
1 IO-APIC-edge
10:
3062
21 IO-APIC-fasteoi
12:
131
2 IO-APIC-edge
15:
47073
0 IO-APIC-edge
18:
0
1 IO-APIC-fasteoi
19:
31056
1 IO-APIC-fasteoi
20:
19042
1 IO-APIC-fasteoi
21:
44052
1 IO-APIC-fasteoi
22:
188352
1 IO-APIC-fasteoi
timer
i8042
parport0
rtc
acpi
i8042
ide1
yenta
libata, ohci1394
eth0
uhci_hcd:usb1, uhci_hcd:usb2,...
ra0
341hardware
23:
24:
632444
1585
1
1
IO-APIC-fasteoi
IO-APIC-fasteoi
nvidia
VIA82XX-MODEM, VIA8237
B.2.3. dmesg
You can also use dmesg to find irq's allocated at boot time.
paul@laika:~$ dmesg | grep "irq 1[45]"
[ 28.930069] ata3: PATA max UDMA/133 cmd 0x1f0 ctl 0x3f6 bmdma 0x2090 irq 14
[ 28.930071] ata4: PATA max UDMA/133 cmd 0x170 ctl 0x376 bmdma 0x2098 irq 15
B.3. io ports
B.3.1. about io ports
Communication in the other direction, from CPU to device, happens through IO ports. The
CPU writes data or control codes to the IO port of the device. But this is not only a one way
communication, the CPU can also use a device's IO port to read status information about the
device. Unlike interrupts, ports cannot be shared!
B.3.2. /proc/ioports
You can see a listing of your system's IO ports via /proc/ioports.
[root@RHEL4b ~]# cat /proc/ioports
0000-001f : dma1
0020-0021 : pic1
0040-0043 : timer0
0050-0053 : timer1
0060-006f : keyboard
0070-0077 : rtc
0080-008f : dma page reg
00a0-00a1 : pic2
00c0-00df : dma2
00f0-00ff : fpu
0170-0177 : ide1
02f8-02ff : serial
...
B.4. dma
B.4.1. about dma
A device that needs a lot of data, interrupts and ports can pose a heavy load on the cpu. With
dma or Direct Memory Access a device can gain (temporary) access to a specific range
of the ram memory.
B.4.2. /proc/dma
Looking at /proc/dma might not give you the information that you want, since it only
contains currently assigned dma channels for isa devices.
342hardware
root@laika:~# cat /proc/dma
1: parport0
4: cascade
pci devices that are using dma are not listed in /proc/dma, in this case dmesg can be useful.
The screenshot below shows that during boot the parallel port received dma channel 1, and
the Infrared port received dma channel 3.
root@laika:~# dmesg | egrep -C 1 'dma 1|dma 3'
[
20.576000] parport: PnPBIOS parport detected.
[
20.580000] parport0: PC-style at 0x378 (0x778), irq 7, dma 1...
[
20.764000] irda_init()
--
[
21.204000] pnp: Device 00:0b activated.
[
21.204000] nsc_ircc_pnp_probe() : From PnP, found firbase 0x2F8...
[
21.204000] nsc-ircc, chip->init
343Appendix C. License
GNU Free Documentation License
Version 1.3, 3 November 2008
Copyright )/ 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.
0. PREAMBLE
The purpose of this License is to make a manual, textbook, or other
functional and useful document "free" in the sense of freedom: to
assure everyone the effective freedom to copy and redistribute it,
with or without modifying it, either commercially or noncommercially.
Secondarily, this License preserves for the author and publisher a way
to get credit for their work, while not being considered responsible
for modifications made by others.
This License is a kind of "copyleft", which means that derivative
works of the document must themselves be free in the same sense. It
complements the GNU General Public License, which is a copyleft
license designed for free software.
We have designed this License in order to use it for manuals for free
software, because free software needs free documentation: a free
program should come with manuals providing the same freedoms that the
software does. But this License is not limited to software manuals; it
can be used for any textual work, regardless of subject matter or
whether it is published as a printed book. We recommend this License
principally for works whose purpose is instruction or reference.
1. APPLICABILITY AND DEFINITIONS
This License applies to any manual or other work, in any medium, that
contains a notice placed by the copyright holder saying it can be
distributed under the terms of this License. Such a notice grants a
world-wide, royalty-free license, unlimited in duration, to use that
work under the conditions stated herein. The "Document", below, refers
to any such manual or work. Any member of the public is a licensee,
and is addressed as "you". You accept the license if you copy, modify
or distribute the work in a way requiring permission under copyright
law.
A "Modified Version" of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.
A "Secondary Section" is a named appendix or a front-matter section of
the Document that deals exclusively with the relationship of the
publishers or authors of the Document to the Document's overall
subject (or to related matters) and contains nothing that could fall
directly within that overall subject. (Thus, if the Document is in
part a textbook of mathematics, a Secondary Section may not explain
any mathematics.) The relationship could be a matter of historical
connection with the subject or with related matters, or of legal,
commercial, philosophical, ethical or political position regarding
them.
The "Invariant Sections" are certain Secondary Sections whose titles
344License
are designated, as being those of Invariant Sections, in the notice
that says that the Document is released under this License. If a
section does not fit the above definition of Secondary then it is not
allowed to be designated as Invariant. The Document may contain zero
Invariant Sections. If the Document does not identify any Invariant
Sections then there are none.
The "Cover Texts" are certain short passages of text that are listed,
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
the Document is released under this License. A Front-Cover Text may be
at most 5 words, and a Back-Cover Text may be at most 25 words.
A "Transparent" copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the
general public, that is suitable for revising the document
straightforwardly with generic text editors or (for images composed of
pixels) generic paint programs or (for drawings) some widely available
drawing editor, and that is suitable for input to text formatters or
for automatic translation to a variety of formats suitable for input
to text formatters. A copy made in an otherwise Transparent file
format whose markup, or absence of markup, has been arranged to thwart
or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount
of text. A copy that is not "Transparent" is called "Opaque".
Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML
or XML using a publicly available DTD, and standard-conforming simple
HTML, PostScript or PDF designed for human modification. Examples of
transparent image formats include PNG, XCF and JPG. Opaque formats
include proprietary formats that can be read and edited only by
proprietary word processors, SGML or XML for which the DTD and/or
processing tools are not generally available, and the
machine-generated HTML, PostScript or PDF produced by some word
processors for output purposes only.
The "Title Page" means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page. For works in
formats which do not have any title page as such, "Title Page" means
the text near the most prominent appearance of the work's title,
preceding the beginning of the body of the text.
The "publisher" means any person or entity that distributes copies of
the Document to the public.
A section "Entitled XYZ" means a named subunit of the Document whose
title either is precisely XYZ or contains XYZ in parentheses following
text that translates XYZ in another language. (Here XYZ stands for a
specific section name mentioned below, such as "Acknowledgements",
"Dedications", "Endorsements", or "History".) To "Preserve the Title"
of such a section when you modify the Document means that it remains a
section "Entitled XYZ" according to this definition.
The Document may include Warranty Disclaimers next to the notice which
states that this License applies to the Document. These Warranty
Disclaimers are considered to be included by reference in this
License, but only as regards disclaiming warranties: any other
implication that these Warranty Disclaimers may have is void and has
no effect on the meaning of this License.
2. VERBATIM COPYING
You may copy and distribute the Document in any medium, either
345License
commercially or noncommercially, provided that this License, the
copyright notices, and the license notice saying this License applies
to the Document are reproduced in all copies, and that you add no
other conditions whatsoever to those of this License. You may not use
technical measures to obstruct or control the reading or further
copying of the copies you make or distribute. However, you may accept
compensation in exchange for copies. If you distribute a large enough
number of copies you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and
you may publicly display copies.
3. COPYING IN QUANTITY
If you publish printed copies (or copies in media that commonly have
printed covers) of the Document, numbering more than 100, and the
Document's license notice requires Cover Texts, you must enclose the
copies in covers that carry, clearly and legibly, all these Cover
Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
the back cover. Both covers must also clearly and legibly identify you
as the publisher of these copies. The front cover must present the
full title with all words of the title equally prominent and visible.
You may add other material on the covers in addition. Copying with
changes limited to the covers, as long as they preserve the title of
the Document and satisfy these conditions, can be treated as verbatim
copying in other respects.
If the required texts for either cover are too voluminous to fit
legibly, you should put the first ones listed (as many as fit
reasonably) on the actual cover, and continue the rest onto adjacent
pages.
If you publish or distribute Opaque copies of the Document numbering
more than 100, you must either include a machine-readable Transparent
copy along with each Opaque copy, or state in or with each Opaque copy
a computer-network location from which the general network-using
public has access to download using public-standard network protocols
a complete Transparent copy of the Document, free of added material.
If you use the latter option, you must take reasonably prudent steps,
when you begin distribution of Opaque copies in quantity, to ensure
that this Transparent copy will remain thus accessible at the stated
location until at least one year after the last time you distribute an
Opaque copy (directly or through your agents or retailers) of that
edition to the public.
It is requested, but not required, that you contact the authors of the
Document well before redistributing any large number of copies, to
give them a chance to provide you with an updated version of the
Document.
4. MODIFICATIONS
You may copy and distribute a Modified Version of the Document under
the conditions of sections 2 and 3 above, provided that you release
the Modified Version under precisely this License, with the Modified
Version filling the role of the Document, thus licensing distribution
and modification of the Modified Version to whoever possesses a copy
of it. In addition, you must do these things in the Modified Version:
* A. Use in the Title Page (and on the covers, if any) a title
distinct from that of the Document, and from those of previous
versions (which should, if there were any, be listed in the History
section of the Document). You may use the same title as a previous
version if the original publisher of that version gives permission.
346License
* B. List on the Title Page, as authors, one or more persons or
entities responsible for authorship of the modifications in the
Modified Version, together with at least five of the principal authors
of the Document (all of its principal authors, if it has fewer than
five), unless they release you from this requirement.
* C. State on the Title page the name of the publisher of the
Modified Version, as the publisher.
* D. Preserve all the copyright notices of the Document.
* E. Add an appropriate copyright notice for your modifications
adjacent to the other copyright notices.
* F. Include, immediately after the copyright notices, a license
notice giving the public permission to use the Modified Version under
the terms of this License, in the form shown in the Addendum below.
* G. Preserve in that license notice the full lists of Invariant
Sections and required Cover Texts given in the Document's license
notice.
* H. Include an unaltered copy of this License.
* I. Preserve the section Entitled "History", Preserve its Title,
and add to it an item stating at least the title, year, new authors,
and publisher of the Modified Version as given on the Title Page. If
there is no section Entitled "History" in the Document, create one
stating the title, year, authors, and publisher of the Document as
given on its Title Page, then add an item describing the Modified
Version as stated in the previous sentence.
* J. Preserve the network location, if any, given in the Document
for public access to a Transparent copy of the Document, and likewise
the network locations given in the Document for previous versions it
was based on. These may be placed in the "History" section. You may
omit a network location for a work that was published at least four
years before the Document itself, or if the original publisher of the
version it refers to gives permission.
* K. For any section Entitled "Acknowledgements" or "Dedications",
Preserve the Title of the section, and preserve in the section all the
substance and tone of each of the contributor acknowledgements and/or
dedications given therein.
* L. Preserve all the Invariant Sections of the Document,
unaltered in their text and in their titles. Section numbers or the
equivalent are not considered part of the section titles.
* M. Delete any section Entitled "Endorsements". Such a section
may not be included in the Modified Version.
* N. Do not retitle any existing section to be Entitled
"Endorsements" or to conflict in title with any Invariant Section.
* O. Preserve any Warranty Disclaimers.
If the Modified Version includes new front-matter sections or
appendices that qualify as Secondary Sections and contain no material
copied from the Document, you may at your option designate some or all
of these sections as invariant. To do this, add their titles to the
list of Invariant Sections in the Modified Version's license notice.
These titles must be distinct from any other section titles.
You may add a section Entitled "Endorsements", provided it contains
nothing but endorsements of your Modified Version by various
parties"+'for example, statements of peer review or that the text has
been approved by an organization as the authoritative definition of a
standard.
You may add a passage of up to five words as a Front-Cover Text, and a
passage of up to 25 words as a Back-Cover Text, to the end of the list
of Cover Texts in the Modified Version. Only one passage of
Front-Cover Text and one of Back-Cover Text may be added by (or
through arrangements made by) any one entity. If the Document already
includes a cover text for the same cover, previously added by you or
by arrangement made by the same entity you are acting on behalf of,
347License
you may not add another; but you may replace the old one, on explicit
permission from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License
give permission to use their names for publicity for or to assert or
imply endorsement of any Modified Version.
5. COMBINING DOCUMENTS
You may combine the Document with other documents released under this
License, under the terms defined in section 4 above for modified
versions, provided that you include in the combination all of the
Invariant Sections of all of the original documents, unmodified, and
list them all as Invariant Sections of your combined work in its
license notice, and that you preserve all their Warranty Disclaimers.
The combined work need only contain one copy of this License, and
multiple identical Invariant Sections may be replaced with a single
copy. If there are multiple Invariant Sections with the same name but
different contents, make the title of each such section unique by
adding at the end of it, in parentheses, the name of the original
author or publisher of that section if known, or else a unique number.
Make the same adjustment to the section titles in the list of
Invariant Sections in the license notice of the combined work.
In the combination, you must combine any sections Entitled "History"
in the various original documents, forming one section Entitled
"History"; likewise combine any sections Entitled "Acknowledgements",
and any sections Entitled "Dedications". You must delete all sections
Entitled "Endorsements".
6. COLLECTIONS OF DOCUMENTS
You may make a collection consisting of the Document and other
documents released under this License, and replace the individual
copies of this License in the various documents with a single copy
that is included in the collection, provided that you follow the rules
of this License for verbatim copying of each of the documents in all
other respects.
You may extract a single document from such a collection, and
distribute it individually under this License, provided you insert a
copy of this License into the extracted document, and follow this
License in all other respects regarding verbatim copying of that
document.
7. AGGREGATION WITH INDEPENDENT WORKS
A compilation of the Document or its derivatives with other separate
and independent documents or works, in or on a volume of a storage or
distribution medium, is called an "aggregate" if the copyright
resulting from the compilation is not used to limit the legal rights
of the compilation's users beyond what the individual works permit.
When the Document is included in an aggregate, this License does not
apply to the other works in the aggregate which are not themselves
derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these
copies of the Document, then if the Document is less than one half of
the entire aggregate, the Document's Cover Texts may be placed on
covers that bracket the Document within the aggregate, or the
electronic equivalent of covers if the Document is in electronic form.
Otherwise they must appear on printed covers that bracket the whole
aggregate.
348License
8. TRANSLATION
Translation is considered a kind of modification, so you may
distribute translations of the Document under the terms of section 4.
Replacing Invariant Sections with translations requires special
permission from their copyright holders, but you may include
translations of some or all Invariant Sections in addition to the
original versions of these Invariant Sections. You may include a
translation of this License, and all the license notices in the
Document, and any Warranty Disclaimers, provided that you also include
the original English version of this License and the original versions
of those notices and disclaimers. In case of a disagreement between
the translation and the original version of this License or a notice
or disclaimer, the original version will prevail.
If a section in the Document is Entitled "Acknowledgements",
"Dedications", or "History", the requirement (section 4) to Preserve
its Title (section 1) will typically require changing the actual
title.
9. TERMINATION
You may not copy, modify, sublicense, or distribute the Document
except as expressly provided under this License. Any attempt otherwise
to copy, modify, sublicense, or distribute it is void, and will
automatically terminate your rights under this License.
However, if you cease all violation of this License, then your license
from a particular copyright holder is reinstated (a) provisionally,
unless and until the copyright holder explicitly and finally
terminates your license, and (b) permanently, if the copyright holder
fails to notify you of the violation by some reasonable means prior to
60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, receipt of a copy of some or all of the same material does
not give you any rights to use it.
10. FUTURE REVISIONS OF THIS LICENSE
The Free Software Foundation may publish new, revised versions of the
GNU Free Documentation License from time to time. Such new versions
will be similar in spirit to the present version, but may differ in
detail to address new problems or concerns. See
http://www.gnu.org/copyleft/.
Each version of the License is given a distinguishing version number.
If the Document specifies that a particular numbered version of this
License "or any later version" applies to it, you have the option of
following the terms and conditions either of that specified version or
of any later version that has been published (not as a draft) by the
Free Software Foundation. If the Document does not specify a version
number of this License, you may choose any version ever published (not
as a draft) by the Free Software Foundation. If the Document specifies
349License
that a proxy can decide which future versions of this License can be
used, that proxy's public statement of acceptance of a version
permanently authorizes you to choose that version for the Document.
11. RELICENSING
"Massive Multiauthor Collaboration Site" (or "MMC Site") means any
World Wide Web server that publishes copyrightable works and also
provides prominent facilities for anybody to edit those works. A
public wiki that anybody can edit is an example of such a server. A
"Massive Multiauthor Collaboration" (or "MMC") contained in the site
means any set of copyrightable works thus published on the MMC site.
"CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
license published by Creative Commons Corporation, a not-for-profit
corporation with a principal place of business in San Francisco,
California, as well as future copyleft versions of that license
published by that same organization.
"Incorporate" means to publish or republish a Document, in whole or in
part, as part of another Document.
An MMC is "eligible for relicensing" if it is licensed under this
License, and if all works that were first published under this License
somewhere other than this MMC, and subsequently incorporated in whole
or in part into the MMC, (1) had no cover texts or invariant sections,
and (2) were thus incorporated prior to November 1, 2008.
The operator of an MMC Site may republish an MMC contained in the site
under CC-BY-SA on the same site at any time before August 1, 2009,
provided the MMC is eligible for relicensing.
350Index
Symbols
; (shell), 136
!! (shell), 156
! (bash history), 156
! (file globbing), 163
? (file globbing), 162
/, 76, 102
/bin, 103, 128
/bin/bash, 125, 292
/bin/cat, 103
/bin/csh, 125
/bin/date, 103
/bin/ksh, 125, 292
/bin/rm, 129
/bin/sh, 125
/boot, 105
/boot/grub, 105
/boot/grub/grub.cfg, 105
/boot/grub/grub.conf, 105
/dev, 85, 109
/dev/null, 109, 175
/dev/pts/1, 109
/dev/random, 120
/dev/tty1, 109
/dev/urandom, 119, 121
/dev/zero, 120
/etc, 105
/etc/bashrc, 293
/etc/default/useradd, 276
/etc/fstab, 326
/etc/group, 299, 308
/etc/gshadow, 301
/etc/hosts, 120
/etc/init.d/, 105
/etc/inputrc, 292
/etc/login.defs, 286
/etc/passwd, 191, 275, 278, 287, 287, 308
/etc/profile, 292
/etc/resolv.conf, 120
/etc/shadow, 283, 285, 321
/etc/shells, 235, 278
/etc/skel, 105, 277
/etc/sudoers, 269, 270
/etc/sysconfig, 105
/etc/sysconfig/firstboot, 106
/etc/sysconfig/harddisks, 106
/etc/sysconfig/hwconf, 106
/etc/sysconfig/keyboard, 106
/etc/X11/xorg.conf, 105
/export, 107
/home, 107
/lib, 104
/lib/kbd/keymaps/, 106
/lib/modules, 104
/lib32, 104
/lib64, 104
/media, 107
/opt, 104
/proc, 85, 109
/proc/bus, 340
/proc/bus/pci, 341
/proc/bus/usb/devices, 340
/proc/cpuinfo, 110
/proc/dma, 342
/proc/interrupts, 112, 341
/proc/ioports, 342
/proc/kcore, 112
/proc/sys, 111
/root, 107
/run, 117
/sbin, 103, 128
/srv, 107
/sys, 113
/tmp, 108, 320
/usr, 114
/usr/bin, 114
/usr/bin/getfacl, 326
/usr/bin/passwd, 321
/usr/bin/setfacl, 326
/usr/include, 114
/usr/lib, 114
/usr/local, 114
/usr/share, 114
/usr/share/games, 115
/usr/share/man, 115
/usr/src, 115
/var, 116
/var/cache, 116
/var/lib, 117
/var/lib/rpm, 117
/var/lib/usbutils/usb.ids, 340
/var/lock, 117
/var/log, 116
/var/log/messages, 116
/var/log/syslog, 116
/var/run, 117
/var/spool, 116
/var/tmp, 117
., 75
.., 75
.. (directory), 331
. (directory), 331
. (shell), 236
.bash_history, 157
.bash_login, 293
.bash_logout, 294
.bash_profile, 292
.bashrc, 292, 293
.exrc, 229
.vimrc, 229
`(backtick), 151
~, 75
351Index
'(single quote), 151
" (double quotes), 127
(( (shell), 256
-- (shell), 237
[ (file globbing), 163
[ (shell), 241
$? (shell variables), 136
$() embedded shell, 151
$ (shell variables), 142
$HISTFILE, 157
$HISTFILESIZE, 157
$HISTSIZE, 157
$LANG, 164
$PATH, 128, 145
$PS1, 76
* (file globbing), 162
\ (backslash), 138
&, 136
&&, 137
#!/bin/bash, 235
#! (shell), 235
# (pound sign), 138
>, 173
>>, 174
>|, 174
||, 137
1>, 175
2>, 175
2>&1, 175
777, 314
A
access control list, 326
acl, 328
acls, 326
agp, 340
AIX, 4
alias(bash), 129
alias(shell), 129
apropos, 72
arguments(shell), 126
B
backticks, 151
base64, 177
bash, 219, 248
bash history, 156
bash -x, 237
binaries, 103
Bourne again shell, 125
BSD, 4
bunzip2, 201
bus, 340
bzcat, 201
bzip2, 199, 201, 201
bzmore, 201
C
cal, 198
case, 258
case sensitive, 85
cat, 96, 182
cd, 75
cd -, 76
CentOS, 7
chage, 286
chgrp(1), 309
chkconfig, 106
chmod, 277, 314
chmod(1), 226, 313
chmod +x, 235, 315
chown, 277
chown(1), 309
chsh(1), 278
comm(1), 188
command line scan, 126
command mode(vi), 223
copyleft, 11
copyright, 10, 10
cp, 88
cp(1), 88
cpu, 340
crypt, 284
csh, 235
Ctrl d, 96
ctrl-r, 157
current directory, 75
cut, 191
cut(1), 184
D
daemon, 72
date, 197
Debian, 7
Dennis Ritchie, 4
devfs, 113
df -i, 330
directory, 331
distribution, 6
distributions, 102
dma, 342
dmesg(1), 342, 343
dumpkeys(1), 106
E
echo, 126
echo(1), 125, 127
echo $-, 152
echo *, 165
Edubuntu, 7
eiciel, 328
ELF, 104
elif, 242
embedding(shell), 151
352Index
env(1), 146, 146
environment variable, 142
EOF, 96, 177
escaping (shell), 165
eval, 256
executables, 103
exit (bash), 157
export, 146
F
Fedora, 7
FHS, 102
file, 85
file(1), 104
file globbing, 161
file ownership, 308
Filesystem Hierarchy Standard, 102
filters, 181
find(1), 196, 320, 321, 332
FireWire, 113
for (bash), 242
FOSS, 10
four freedoms, 11
Free Software, 10
free software, 10
freeware, 10
function (shell), 259
G
gcc(1), 285
getfacl, 326
getopts, 251
GID, 299
glob(7), 162
GNU, 4
gpasswd, 301
GPL, 11
GPLv3, 11
grep, 206, 207, 210
grep(1), 182
grep -i, 182
grep -v, 183
groupadd(1), 299
groupdel(1), 300
groupmod(1), 300
groups, 298
groups(1), 299
gunzip(1), 200
gzip, 200
gzip(1), 200
H
hard link, 332
head(1), 95
here directive, 97
here document, 177
here string, 177
hidden files, 77
HP, 4
HP-UX, 4
http://www.pathname.com/fhs/, 102
I
IBM, 4
id, 267
IEEE 1394, 113
if then else (bash), 242
inode, 329, 332
inode table, 330
insert mode(vi), 223
interrupt, 341
IO Ports, 342
IRQ, 341
isa, 340
K
Ken Thompson, 4
kernel, 104
keymaps(5), 106
Korn shell, 158
Korn Shell, 278
ksh, 158, 235
kudzu, 106
L
less(1), 98
let, 257
Linus Torvalds, 4
Linux Mint, 7
ln, 333
ln(1), 332
loadkeys(1), 106
locate(1), 197
logical AND, 137
logical OR, 137
Logiciel Libre, 10
ls, 77, 311, 330
ls(1), 77, 330, 331
ls -l, 310
lspci, 341
lsusb, 340
M
magic, 85
makewhatis, 73
man(1), 72, 72, 73
mandb(1), 73
man hier, 102
man -k, 72
md5, 285
mkdir, 277
mkdir(1), 79, 315
mkdir -p, 79
mkfs, 330
353Index
more(1), 98
mv, 89
N
noclobber, 174
nounset(shell), 147
O
octal permissions, 314
od(1), 189
OEL, 7
open source, 10
open source definition, 11
open source software, 10
openssl, 284
Oracle Enterprise Linux, 7
owner, 311
P
parent directory, 75
passwd, 283, 283, 284, 286
passwd(1), 73, 321
passwd(5), 73
path, 76, 77
pc-card, 340
pci, 340
pci-express, 340
pcmcia, 340
perl, 212
perldoc, 212
popd, 83
prename, 212
primary group, 276
proprietary, 10
public domain, 10
pushd, 83
pwd, 75
pwd(1), 76
R
random number generator, 120
read, 249
reboot, 157
Red Hat, 7
regular expressions, 158
rename, 90, 212, 213, 214
repository, 6
Richard Stallman, 4
rm, 87
rm(1), 333
rmdir(1), 79
rmdir -p, 80
rm -rf, 87
root, 103, 268, 269, 270, 275
root directory, 102
rpm, 117
S
salt (encryption), 285
Scientific, 7
sed, 190, 215, 216
set, 152
set(shell), 143
set +x, 130
setfacl, 326
setgid, 320, 320
setuid, 237, 321, 321, 321
set -x, 130
she-bang (shell), 235
shell, 291
shell comment, 138
shell embedding, 151
shell escaping, 138
shell expansion, 126, 126
shell functions, 259
shift, 249
shopt, 252
skeleton, 105
sleep, 198
soft link, 333
Solaris, 4
sort, 191
sort(1), 186
source, 236, 250
standard input, 96
standard output, 96
stderr, 172
stdin, 172, 182
stdout, 172, 182
sticky bit, 320
strings(1), 98
su, 268, 268, 287, 301
su -, 145
sudo, 269, 270, 287
sudo su -, 270
Sun, 4
SunOS, 4
superuser, 275
symbolic link, 333
sysfs, 113
System V, 104
T
tab key(bash), 77
tac, 97
tail(1), 95
tee(1), 182
test, 241
time, 199
touch(1), 86
tr, 185
tr(1), 184
type(shell), 128
354Index
U
Ubuntu, 7
umask(1), 315
unalias(bash), 130
uniq, 191
uniq(1), 187
Unix, 4
unset, 152
unset(shell), 143
until (bash), 243
updatedb(1), 197
usb, 113, 340
useradd, 276, 277, 284
useradd(1), 277
useradd -D, 276
userdel(1), 276
usermod, 287, 287, 300
usermod(1), 276
V
vi, 302
vi(1), 222
vigr(1), 302
vim(1), 222
vimtutor(1), 222
vipw, 287
visudo, 269
vrije software, 10
W
w, 267
wc(1), 185
whatis(1), 72
whereis(1), 72
which(1), 128
while (bash), 243
white space(shell), 126
who, 191, 267
whoami, 267
who am i, 267
wild cards, 163
X
X, 105
X Window System, 105
Z
zcat, 200
zmore, 200
355

An A-Z Index of the Windows CMD command line
a:
   ADDUSERS Add or list users to/from a CSV file,
   ADmodcmd Active Directory Bulk Modify,
   ARP      Address Resolution Protocol,
   ASSOC    Change file extension associations,
   ASSOCIAT One step file association,
   AT       Schedule a command to run at a specific time,
   ATTRIB   Change file attributes.
b:
   BCDBOOT  Create or repair a system partition,
   BCDEDIT  Manage Boot Configuration Data,
   BITSADMIN Background Intelligent Transfer Service,
   BOOTCFG  Edit Windows boot settings,
   BROWSTAT Get domain, browser and PDC info.
c:
   CACLS    Change file permissions,
   CALL     Call one batch program from another,
   CERTREQ  Request certificate from a certification authority,
   CERTUTIL Utility for certification authority (CA) files and services,
   CD       Change Directory - move to a specific Folder,
   CHANGE   Change Terminal Server Session properties,
   CHKDSK   Check Disk - check and repair disk problems,
   CHKNTFS  Check the NTFS file system,
   CHOICE   Accept keyboard input to a batch file,
   CIPHER   Encrypt or Decrypt files/folders,
   CleanMgr Automated cleanup of Temp files, recycle bin,
   CLIP     Copy STDIN to the Windows clipboard,
   CLS      Clear the screen,
   CMD      Start a new CMD shell,
   CMDKEY   Manage stored usernames/passwords,
   COLOR    Change colors of the CMD window,
   COMP     Compare the contents of two files or sets of files,
   COMPACT  Compress files or folders on an NTFS partition,
   COMPRESS Compress one or more files,
   CONVERT  Convert a FAT drive to NTFS,
   COPY     Copy one or more files to another location,
   Coreinfo Show the mapping between logical & physical processors,
   CSCcmd   Client-side caching (Offline Files),
   CSVDE    Import or Export Active Directory data. 
d:
   DATE     Display or set the date,
   DEFRAG   Defragment hard drive,
   DEL      Delete one or more files,
   DELPROF  Delete user profiles,
   DELTREE  Delete a folder and all subfolders,
   DevCon   Device Manager Command Line Utility, 
   DIR      Display a list of files and folders,
   DIRQUOTA File Server Resource Manager Disk quotas,
   DIRUSE   Display disk usage,
   DISKPART Disk Administration,
   DISKSHADOW Volume Shadow Copy Service,
   DISKUSE  Show the space used in folders,
   DOSKEY   Edit command line, recall commands, and create macros,
   DriverQuery Display installed device drivers,
   DSACLs   Active Directory ACLs,
   DSAdd    Add items to active directory (user group computer),
   DSGet    View items in active directory (user group computer),
   DSQuery  Search for items in active directory (user group computer),
   DSMod    Modify items in active directory (user group computer),
   DSMove   Move an Active directory Object,
   DSRM     Remove items from Active Directory,
   Dsmgmt   Directory Service Management.
e:
   ECHO     Display message on screen,
   ENDLOCAL End localisation of environment changes in a batch file,
   ERASE    Delete one or more files,
   EVENTCREATE Add a message to the Windows event log,
   EXIT     Quit the current script/routine and set an errorlevel,
   EXPAND   Uncompress CAB files,
   EXPLORER Open Windows Explorer,
   EXTRACT  Uncompress CAB files.
f:
   FC       Compare two files,
   FIND     Search for a text string in a file,
   FINDSTR  Search for strings in files,
   FOR /F   Loop command: against a set of files,
   FOR /F   Loop command: against the results of another command,
   FOR      Loop command: all options Files, Directory, List,
   FORFILES Batch process multiple files,
   FORMAT   Format a disk,
   FREEDISK Check free disk space,
   FSUTIL   File and Volume utilities,
   FTP      File Transfer Protocol,
   FTYPE    File extension file type associations.
g:
   GETMAC   Display the Media Access Control (MAC) address,
   GOTO     Direct a batch program to jump to a labelled line,
   GPRESULT Display Resultant Set of Policy information,
   GPUPDATE Update Group Policy settings.
h:
   HELP     Online Help,
   HOSTNAME Display the host name of the computer.
i
   iCACLS   Change file and folder permissions,
   IEXPRESS Create a self extracting ZIP file archive,
   IF       Conditionally perform a command,
   IFMEMBER Is the current user a member of a group,
   IPCONFIG Configure IP,
   INUSE    Replace files that are in use by the OS.
l:
   LABEL    Edit a disk label,
   LODCTR   Load PerfMon performance counters,
   LOGMAN   Manage Performance Monitor logs,
   LOGOFF   Log a user off,
   LOGTIME  Log the date and time in a file.
m:
   MAKECAB  Create .CAB files,
   MAPISEND Send email from the command line,
   MBSAcli  Baseline Security Analyzer,
   MEM      Display memory usage,
   MD       Create new folders,
   MKLINK   Create a symbolic link (linkd),
   MODE     Configure a system device COM/LPT/CON,
   MORE     Display output, one screen at a time,
   MOUNTVOL Manage a volume mount point,
   MOVE     Move files from one folder to another,
   MOVEUSER Move a user from one domain to another,
   MSG      Send a message,
   MSIEXEC  Microsoft Windows Installer,
   MSINFO32 System Information,
   MSTSC    Terminal Server Connection (Remote Desktop Protocol).
n:
   NET      Manage network resources,
   NETDOM   Domain Manager,
   NETSH    Configure Network Interfaces, Windows Firewall & Remote access,
   NBTSTAT  Display networking statistics (NetBIOS over TCP/IP),
   NETSTAT  Display networking statistics (TCP/IP),
   NLSINFO  Display locale information (reskit),
   NLTEST   Network Location Test (AD),
   NOW      Display the current Date and Time,
   NSLOOKUP Name server lookup,
   NTBACKUP Backup folders to tape,
   NTDSUtil Active Directory Domain Services management,
   NTRIGHTS Edit user account rights,
   NVSPBIND Modify network bindings.
o:
   OPENFILES Query or display open files.
p:
   PATH     Display or set a search path for executable files,
   PATHPING Trace route plus network latency and packet loss,
   PAUSE    Suspend processing of a batch file and display a message,
   PERMS    Show permissions for a user,
   PERFMON  Performance Monitor,
   PING     Test a network connection,
   POPD     Return to a previous directory saved by PUSHD,
   PORTQRY  Display the status of ports and services,
   POWERCFG Configure power settings,
   PRINT    Print a text file,
   PRINTBRM Print queue Backup/Recovery,
   PRNCNFG  Configure or rename a printer,
   PRNMNGR  Add, delete, list printers and printer connections,
   ProcDump Monitor an application for CPU spikes,
   PROMPT   Change the command prompt,
   PsExec     Execute process remotely,
   PsFile     Show files opened remotely,
   PsGetSid   Display the SID of a computer or a user,
   PsInfo     List information about a system,
   PsKill     Kill processes by name or process ID,
   PsList     List detailed information about processes,
   PsLoggedOn Who's logged on (locally or via resource sharing),
   PsLogList  Event log records,
   PsPasswd   Change account password,
   PsPing     Measure network performance,
   PsService  View and control services,
   PsShutdown Shutdown or reboot a computer,
   PsSuspend  Suspend processes,
   PUSHD    Save and then change the current directory.
q:
   QGREP Search file(s) for lines that match a given pattern,
   Query Process / QPROCESS  Display processes,
   Query Session / QWinsta   Display all sessions (TS/Remote Desktop),
   Query TermServer /QAppSrv List all servers (TS/Remote Desktop),
   Query User    / QUSER     Display user sessions (TS/Remote Desktop).
r:
   RASDIAL  Manage RAS connections,
   RASPHONE Manage RAS connections,
   RECOVER  Recover a damaged file from a defective disk,
   REG      Registry: Read, Set, Export, Delete keys and values,
   REGEDIT  Import or export registry settings,
   REGSVR32 Register or unregister a DLL,
   REGINI   Change Registry Permissions,
   REM      Record comments (remarks) in a batch file,
   REN      Rename a file or files,
   REPLACE  Replace or update one file with another,
   Reset Session  Delete a Remote Desktop Session,
   RD       Delete folder(s),
   RMTSHARE Share a folder or a printer,
   ROBOCOPY Robust File and Folder Copy,
   ROUTE    Manipulate network routing tables,
   RUN      Start | RUN commands,
   RUNAS    Execute a program under a different user account,
   RUNDLL32 Run a DLL command (add/remove print connections).
s:
   SC       Service Control,
   SCHTASKS Schedule a command to run at a specific time,
   SET      Display, set, or remove session environment variables,
   SETLOCAL Control the visibility of environment variables,
   SetSPN   Edit Service Principal Names,
   SETX     Set environment variables,
   SFC      System File Checker,
   SHARE    List or edit a file share or print share,
   ShellRunAs Run a command under a different user account,
   SHIFT    Shift the position of batch file parameters,
   SHORTCUT Create a windows shortcut (.LNK file),
   SHUTDOWN Shutdown the computer,
   SIGCHECK Display file version no. VirusTotal status & timestamp,
   SLEEP    Wait for x seconds,
   SLMGR    Software Licensing Management (Vista/2008),
   SORT     Sort input,
   START    Start a program, command or batch file,
   STRINGS  Search for ANSI and UNICODE strings in binary files,
   SUBINACL Edit file and folder Permissions, Ownership and Domain,
   SUBST    Associate a path with a drive letter,
   SYSMON   Monitor and log system activity to the Windows event log,
   SYSTEMINFO List system configuration.
t:
   TAKEOWN  Take ownership of a file,
   TASKLIST List running applications and services,
   TASKKILL End a running process,
   TELNET   Communicate with another host using the TELNET protocol,
   TIME     Display or set the system time,
   TIMEOUT  Delay processing of a batch file,
   TITLE    Set the window title for a CMD.EXE session,
   TLIST    Task list with full path,
   TOUCH    Change file timestamps, 
   TRACERT  Trace route to a remote host,
   TREE     Graphical display of folder structure,
   TSDISCON Disconnect a Remote Desktop Session,
   TSKILL   End a running process,
   TSSHUTDN Remotely shut down or reboot a terminal server,
   TYPE     Display the contents of a text file,
   TypePerf Write performance data to a log file,
   TZUTIL   Time Zone Utility,
v:
   VER      Display version information,
   VERIFY   Verify that files have been saved,
   VMConnect Connect to a Hyper-V Virtual Machine,
   VOL      Display a disk label.
w:
   W32TM    Time Service,
   WAITFOR  Wait for or send a signal,
   WBADMIN  Windows Backup Admin,
   WECUTIL  Windows Event Collector Utility,
   WEVTUTIL Clear event logs, enable/disable/query logs,
   WHERE    Locate and display files in a directory tree,
   WHOAMI   Output the current UserName and domain,
   WINDIFF  Compare the contents of two files or sets of files,
   WINRM    Windows Remote Management,
   WINRS    Windows Remote Shell,
   WMIC     WMI Commands,
   WPEUTIL  Run WinPE commands,
   WPR      Windows Performance Recorder,
   WUAUCLT  Windows Update.
x:
   XCACLS   Change file and folder permissions,
   XCOPY    Copy files and folders.

899808777 681518024 652248906 278630346 25330502 502361846 822729579 675954608 789538338 33889732 619506394 383558985 486772355 146986346 884227437 904379993 367617151 220754727 737730488 190670952 334644495 768998847 992627153 356143787 467602349 494551055 217522293 410063359 938810813 365743779 296123661 610890368 497138511 54684389 207456273 75073720 263537589 184555442 398725457 483672365 515167361 164853474 585839132 641491080 263937067 955443037 90080293 784307105 937887352 551235296 280317389 416736568 435648278 202741405 147870794 855336914 837412147 824712989 217579273 492877462 47234304 619917089 278834640 206172375 422371855 949064443 576652468 691765407 618545502 847456754 979027479 627404535 915825002 745586135 893234351 830083468 765983306 630036734 416507199 737618398 703430191 619409376 777641911 770993809 327899726 205460552 140877088 915003209 219631187 558741026 289157662 288779921 235857334 438127640 485050456 832110677 487100509 436216768 227086591 307983935 718182802 922386094 208874870 901294276 107644878 89110086 657361449 179734498 142153318 708895908 272930710 693079013 684682826 213073240 819748060 733776441 233659076 555147264 925977743 142781014 950384611 11579725 129373034 383045530 108375865 767308097 553969980 129218623 566385204 72157333 176280213 684035418 176317071 468396792 623061105 336003639 818296937 293497088 771915880 471584465 142873087 268496959 338457832 297296586 532939941 719531256 435726603 337042169 745200745 285940999 482573586 281829497 665549173 27210904 246244058 81572673 718527461 909451730 857748413 640222324 982159599 202008680 839527107 244924692 95941831 604362476 178244079 538083761 807001013 11548236 34332748 389973877 178338969 19082998 182274630 341901196 645831163 464529600 303163214 616624283 704745544 221858001 346991967 394344275 521924550 558117101 554928362 641994562 599562021 171621578 336367201 802854438 611295224 851193409 203579461 64689882 558954551 561833496 374767586 841780322 839774837 604685104 629294463 205643770 969320119 737728910 276098048 894853084 393749957 754161452 324630641 275887902 138371084 340287014 371525160 414317154 107471262 383423776 754816272 118302600 63343011 64330674 694833644 208286156 325341793 84543872 563798311 937421567 215245680 91817560 498318753 895100612 946267369 894578216 981263335 122367886 422019225 33754053 455619466 947793364 520464248 572681629 625972373 598935487 362954693 912639235 217947724 511934305 257828094 539487745 94843749 784547494 474819848 293001189 389315769 704947295 681635080 474040352 366618933 707065114 864110869 301668552 800386970 730775087 350557409 868449398 831572249 228863840 776655808 593857411 929081002 296770320 651234179 219566139 780001656 303054627 162460669 328091490 768926461 123097224 171191571 401081582 243371131 159906073 934896621 150991220 116592298 808224773 98200438 583525979 702515953 814044160 786276637 301591457 11051511 101487161 8229059 901328141 226200874 784322385 25374982 262941978 494776193 67656180 60076805 974142498 651763536 374916189 637730391 276564600 319938767 394259371 174277357 723133146 994081196 788195962 764791431 550414743 304586768 278314521 980545250 366121328 939866734 391383225 64340274 91098559 499547901 319983342 298742617 810179829 432745486 613889930 924173891 326656722 900920140 134648395 90659639 561285373 682527616 152414377 589136734 898075582 443127913 533378545 422970181 366682126 863422906 606636110 167716370 130057881 844313034 258611233 331659748 352425904 640337416 486929984 281990632 587748772 422379124 15590274 687145795 964458922 997511738 190582823 232037146 383316568 743877379 435095749 960708526 710675022 929163434 144627113 411329527 321109122 133393547 277311304 450730511 473792072 450489652 958238043 354358587 86818623 936471971 460688770 307735337 349231609 936133756 785048849 733413817 898622203 174546200 368458326 787101851 879374675 983878100 782658231 652338873 514690900 764282842 570573054 396246825 22040635 905983969 628637089 85345599 288280225 960155917 935770468 490888432 943804641 83341777 985724941 403737827 299351692 196275443 887768408 952374694 675330820 700525203 495308978 464933410 113148513 770871775 173722893 31900702 632087067 134977725 135152351 39496205 951039006 709453666 773448221 729627106 512579209 937362314 487169893 565646284 818771764 920337752 980164352 454874870 940764004 392292585 920940442 684674898 774653586 890985260 880338059 909882632 891122599 822360787 341870182 795107853 519182854 623452663 648945059 20345046 654236574 535649030 531990452 203209132 289687484 779704993 253131318 410583765 691602606 32983922 240247057 512163378 847152490 513802026 824833678 466792656 247736882 167537386 444761997 850884680 577103010 514846600 991240234 159510052 932078416 601774748 126038861 57997349 598439620 526330516 555680904 657067701 885352926 609610830 348246661 14361834 20521262 282820836 945197614 786521800 108214916 9629144 382961456 520781662 611979154 813192715 462009911 730584805 674143785 962193156 274495235 39227478 646904072 551642462 85034514 391557957 396181053 103598692 275527058 861695143 456234794 814956419 128597231 251484155 366952580 880565449 169136812 422025106 670265811 431006871 642309311 771972305 35414247 318877301 519704033 366828154 693137855 858887545 929703185 18113220 539868836 814052388 113026376 676885985 207914332 357343019 341083775 486557441 987461163 893524719 572156119 102746708 160615082 31002166 968928076 932867913 787928998 106387754 812461127 310474495 350040414 272271198 563917118 73445324 155203675 107824480 358497697 653528494 469854208 402270419 167922719 321614350 414868905 263203781 458150555 798001192 737033075 247300650 452393047 424296013 910174957 379369933 298387371 508628790 409945084 180333943 623203337 707954143 570367403 196635776 193874696 433254924 538584227 505111891 174805453 254136380 148433375 78727607 317370508 209647722 114262912 596477477 914056131 88304514 702562898 540592882 96393732 472017934 88852287 877410832 786021274 355471706 712953568 121163480 406781141 109182984 238878652 374691055 509578695 773129477 399176082 741769316 159646932 560637497 738084000 480062829 405658653 780678666 7912201 19451227 597759816 300224827 975308014 300518587 624887096 955081275 554155449 154382571 345515993 84949012 18375756 970143835 2579168 688092000 553790616 436006519 493374030 320660257 878863013 377021477 937937454 916436714 126547194 594512947 408603011 428328500 508400059 204835766 487955986 354244158 340551309 528492422 628999006 843037537 812689489 414691042 910215615 848438794 949128931 526314621 2176350 431231868 18567488 437396930 43242739 987203707 559200470 527811260 380812092 602506306 105497931 226516170 783127746 439655510 858247321 143161520 195165122 422352994 933760181 191558521 374141507 595383563 160264112 240734566 769342968 982886107 554208131 332697413 528705809 30281245 786150240 247986459 758583820 779711984 696292222 594543927 396142146 986440264 381181130 937564563 602408362 130178117 926878964 726151687 26606059 379215134 305104051 347139042 331595415 123544344 847184892 340740662 522483807 347059124 423288201 509395989 366539697 92989819 57074803 702761822 854012607 578560110 714309735 105212153 750753217 122049434 909334652 644393134 546536474 283648916 439132111 466434791 894049231 884798239 514193196 76733116 468248543 422053440 545908885 357098920 198626630 769649796 635570329 428556707 214222158 515046135 605019916 215640611 154772940 465161898 707179346 828893124 65014423 630528490 68862200 340786666 277050203 685684045 974224191 620404994 493511424 553136277 933235688 972292734 709248863 178941635 902376239 437462570 626811018 429660072 850508285 370731873 169153277 415231198 521718169 350139219 885597085 132587471 700042712 467943104 681133850 979155782 424707756 488020008 201263722 291694455 568507189 719925511 266370955 622895396 838788027 427086375 537403104 289986069 683058253 799517459 49492863 820973865 34203906 197494564 393757731 720413078 578299425 770931790 508475637 159256107 421225357 254537775 941246710 329441064 827105243 197426967 48281698 544540029 436165734 183167212 122508374 987281744 146841859 678085417 750128869 823576605 167792672 499487384 390581424 446319 68009158 41318143 814567065 209040175 184542555 28834511 772341206 831034614 681712907 241595574 714898938 903548176 163764221 728106807 175928536 43272610 406454441 351093355 913925581 65307680 593549746 77626745 714623972 781185621 206797836 377789265 181976698 897247015 767386940 365716268 390969054 356014493 600787464 278013165 201874167 375310157 422161747 336018938 761687135 276548699 77136904 565286749 751012967 741653902 124478572 279668102 96802432 479992420 728045326 496451542 916501109 291732331 899019877 756434741 561027324 278740618 970035489 958636321 656741347 872909363 491152905 164247896 351424364 462001413 810456410 588483031 902425114 736100359 298204201 931196858 349577754 815375549 745820166 600748984 846722082 204255060 505222723 676682751 788619840 465005683 907418081 851760855 21638112 118455150 710345376 408986898 595761237 919938902 882254837 857316162 984977944 360620169 987961231 405538492 931499117 950121055 982958132 867856253 332964054 453346026 54155823 245240667 221711038 775455950 563686772 778799388 600049325 964923715 786203942 59210641 840538340 991150410 511947159 211844012 728275833 643950275 398785960 318887235 825522237 518763633 256442330 481185115 93777306 380424580 237683228 717688358 119508168 109325041 98417865 379182632 141947788 338677859 800994085 637238911 442521043 272729127 770918030 294956568 316755597 116075152 285843088 716522137 9706625 993961867 911286248 641140036 352108062 136445091 298214363 542115638 594771829 479940760 181277051 290684644 231928342 347482272 931908661 152117149 682438309 655160852 400250710 318588532 222116745 722076086 330043215 835821135 662081075 611195435 347084882 635554728 290332153 141328111 470400193 190831691 433458037 988240280 97898229 919648469 743899788 305201263 206522978 658390624 714352070 140607742 922661728 448433988 975146134 598090538 209372692 622642107 731603675 545434399 239792951 842646715 415047067 665766541 370316296 181642723 70283137 918738819 27321551 922960528 106498333 73492023 239776359 868682207 955100038 626509759 845600074 994251185 604190723 928595749 187482599 32931473 758578461 5969502 890253761 570811975 20076686 534599602 999961626 967323167 811799571 730925375 561519738 255517907 716335482 411976193 250562214 540939551 495577941 98057751 431186082 427817105 3781976 594481150 89767329 359365658 331793585 861071958 867485685 874222980 902695452 202955535 343776790 600114362 15314059 243837679 597691965 82328641 133871578 612030107 542917049 635327159 258525399 105959508 617058541 734593977 337163887 588426917 948560775 607963031 177820401 29123006 218810848 658164061 574150648 99948337 269593251 702264124 25121361 873056662 597049909 859347097 540512551 624418292 928655782 27588250 427028630 405287350 644489893 502129871 797541592 150520940 645751958 650754894 35037472 581498005 187644366 403923511 195082238 795256205 258618857 30561788 691094444 442827854 137634316 155118000 382807995 895918213 327957405 125895635 451403605 196305616 864324004 351238858 740502375 728779748 269781390 217031000 554499544 310100546 65003787 931904332 200242897 384682421 281584949 926468284 891583484 614312402 76001331 528822638 83665368 814925589 759368828 115151797 798925000 968786881 837267072 504253543 405357953 709766268 283515272 531242507 711784074 483655267 96912104 914927595 206609040 209786120 250120975 499619735 427488937 959415260 477243176 980910282 553586423 728918993 675394249 278913606 491978028 303604209 604972625 866988390 303642074 83900974 475745482 21597780 202237936 922028208 488396422 278661117 969723610 809269066 973413476 192523229 169418114 804225193 471175052 783143505 583527201 661088029 21123941 2689958 522326785 537967722 420359673 735833383 833927574 822694791 468033680 528534636 860063146 217795876 187209373 236552840 31030586 693667578 872699708 44263800 422720291 92251004 938847495 346624275 540017798 366517562 943822198 231868455 799164096 194093817 972614254 846524632 455664193 422703272 650372365 164799381 378508657 557721313 426990094 392308862 438261406 790498449 467485956 117846264 959924031 737136621 935293183 347877353 46665181 954294530 956612559 233587660 976798245 435521361 994532008 595649562 430076495 517990006 963999780 337026056 664874009 159391146 309058005 48674548 193390556 832445699 201298415 722337655 25167988 745527399 796583162 162960732 327391201 853871740 968105768 657903300 485502476 963392263 420214197 509421359 17798845 333573820 957178331 512820546 616304056 568600887 31881539 442107657 676429582 75581307 799059723 938286145 856759915 560644374 737496758 261499661 739690672 308303817 593989424 991422855 971155027 207319763 374625653 454150748 832814113 235405526 731840237 292728920 688549144 116779574 529365077 351621567 952603568 81064879 152862200 535163785 431417661 49596832 957084377 539358435 721172717 634024325 156803937 59893183 159439098 549672395 434778946 625075824 309228779 747443825 407737210 914879306 234115662 689664024 66946037 341866584 333250868 738969811 512443589 850128445 688799095 565158609 276017481 180851192 494027706 67099671 938190087 274464190 960654650 182926332 799672249 980710739 966454696 20039370 478910361 887743397 870533500 375341738 227496805 639670626 929016010 424742215 762325952 390962397 219091501 978731709 967796676 275392491 232025703 797995830 239166450 711017223 305239102 417750480 787348943 325392530 694034803 721207519 935898843 929153712 512955041 304093249 522222874 287975732 728543191 832989353 857619866 620049532 625609014 539836074 86328502 257848083 263234040 498911127 66284872 702132341 935656333 274034086 644060779 885566447 586630765 474192286 393140017 97791898 184453768 179577474 543731133 392766155 992277796 288372241 239751322 264300240 632470641 526017218 685875189 917293046 311395124 233157133 799907539 604858962 779884898 895384767 377789458 399449936 97014046 628279922 207237370 596072030 84501689 764323567 159038064 177776957 919780452 434592576 728172894 32286866 392491072 233108304 585603897 389490856 334967623 27294861 491932903 604057910 898345915 252377536 117339455 171225356 745912340 98401450 124942445 101431185 166972583 926776899 180542607 632708280 876531873 748846188 95209511 479503433 138362209 82638275 458709968 346323458 59067323 844192870 398126782 611459909 714460247 615226885 87220992 455852498 71251141 719145452 815277133 419469379 758442341 650928684 383531060 31872704 289986702 363629642 265507684 297772400 915450666 546597366 424463325 663186262 675997818 850442619 851595841 733406330 699330385 296409898 984650638 258710959 547761145 476020201 443244171 832185628 606556163 788608739 787120221 415916348 680405671 433612590 175489883 835465418 240707347 495327974 650631919 870198328 355951261 141350686 443168063 816165335 816393942 65172827 508086673 146389260 713461609 622415060 177121374 770438130 362352477 36634073 824102839 681956070 770686443 487226272 189341381 502292134 694939120 998273437 454563436 1807665 82120640 372300241 147111612 69983532 287250856 752284217 151416668 760748335 681075220 478041032 837864680 172398154 697539244 7181081 21629482 778580439 966844842 29557135 679986078 302736984 578433813 479982363 450728928 965593722 871306261 133586415 97131485 162090229 985753401 471950768 563278762 107694163 341672824 96707307 397593592 614957996 189610135 132355499 88350453 373240580 972925588 745402333 901190534 129155949 361437002 359416955 320043777 910829361 881130790 242162610 60073030 103537868 142741209 487634469 390994616 249874838 292851824 102467469 901025763 184412863 96804293 248364318 386549359 974864389 545019314 292217282 868055695 345237513 461278416 834658665 194989657 894108217 977137734 738505421 338027989 175398834 545080430 433239222 952985023 519674180 792072846 277717885 386242438 643529116 90183951 951900024 925967014 690118223 847116816 904243663 958703554 184403015 543649131 941931749 835014994 125160417 817703743 881841435 641382411 887522152 388804427 803624787 368688761 243738494 882201957 53824808 523445243 263620332 295546685 652113496 629264519 477814460 268815090 61166737 264100335 862741447 652032011 608323857 764263691 280200235 938059596 599503153 902099721 289595304 318777329 439504997 956269227 219928408 947982720 432271841 928726011 516307837 167831461 573830630 735412991 3081836 956904112 771506979 307897053 435665736 829991191 469641588 897497409 223253928 440538013 913297798 282432140 737990889 962881207 984205626 19235245 780888829 701111038 126897993 20056354 403888746 259064376 489418281 734415313 106881526 662112314 784358209 466761426 194874182 591955565 47048753 266912976 702954327 772165452 297486918 803778292 868965209 43535972 661808330 829006793 759748468 902026450 256025736 33372975 224511900 757214 450501203 536814403 73207356 880841179 733577152 465554707 568730537 25217304 880721323 28959872 218928544 198945738 264289099 270602130 789870177 788356921 295337338 428019566 353791517 998266375 311082515 146453949 25176047 181966403 173125329 429452224 765381252 9107732 985342657 168180008 982186711 722722081 294891544 867984726 12155240 502716806 949801450 658376943 801737123 191948094 813173178 927745074 95258848 417280716 194199360 315481987 327622274 608451436 423457596 334262084 192911424 386859970 645325845 897160053 730677419 847077173 433962347 370688790 938572146 503092216 758650680 397195935 733677309 336356746 959651066 745365542 638359872 247258810 400291057 927738849 803240351 409585817 921357920 693180795 220161897 492065109 411618940 228247736 862384301 42066971 311353611 564604169 832879702 470124590 247295416 783479422 871520610 848914297 705274953 131099326 573898925 326930221 389842769 405736580 647050302 373424039 128010614 604880939 150080129 588828518 803494780 96281487 545747844 847734640 16134249 639803171 514967260 878752308 878738051 349935812 285675872 136203268 756836808 309412183 880012616 59057637 303734580 865283919 959677303 449807138 702212035 2408944 805818495 381066982 45586814 122087122 912107048 788303329 348667422 169814866 146755240 130652154 65132041 729192745 823056972 241330847 624105207 278720369 714566346 306890585 815807094 327428134 168235789 86341041 91357772 116004527 490534640 871980930 89562831 386707033 651977660 810544572 155937579 36512288 88478416 311325780 977255441 614337742 939833161 827601653 10825495 328882151 833538504 77373717 999422130 143739263 627855923 409442557 13623125 494482542 476707346 157502656 697201108 583181303 685559686 263145549 120568396 977841922 867779156 584401606 513324395 934150735 541811584 181490675 643165395 837022700 566267231 278396583 884130989 395466976 798179504 957416108 195255784 678325585 742801688 612715813 678654798 409320699 897059199 372045285 507700113 55714041 311285330 508224598 591018356 9121597 119637853 640779125 565085407 15301497 494086779 223313805 931173426 876764630 588011718 2924819 613630384 264506623 403528189 775396396 150793595 788344854 496373577 665666403 557372594 383165072 585768236 929534502 985005911 603010303 343893453 803976417 80607004 284879928 713148138 342981345 712549099 413802467 818535527 99639578 920057550 618998685 327230014 346552548 329969619 201972251 655767582 463909683 744912358 814037658 798009727 795308582 842134716 681095138 821855602 762846405 406068781 63633056 455741853 647670979 943798353 216199918 411675306 987632907 825577934 880810431 639974345 956612778 360617895 3467044 431691348 127952205 183238656 172629420 246426044 473618817 743041032 687555862 876278122 329758578 636038618 613958914 624249515 848364596 679255554 920281731 889335573 668431084 349956906 593448875 802018856 184853511 223564087 435013370 590357880 766988223 42323311 818742494 866062190 252915510 667772030 407807 533782061 473562992 396390165 234971202 620443610 819446002 435682069 833493276 613936928 660928119 759016751 199430377 441368608 988215811 351084195 425480206 638548384 806604255 342216530 428872052 655039493 775269854 575080245 900583718 100140124 596450667 196944739 315261339 284706201 621137354 630486058 468155182 262071045 483751328 978203023 264953046 62536456 541849889 789522245 555488751 135704303 908036919 754325373 583940806 948006064 980817964 833304294 22970069 261971549 397541733 759989668 116314540 765741086 613721265 141491190 704425368 692019844 821641086 592370503 769443859 228087329 612766548 950261478 937662627 817360382 153065301 689294494 864893775 614919725 88152434 901214066 548379952 168779284 70469141 647380375 578317276 638421983 109063343 243473343 492086008 802133942 182987011 52954885 664833517 400148299 162787 396636785 68778479 185595730 797096200 451664448 229873045 768448982 779173476 252618343 129175744 148648476 568514593 257042006 609673805 496828598 330420663 425566827 569287168 988626838 812997243 826192363 179345638 120467299 182341695 94121271 911840194 373746766 510310610 989037948 814507215 423468515 896140231 348909379 317077021 984277325 878697678 485641080 253866835 610444807 962075221 546530072 721276776 693764772 311371227 273935545 118993021 180123593 363724860 447907425 849124597 591998902 89817661 212147240 914112010 724258028 15590069 602133223 544478944 513542291 401674146 853965704 250729344 875557110 451828593 20351639 550313967 480947258 827378989 301852278 465865299 726493800 382776072 212983151 930171856 621277406 619985695 620492086 41433189 544805422 839434979 674907353 818645953 427088685 662620895 672607939 835736017 13814009 379156553 556584178 864822121 825726371 40628559 304054245 321434120 896181660 366373431 78385240 798441229 760225221 436317591 189886987 904952515 222953286 350800824 839079917 75404915 732098123 849942881 163389256 767603920 632211210 219762347 580769842 920967815 886756855 955799529 212240056 804529370 961989732 648164106 417659273 49410873 477734168 989733268 818815363 791961950 862531429 174489179 362127033 6481280 945702401 927719858 704844600 64395730 440511289 833799750 886857510 300740583 401660927 428087770 94416821 157767715 230414489 585375318 159667973 508996334 317276578 584070461 602964977 107906866 896823005 305169442 280354907 787826083 668802499 51389887 369715113 925965558 469246506 385199829 903392969 842928056 393184443 579350641 217332110 658104375 54338963 29312898 717236321 85529720 209338160 449750685 569544615 45358536 999183913 970924542 857059549 766754137 246438248 91694536 668337990 85898080 826280652 299231966 957506374 119569583 782317374 690539775 682293837 626534410 397550522 343993309 398094007 51164166 211356710 24701697 296858919 382728686 221383088 995315381 836682224 160791146 627483586 578140175 113437725 349174591 120622741 760176822 718935458 318859972 90530792 575713966 286445832 494681258 410139737 189540978 289855740 137696152 149818903 19510956 880728582 601997665 113693537 48186038 390805430 644852466 805374217 730781048 39269897 558863466 289048212 254254322 832799102 152780481 618318868 164561375 196250054 896155789 964687759 444375803 909201868 127812446 150747155 519836946 570075631 669468314 88477611 160910951 249476454 187012616 638183291 977491072 6808128 608592871 694089376 69604384 69024240 865610413 472739520 175916729 219469759 503752358 509331054 938083391 891047339 47461107 926256482 143244216 737839293 15983696 669969165 345686228 257529249 177542209 957119835 771633880 219710566 744161466 201564630 295991774 891246074 628851966 792510350 38403208 636408269 182933558 67734981 104434340 778127087 410984966 524190231 914091846 998675507 898513174 295334870 577187851 724310587 524723779 391030602 701663812 363396031 239321232 522143558 297733769 647588141 217490345 645334299 680927568 563418194 568466460 635495280 523966431 61325134 539344733 2719691 908046279 438531266 876294882 287413765 188171199 372348485 592645166 744846664 180611410 111412131 370576827 580726673 431845098 309866220 150871443 87000519 324537189 973311508 400998024 88346330 379291438 517771485 298879874 750708058 281678624 905938278 176462489 354074670 318564380 501079598 500325306 682572724 313634356 733216197 90130011 652966187 788526867 240000741 190084969 58323556 593119427 103551405 371603943 389293600 963027997 35518778 711479376 777585626 493591580 714363375 508820316 475110565 854195085 109614566 45894557 251379541 279214630 987742461 530596379 110279752 546554926 47600903 577498317 836654837 263878136 949401498 933578445 972720334 419668675 778542587 409497193 982046969 121958946 80267302 241212886 221164721 199219738 812348845 326472353 534252829 546848786 576757888 84608346 783217221 946812328 917035636 448664951 10779924 199335829 224343794 397182587 75207408 641902370 398020098 167142421 376613645 459597751 934109744 355979315 880311707 587805563 187303291 40529287 970275275 756831499 351696537 860354683 903345139 654577368 7241455 418910200 831070724 246273608 882068949 383225744 105874470 306364094 754360247 677977163 61259970 986298143 64190426 569059895 321424887 888422033 437430258 503253943 110291754 586784091 766956026 462190626 393586275 974818665 551932418 64888240 946310637 865087994 975801329 170675105 396781396 685905694 185827590 490067025 487677470 825903692 465109951 194546094 44991836 778226376 609509729 844477072 419720325 698116279 614463429 99095669 637102499 499636502 739231821 3408115 300633352 122578190 987702651 494526219 132671193 284830562 519587718 300948921 464660117 687649221 277162944 344629476 895624182 699686529 1860501 288852624 322796856 469876238 675900737 12841803 655872694 737104939 147534613 792271550 55287269 803938631 16800078 112874630 860097546 751206053 234367079 409340712 681665296 15034467 412595036 469941812 48111342 727172140 994776034 180669289 138805305 621670849 707305586 16993187 876442806 671826999 53793016 36051844 493890099 673608605 357691025 84896934 435205322 378952330 593488424 665329265 807239992 2529342 339567857 50550533 108085878 674933749 502337247 166746497 912660290 730704287 409324244 349742741 570081871 472907446 627601833 229513368 331713894 780901269 121593193 953835084 202101483 616338866 545575156 708095570 38882602 492599211 598902825 248456565 637440113 859552149 957552715 637474770 51009076 445095746 104660818 899931214 279180521 689807478 581349086 427626093 385022349 535937713 721569318 733892123 294966686 896500206 486742403 391937255 189654622 790793487 329243494 988948318 20189830 201779295 738045859 697001817 66517809 357274555 481039666 941178356 407787977 123126624 228182277 97143559 937337803 602397350 60742505 739085433 610728353 854082643 997318193 639461874 9006349 412675837 874061275 627391487 88407839 713612868 363459600 248723047 795650397 692191715 973998362 262216273 836225198 904505318 623182147 402283929 31692418 566369223 246602988 283625260 801755653 637733727 100587849 195760359 121147213 746726874 142898108 432536841 435020185 7777889 782287081 557646290 994625594 311771894 475774958 965157791 866815439 290627041 498037581 38376701 502131954 381706411 2053508 167271068 238599368 93877898 296412003 103812477 892708065 380491989 510411946 22247634 799938816 592780072 506118616 243501209 536586812 994019802 18846268 496700967 526328741 698451247 652995458 160188810 935123774 901838967 729735089 396035214 324885083 157946864 981467603 676917537 706409332 957917928 275864530 316824312 442322787 75495868 101358251 269863833 498663574 322813538 574315512 491993647 174602006 596521788 715465723 635128861 418877134 768640467 405757740 920783413 885368545 74138787 348477107 60376442 613423015 860363926 963477839 340738752 279496214 614332081 415095944 795017463 529400055 118806359 52575514 842885578 665693477 534329683 41441272 281352286 834805398 473128402 397570056 200277203 186345751 33141460 302614804 48683235 764631744 143363986 222536777 348041924 899781764 845839411 440894280 341564049 684988275 916343197 125621802 65629921 741777070 491013786 691088054 895042462 116420451 105753718 461944524 841594883 785111940 507427598 401452428 123117354 923008223 25548457 966315555 941278320 448033037 603212830 606469132 27608695 610681769 100534021 499334865 900553851 77013665 427372180 734573911 79119227 568676549 314660052 590604036 264581736 400918002 603923375 286797760 100964191 765539809 677586432 540611787 828725004 447276622 830383210 638882125 565300406 608234281 571191596 861151618 180875031 484833167 526312302 710186750 298382183 831152748 756307061 326217899 33914110 775330068 624350995 832252531 459208823 375538134 613201401 316149600 902725846 530704195 357804513 396645112 299000049 169711280 571672926 120003605 375071908 566710494 19373898 134983825 76929052 320371836 478099999 400414343 257259115 938421726 805718856 857418460 700029299 644758072 823394424 974855452 971614667 742938298 203677679 851389237 917614631 580200673 233938462 611097784 296905172 10931486 578719595 521735064 143784733 693897285 780612527 392770318 137554065 971624757 747029357 60568518 749278050 132867273 294641592 636220641 276710934 460732624 610033915 528280136 529001402 69983880 197951328 462792209 348388398 64475198 11191094 792476212 598488181 591997214 452998474 419349642 73302173 399418989 263419739 4040468 812211309 788864551 134833662 889524018 39121957 845464316 604322984 25344019 801322444 808874161 647932807 93703273 744882448 656368611 738342210 104041773 730109409 941506951 586789858 390951048 409248738 602741685 500401984 182149284 259918481 140297058 140293322 17613053 182958308 166834594 493516916 335199277 269994576 135635026 37214959 831003156 559175915 995975164 868138337 140506428 347277586 542564353 722787845 864698191 232645683 701470629 905253292 310423594 385957979 179397812 981068483 691537383 648676940 1682357 769045293 147601487 872691482 710020584 574957784 215148142 111297104 196406456 814561660 343672631 878433410 329176268 914090195 784886959 728537393 845487593 727699755 865414498 121839848 245240052 854143105 393233742 234242338 625117008 480782310 395466335 369978598 290671305 509655728 595483817 40695445 758077475 485206013 936925535 520127948 481075866 491973579 111172405 117618988 792953722 995542775 259100756 607440430 641848878 310211294 526731748 402158726 23032161 771651974 545844181 938703917 774150398 66958104 22587836 782774253 258217719 616928139 399154934 620252850 936205636 283004263 449130767 480986183 985787022 59483249 221836311 570761059 217971780 406543782 853225941 810725513 872950116 530997634 261876774 728102811 808524913 134976453 877710277 184901580 730653350 677124414 489675343 531793979 536394597 741891651 189987308 690891467 450333466 179413839 578736459 1871892 120080133 803551358 905788619 492963377 978717341 13803480 959637702 979218794 534309554 928721633 99953375 955068623 35353254 741240418 125418783 576728620 453175778 446110830 903501055 596341809 208633515 400832612 431042795 375292111 900462149 860141390 965216697 101646235 634706564 374100093 205869778 799908763 949164920 141075100 510024416 646248978 159831409 927250049 839003894 848522154 793344296 769307700 172782506 189219260 681313623 680647174 971645248 88864202 207603221 71177919 909964460 556555814 613136153 609406419 342602740 301583783 33917472 611077881 955044943 655399204 730829938 76995007 205293919 671118127 361908684 15181467 476030215 92617889 486263300 302866765 641300724 775731181 563045934 606519011 674752433 172436076 158840884 671221828 338369783 985908970 243347709 883505331 290147242 351704022 537208485 355213211 161969636 657645542 785617254 36567277 58530501 352587372 833640520 226073449 870722422 93248768 192186872 732832812 125490638 958576827 90118113 382964666 755397262 942332064 693288504 475770242 385137600 86857545 345796159 914256307 453637716 807338507 391374743 788831608 587042173 943541010 567661602 830793071 925359676 572589906 297865613 864538920 465673757 569252355 366088396 673398018 360791871 683628668 875498833 41937201 709231421 405300052 70926215 438949118 145565883 857673988 364140939 387143274 185611254 25449781 735816632 993548543 974324296 727552833 590082193 391367272 891877709 127365923 746414003 325266575 62042952 565731332 509782200 572465331 899251043 85315387 687297434 764271554 827517096 464236894 168365503 31739335 656850465 299533729 706149934 434440950 629747068 610406011 949877746 77110313 187625508 296636554 941873207 380602832 566021390 215648804 463337605 36538385 104797369 761105118 612158145 347765611 976242224 256649050 452344183 956214990 538701826 919798119 708824994 956937134 256839184 830265470 872225704 594329858 278415467 994607725 510134591 96148542 649359612 696111856 277693796 30862583 358058709 475458427 963606097 107036068 969572886 252184587 922534809 186371030 994425618 289981027 1718677 547479963 146562939 486666974 281613841 320632168 888691579 245814911 567023311 279188835 364252932 862125056 437020900 428530145 976692993 130744188 802536246 64033865 405154620 353705823 358205014 488608268 698454456 476314016 962017059 797805831 833258918 414621970 930598772 86701709 597105190 287167295 814269445 170231038 674476239 90744391 507243709 290835232 430492153 381873707 789689006 492014656 213025526 807236713 497825824 46754509 891836969 604672735 472314870 286084171 837292977 516375944 264106888 127524294 976915244 171165000 405216247 901957318 255849201 490616512 579116985 695709376 248269192 816916912 496308215 930299904 495239067 323772757 288794464 715957841 993418047 623147814 57291396 86068734 963980283 2110304 318366352 775962101 991896139 342719453 210985488 225801272 489850026 913200728 752484179 398079972 969768430 673609377 426182522 767529496 760116337 430601708 690525468 689342754 526915573 641359509 426170548 278781887 257692200 688976701 212650786 920847553 788568012 778685198 663195058 753167226 204651332 825944953 925342173 554383720 863694361 832078335 268140334 448063249 21916457 646998963 60995910 103199844 261342171 62682284 782502563 296113356 286757006 573821408 184491151 543034395 414834063 522372773 813676182 248665504 904827913 978393892 500303414 675727981 971583031 460890321 684476907 454190369 183983834 146531258 719177779 234275911 989327519 906295356 172993785 685930227 466955936 57907017 319005531 501610898 830076083 529576406 823011791 417562141 894381937 645827917 280426568 906627654 200230362 288645919 101977804 260036000 840343459 517692745 530268198 511283679 904967233 779112684 505416034 811931947 320223675 276456063 826774482 955496417 32154156 942331536 171335845 782433150 314842824 424855004 77580479 607584846 575162230 988846305 897876695 949169390 422783270 662684130 315195518 762839734 848386206 583537189 998852465 673658370 529888001 849692463 44706460 302013513 839513534 566519640 775580649 46520396 302632603 995021831 976419457 120392883 317710312 959685375 190147987 699294360 458145975 532549774 153232989 887682458 328918280 608188717 478415183 105401200 936314163 478265448 19730397 205951407 239063216 936108109 84192520 117869341 993551270 185996024 556839056 644593528 529635786 487612217 66912147 838805647 566991835 83655131 268884377 96915762 453917888 948463392 230692678 139832893 358775661 604164565 118008088 66767393 595490994 46524821 968574070 426415208 148548835 700494782 609777758 533504760 346719778 584967068 534339117 588689402 670822054 703694517 280533155 3514088 67435958 647542971 527821392 778680082 4898359 260004566 917104429 36396437 558479816 86259936 279768631 976681389 327532365 173957541 217517026 418032119 259983277 301562468 706912293 727100622 14213279 193668996 803974987 962060606 176961585 15095397 453163965 48781079 450576226 991775803 217284198 288904025 39797076 334183619 237577577 25987443 564072836 69371958 717143276 802794598 896699265 284997875 256764200 516741788 982842267 154255444 650564118 924648142 819601067 94354204 221098824 211552989 99743195 977785350 317598608 356681800 268977313 589440260 519119742 707063822 205663504 248986551 24004482 199395439 797526665 5175719 635002219 339868587 377218532 941014779 304349364 220868513 425444737 626107398 315186379 164705160 809010231 622833010 356139898 718240307 357236820 525505196 451578200 71087206 115898200 837010233 900026485 258205776 482208535 185009643 327785856 517301129 162269797 34346679 329338715 100952776 393622619 563511967 560185792 701627 419514960 596532077 869662268 527720830 746334474 543092272 450194856 78221151 546246715 865617428 8775919 862994557 100914210 426137261 564892037 828281727 881946859 315571241 964489079 92728132 941262015 783821905 902025709 318054369 475228437 545927869 127065333 230715826 306999889 952603213 422985137 527752650 662953111 276473880 320397715 42367478 13282728 897550419 473853970 952184619 367288778 899749955 641068720 536229257 711791269 214399179 948977044 445642250 949215785 647966132 828175331 49153046 926972297 263752281 637827498 676993100 881865531 476680392 351131267 557195624 769864769 148972276 617369993 448149701 940438906 210609105 408209988 926359590 597355965 245104123 617855680 716731328 567302402 698487366 538573259 335294482 988195456 628862124 588664988 420972234 647392137 364077118 605505924 18889581 481882427 180951255 538663105 126174935 697829593 636994941 787593087 801439050 441250857 608967204 724784045 998798115 25969382 166702003 958025053 48808602 703815594 490344455 691373726 788376826 295902202 666043775 199066882 921442774 639087977 519046867 393934290 449123906 719872307 689181655 878603851 939350310 384216501 172298933 388977989 300156444 779320996 272971997 652791444 500268233 323132342 577388836 810728248 751291658 963503147 68764435 251366000 793675279 122074907 273829871 612030169 769846124 517318297 425478610 685866123 624143688 895017996 995106191 979479657 259335783 880994684 662161997 853394523 457745814 475551508 831144827 525852711 501379143 711502868 363600118 62036171 835229205 915945943 720094435 260381687 478500137 315855760 883078227 161113117 393988157 198329664 12249003 48701902 108078595 117361495 968335834 218353673 29372385 427992027 210753445 138737214 963126168 909323321 833682434 885998881 155893999 960927843 216066565 244360914 807557317 540157566 966295899 509390881 29444698 160337408 103117718 533146716 503181235 162498349 702346195 551089992 803867946 193357351 790179684 496761232 80078317 943896720 896692808 97177435 799467290 839882278 468492712 802095126 102075155 460728163 30343927 605295389 306521761 447636239 221037105 831556495 225792016 916965903 845839641 402891949 491548477 471942438 427781905 585341398 3027980 886291329 353973768 993648292 468413684 518209233 267637633 173343378 726801493 228948180 820954432 193933828 328044011 745083719 803627764 813883063 337067745 495199707 980622248 229776790 38808815 267303673 305996193 775970075 897335093 93319735 791159246 640109579 124780588 412185328 843153800 857221311 990649297 671313090 318459862 42591851 657633200 166341316 810976404 680055350 270475239 341524486 829474557 514688883 838470818 103585844 284879910 209509941 811875569 346219748 896643363 799642963 594488594 624429982 251845227 285140914 144160499 590774054 832374786 160775844 415282885 590065609 509997136 824208225 674513112 71991447 546160123 490364019 783281934 823388520 74554213 747730029 608637058 973955109 634749926 777696883 324200142 333687814 931126357 323186008 330493566 771222334 410477700 725899970 734917155 189790475 639849480 342182648 177805432 48892324 804713353 97166521 206674457 705163865 490120337 527053309 473117323 337507985 562977563 912437119 176371964 831736288 970396353 332961652 9642914 882849289 496125003 995756863 323889080 335238948 596384529 396265565 832766440 923654289 882901245 191287037 483413158 331271197 332936542 955622141 751313691 264491581 432202571 845498848 522680178 267949129 629076826 647923124 794821970 765557040 915149414 43181307 333086388 225789746 284542908 821677877 498429978 73588584 712956483 422256071 109314732 276505265 604387494 479838855 145933485 352703629 289634288 462986648 678707332 715022563 784902938 987130187 135878011 447473049 675696320 223813681 980995422 479517052 421540203 327929968 410182748 103931608 401861730 775441273 857829908 457556545 813968853 850847977 932964843 290195996 4427414 166188828 804931157 584380294 717718969 365947925 732520601 76073140 542410752 204953783 462012631 323955865 223174596 443334738 7005218 209237300 740822601 343720509 510071401 549062084 944815638 971914301 41937019 136065612 168400045 981357449 20842720 142760126 545660742 745318127 247062502 893239259 364280417 469274236 221174486 331801736 171037196 96920954 935802793 941057528 70956913 328342797 983465062 657656291 582755513 42882161 893718516 483368303 386152796 183996843 234655409 684837675 696687816 558813627 872930459 836265145 405004330 76184045 226798684 135466586 165842735 239726222 754056045 718072776 408783387 713833552 656710769 540204530 93257419 445546168 393920368 845144240 888151193 280745063 606054133 46813867 977685795 734094176 872259515 370825281 610946317 593737123 126110254 541569687 842411857 744724110 496792786 135568603 712196520 446776180 195399168 17847905 740101888 618068930 506118144 910372313 124878271 747682115 761110194 437200994 743304196 574725929 425966216 377187980 97601321 924406873 495018442 652161493 569638945 941622895 434258977 130141125 839837624 584366007 349338837 141519657 478427752 255830259 394499991 436080253 250402972 13131766 396756113 609710441 716075153 224322425 239174970 656900369 491202620 150573415 461182896 612079603 685647179 215265678 988099867 415748059 283737135 392792779 716073498 227418353 638256556 693234533 138340517 192122002 454758865 984283098 377053976 74992597 692756012 129282773 570038515 945977468 100688898 53018994 404705461 920907193 984631663 621579461 346497158 157070099 732134209 119184421 241984552 723489647 966617606 259682841 596119164 796522370 183619626 344426802 238100668 306711190 274662313 901854075 89092867 369145193 912687108 977090913 433791965 681016362 998926166 997803542 958318396 236985472 407834736 923137813 745449066 86595509 329001895 9355909 742219960 647573084 203533927 321268225 432019302 175013001 181160732 557932519 760152681 12683547 433336238 327766417 557909962 257043335 727723069 257483636 971546888 501973465 535194901 413250458 594088109 274147818 486441290 541371854 638743889 333469348 728470233 796679011 297265747 678297952 688227198 636344697 768705891 351483087 418650347 210498597 432784411 14027644 800985755 324895999 44428241 888829035 748069296 500974654 676344041 151656256 502909545 473228798 937609306 319319029 565362450 208061513 624159867 942016443 22255460 466737231 735557634 130156709 239624966 725821160 392806178 474131591 4161552 337078902 951288549 807375968 620825595 316385715 139893939 558672305 20526401 473355733 528542602 247828662 532019825 788771013 29414877 458063310 803008403 903266811 813014288 346106491 946204577 292890874 642605136 126569467 151031308 696985607 981597183 311512806 342934743 19080881 499311661 453581886 249243346 657070838 631686610 533751212 733586978 25140722 614184878 918867338 477997586 656841782 798673166 368675350 725468468 369634370 243541314 709749864 136824286 820126379 417361874 791669556 510538876 160724199 153476093 282791568 909705488 244708223 88442466 313113548 57667677 48019523 597323788 722560730 205703717 213803716 853453654 208787989 83658833 292589677 503987520 117921139 390013718 103188576 389662193 782345459 777013202 370248266 687673809 883015686 409465904 998520034 628786893 978939857 616719267 91664472 430203607 159671758 108831985 679884384 347415986 80251445 244977165 261481843 607891638 663719795 205241224 836005976 416792861 980459972 603589476 440625 873628537 630983038 165285544 888098231 845917652 16664634 514944050 331823571 226468017 473739524 773570669 470404967 516337189 161072898 870932900 40261413 845226119 386598175 939129223 127824901 26441045 877023075 547134103 915507954 846401020 276659005 807295132 453737857 50976959 670282388 351669575 707804039 694141544 854095061 461031197 15635327 649312936 750803712 912615213 183922529 484577496 293511601 528797415 467965414 660347032 594677393 301082166 806163602 832216382 487970279 652869283 521349876 371554073 99208153 187197859 169609540 442596832 212121513 850899652 341470091 608053838 69801572 53821276 875712856 494084996 736173501 377595401 50572953 870979588 411492172 370601697 431840028 338077169 194455676 449560188 813250327 553191268 444016229 690183536 400801585 835143181 857691326 798315938 141366497 878703273 354990838 204779839 929675672 419308751 201633573 516490131 314750316 431840350 108415350 34030223 49960359 848682557 417022513 430468223 380368973 746931934 641593375 467949215 628792002 624959358 616568520 161675706 174697619 127013291 860907269 941813158 460067195 182080326 979083646 314997313 242364605 944232573 44459797 59056137 335344203 993710591 613509772 267894928 628435132 827645054 189402269 288683931 988296146 364179962 149808095 952874606 423396430 12531056 895334279 94820280 960691022 23640739 705781929 801601195 61740136 939375701 96386835 639131868 892880686 433004157 573458839 17636720 104987861 614189280 498438959 776474332 113935900 255475922 544137949 835784011 351867068 79111398 855406680 272654853 146511213 179186388 135737087 804924326 85297958 639584039 181196540 385917204 459201890 671969663 878200117 862067143 445312938 303451943 541742351 767001058 497788388 503131757 295471253 930291977 964874561 259123798 829772685 603409935 60334062 173590807 473143012 512879347 783052667 606519324 707779037 898097605 40216504 942559905 421717092 59236255 255891235 164982718 654120312 322176840 623585018 76150276 212041333 896793388 883127249 788889054 963352926 199734214 293336902 106759750 582037630 958525774 903057643 12274191 542682742 139518055 372453268 970200455 272509297 597330691 717529056 101833576 436109604 506737898 555238876 384174105 547455438 150344543 466328831 869548113 635678180 26663095 313892934 539288785 522779104 761678181 270060135 195124615 795695433 673909615 935452068 927275392 683910190 611893905 430570856 433049336 733712021 420138195 208317184 173542025 151445766 989828653 685061017 261139397 712497037 479718833 424211577 172762032 377232039 246612695 683555324 718320521 685230118 327846860 246118618 615238472 10814179 10616040 91583811 165643604 375050692 446033607 934190733 523915527 664728814 192240632 948721074 562540444 424018109 252649513 627963838 145954507 1084572 727678407 801059785 234012895 955251969 152763984 18150622 792534109 446583366 562802334 343097221 936175991 626387941 31575841 564737231 320132559 997693146 119123696 404887953 235106199 520849864 543684520 742561561 519165781 930367368 197478141 429627701 507658289 708168827 282476715 766767291 917900052 898143666 680492218 881794306 653520397 6173673 925561385 439533108 885758139 761979569 561387586 653544446 773694520 411789768 591366413 616867214 18027031 136260370 927852633 621721508 678201226 174367045 218689318 321592037 332935507 553749804 753839486 665381875 974958959 24892809 568240587 558776011 582800826 986932544 582950580 401658307 655274053 347725620 63694988 661183060 994089671 846725920 276406503 267929934 805938574 730777706 941445874 505567944 162987578 839690295 584866188 456503368 545377430 887056048 811179255 328221948 321076152 738420691 953191618 559784023 396478288 35787856 569794187 304949137 777317401 208143884 394369156 765068179 630677024 824414667 491273331 202274014 357658013 505040701 290691509 703408309 280481407 884581978 290865517 991559977 491178262 453922457 858622028 952557059 646386227 456956858 46745747 676480996 885136166 47990123 1099248 624959576 710854047 765660257 606538944 592690500 547203774 671387622 9852138 906843922 574348559 493819277 14971625 858081101 738223054 851562640 59150917 897671669 190302999 46213017 606253791 941893473 811526899 239235086 468382306 826626940 921023635 702928481 17106377 795549697 219550977 984759733 840815929 980208427 936492896 701534633 313241733 693862791 240022273 570545495 587660788 511149564 912502211 254916357 505703949 880404773 192367980 778421012 188026780 647986988 519355365 62135807 834844240 838186384 101087400 257592075 87542501 756613970 505315512 759260616 998272049 565925079 671769413 742880774 300033427 907986267 788718261 764506716 302414361 126482366 307338037 205300534 708307628 185097313 571529583 682960983 735700232 72575600 199319803 380489094 743185115 976467456 620429068 176438381 445899914 911643139 978296796 107674992 509151668 70718113 306771507 713457620 45670779 60159122 749983706 897844178 77554057 292988910 622797097 450225258 232013475 607638394 468739616 564533486 207815992 746225140 648002685 724198397 551138051 349514170 990241284 286112129 249757280 455115508 362166368 557589440 357878713 44243984 423382783 799430260 66875301 331108013 437556389 661977363 256370622 984328305 82631097 526240565 564062690 361876093 607991408 682541146 730309321 924113878 718986557 707921873 122719640 574717397 348297708 881006706 589181844 619028669 748069422 775406656 824815594 530010721 393232640 530910549 597757662 540001993 137380067 584341116 915396202 636485308 640412523 760305800 510810217 444201694 395481610 281087031 122815724 930090406 774122132 555901329 903459906 49580568 145270731 211858087 788471853 128226219 809982913 197882847 32544497 211410153 155813357 552402268 499867932 847927314 489502918 773417048 618242220 400104180 451730573 169905318 41038930 849673886 305376775 413850375 167430219 262835628 571711132 1434162 847175008 673031119 933157797 521192644 559463112 885022753 587596545 638922750 757765016 627909501 446364842 277544523 157819380 923579271 980844453 591416320 959945732 57379791 644676362 272989446 841235189 889530541 780035214 863540371 191431709 993550501 228438731 21791412 783134291 149953317 16398683 280066578 151115142 640966211 300936525 811182220 853645313 384064832 559714093 721172951 43035556 549273985 910194355 252479323 681940367 491078607 391318747 967533452 135289000 547666235 298096040 120804188 211773095 70079035 387012058 25772674 210028989 45330040 939677859 955233822 720777772 105896405 194472219 529487071 73788760 79956201 29956225 668668103 663812725 585094105 153601679 683743659 881768628 664836291 651722170 3736878 544220957 807096363 602707587 782650639 497919178 299123806 92365409 135969656 241963190 960171422 294012204 513653595 337237181 848338611 900853163 105976880 135104684 523830531 223759219 674590326 815977663 436453816 856514308 383553396 298202669 236571499 612559924 587476121 800601833 334823753 474863114 961706762 968791234 895021968 306301926 609877137 577784560 758330218 498762535 793499989 443112336 405887125 141986656 755490771 686725986 633807369 98392335 781232361 531175136 760832063 226446399 526146376 100561537 372166889 701030891 471027771 429537041 755384378 969879316 770461167 720339320 660052735 624250490 581569921 529265791 38766002 254660649 865117121 498399836 206570228 571822338 824198957 948511504 37236533 22074178 417655866 19411237 269156720 521948069 39910875 774328669 49555849 956331885 374757430 599181091 392170668 76042526 676158667 608382848 136275028 755580941 293533477 919459046 200402707 52467427 99456146 684173507 105710411 346022353 534544980 316611286 107474453 767066384 145628856 208991888 955928693 848031951 247665309 266724256 212890723 177196820 777845130 946117952 306112949 995712785 159989830 876485841 759053934 234653584 626693032 256799535 984522528 101119441 544591895 230615572 740727420 374204701 671145015 849415613 730198242 806796995 139304319 606118747 286695292 120439190 173964576 10696585 213891303 620173030 853092522 796589329 639755723 969058128 304795191 601679625 677727409 600774043 496461802 839410182 52556164 446593646 460473899 46667594 677477417 841357050 622220438 294451380 77267226 482893502 927365267 283765557 139042392 867237584 879804772 125459205 907178194 831027578 664160018 371745440 651880203 15006297 843395382 639470822 556382703 838095154 931687874 816972022 530859824 621653124 136839198 367093736 603376540 179257964 330943783 244662941 763494047 19689316 12759437 74124876 983917687 369309960 852031081 958510331 849738089 447015154 822548862 634105402 784439802 809540326 28311039 803843682 106505358 855552880 452207615 891851956 279540565 862850343 874453018 203627767 157365262 783950456 110224862 251310965 482475954 157300326 847772418 482362008 122588393 604037740 571299870 27814456 743645949 654332753 293104038 611946156 191243244 788146832 994261469 536566846 887542449 275805662 197027232 816036840 904545571 158834338 347502670 198083579 542978843 858174364 390894521 193731887 399397798 299285858 461781973 412182389 750472664 866480908 141263023 831480750 312328099 38519441 718934780 129732496 962015650 770174054 108392761 68762512 595969076 774511249 144680028 883129048 540681172 3009820 55161882 763625066 803206564 829788317 31255083 101111402 195253899 190786054 584268089 820866224 151946766 361845268 200057226 882650134 815624107 959672852 40349904 456050748 947057250 412008178 122770454 846901247 316513051 45997926 751736597 133485739 265974926 669539996 7564611 762443332 206273276 687457764 196893364 285792627 333812008 618097626 930175378 746054116 702544132 53058197 55894779 675241593 10930490 312427446 197876769 257552485 973384230 46995911 320884608 871339394 838977869 592759503 224506822 23751069 79363440 694815800 341526841 26123456 469263516 13876722 860746063 736605453 961673693 686879242 466805797 20176824 704358991 210714420 977609290 108887955 235361239 244035406 333814124 680387999 254813038 858832367 282619676 354978413 694530207 70880646 967721239 14509002 875770751 776860798 438599697 338400769 75448215 392613669 814879442 593236851 868987692 662882399 873498702 869065838 296758524 188708887 92980830 777965983 400708813 322207778 761216528 231839110 901098004 72331332 212944184 443736568 951836653 124776089 849407969 52502520 694993173 697633238 850054816 902314205 675516515 709058868 291754595 691248884 229354376 643113688 620737047 57299687 644036574 198262723 669367214 717878321 198332727 123925511 428756244 774090268 410845867 434845793 963778113 431001652 287583161 80082770 438436109 389939189 808163619 414824451 822575614 707385322 11966358 163841012 228318873 76494581 364080754 336943786 761928863 94504122 653973419 591881212 600229943 476028836 50130044 936331418 489848908 272955315 323970739 281288639 863379603 711407947 800021521 976657914 234277995 407528956 923825114 673673922 506251546 375347558 861215902 268500611 326763877 444497536 917185516 820367595 645888146 876048060 772351790 114817104 754428424 474675198 450168143 161081086 809186843 808236401 246357977 603905773 861094643 204468784 715360183 908413036 848974107 824097022 976147516 263149957 917541913 12912116 653951501 975497260 142944044 296919322 702919702 139729756 134296136 135649183 638651639 200960518 822092459 632899019 677936144 391732546 395876905 737502065 694436632 724753622 718425331 30434908 901324429 359904450 895556440 889962016 30508691 639213696 943871847 165981366 167715589 365362594 884142832 949070085 426717118 402704064 158959544 31550945 139011162 616190549 57039591 346723834 522025757 472903499 516400248 976270493 205670191 761632152 470313260 292456496 763536227 604148044 814682473 338671910 427160780 203952174 975340207 935721652 289237252 493505083 284510123 592808619 222239225 8300852 68906187 461871556 392754858 485133780 507146010 880356196 444315554 469825443 5963407 68086527 248134023 498496792 209640805 630594914 892507429 786522183 541297119 467224945 638562301 19342716 587976122 24774055 253678238 912030415 615961442 94249991 589612088 461077812 550084908 175663314 339182337 611134858 673784518 823162938 850545432 610176280 969671667 735710866 262654469 966355633 66119524 496136811 667279842 896105502 238277005 113611754 249965422 665607255 352053472 39779572 253261724 494005508 909564687 973213183 413832516 395294074 722870080 360869185 879417825 136768905 667630400 179928953 168110488 437558672 273689753 171254339 565630492 757288309 731618431 704287401 204847243 423881176 999319252 550787079 27402891 652103685 766434311 369095508 596626004 704586063 891290474 955810141 595863201 248438969 325076208 937338159 985826298 682404337 819722633 652855903 746668209 346358886 267543906 604063645 267410902 541349226 8427163 48322380 837361894 285830344 900314700 831169495 537816355 723879497 578348801 566524597 840633659 55236863 963903702 519237516 92038628 529642831 402536747 716569080 270060819 416772841 933477548 406224370 176070794 776976757 213535551 636990532 401138121 645545479 833941239 215826689 57084075 354226837 333423207 583726180 850950910 862853755 113297468 287652170 974640294 358937852 253892302 451824411 190972675 887890463 543042682 612338616 267401855 74733115 388667772 557182360 743599769 329922042 496606535 503369132 452739118 707829338 279017911 413982189 260948001 32012814 230636143 270774689 213178801 659285389 595962049 494747749 915937314 444732424 581311653 231855738 544227255 390839240 952564260 364342945 209135870 986761594 914226800 697942819 37788988 621952495 588265651 778032575 103108127 47538912 538428277 247820045 457981748 953807325 841214961 188822961 930724679 404624660 997248383 936760006 175229266 654875203 96955938 828273384 515060449 979235381 295327996 574415830 12438882 238381556 879357423 211879187 73917192 540494322 313780224 788568338 621634262 665733113 268500242 480285782 938124514 184358392 821462454 351468284 81413659 73541059 761491360 113439619 857410834 230327563 349011 135083739 331834986 847077346 128388242 502972504 735088878 551565446 236815497 876198922 508887280 312073028 760134099 161527242 383509381 825825 753237251 251177391 490780318 598985975 410341880 339631802 257592104 335079266 268458228 319203333 455110483 523017006 638490520 718763051 512714155 387519661 816538296 22507387 514727224 889052291 467802076 227675768 57381330 53687924 385698555 264733134 859121531 81092823 470158769 301790168 687389374 104748525 424967137 631636882 470367212 764858029 706544172 621836177 83185849 881306815 83319122 122581582 557219126 451286590 94666912 45410549 274749596 539712627 682559820 801030677 894473815 497013990 394868869 431016675 620162068 265199629 125160284 115702203 686806032 398009309 282967211 930714005 640731261 783527762 254891904 725092696 727651269 140548542 667955098 154548815 77534171 578258765 761348175 589413401 292184521 670816818 856863847 588514019 666349551 487183111 496546112 871052771 192297257 66366718 706458305 27945086 552999312 147603707 958333411 234939912 350993849 476766176 192369143 33606937 192235023 237296496 290293983 650345603 929015162 743329488 853978638 99344826 318533468 24173105 377687462 149291578 908279382 292652570 333039534 978538456 726590387 288001958 636708839 70782687 579450308 404438356 347914551 798718107 726018966 782625352 546940564 478300393 921124043 935596600 497325035 443539128 682560773 614373632 201579556 149962154 844091236 409412472 58116132 914029465 287212920 744469397 851750804 913717440 415810557 936688376 757734646 201545161 105029004 317071845 59966964 453123373 256769046 944451612 825527959 655914540 273652553 609563556 333864017 385483719 949278530 879001830 198503940 127352134 696197740 688122613 932267307 507172291 811514346 765923932 684117331 301953397 653507835 736794595 24529072 234855526 964300199 670403145 876004369 260216325 642298369 678988901 768697909 869220163 930955332 992442051 765710423 979609619 796421060 771185097 969264025 914083468 735566830 969379795 501189605 425834402 797489914 227606950 630378470 863325822 110458905 135993742 563904632 121691425 411150647 694831231 56457472 159291316 960111488 319115091 134897518 470123595 937066196 924080716 908883421 848873011 695681438 39271897 482971461 22849303 243433506 378166372 390865319 589736690 128727581 635262415 772055048 258452470 393582041 958529342 286178326 966736104 941457978 690196248 659175092 789466101 640475635 127175051 709048732 794512663 209142143 700429075 939341817 171265998 512456382 27098105 747494377 324394998 631469265 847887479 829342198 33916794 749672011 19258503 588614028 604793112 418488432 220022108 209087898 259079578 653609779 415361049 866450981 470541320 978462834 865512032 970231709 16497380 585887754 417452647 172020975 493969822 829372985 288501035 316918816 97711221 234732659 250084257 241747162 704293330 636687844 777172354 881632498 399459287 75948603 297740207 283397797 616941872 316592500 172221334 978192742 518809116 3787298 190867488 536866384 872972563 949633335 698693457 48748291 945474229 712252064 415505138 73274203 383343651 875028054 116780445 827818084 342513067 935253614 867105127 204789932 363282496 695298189 754513527 101504778 683645534 432830389 264970975 374750756 727727900 791284087 12145992 235565533 296660721 966342201 162421613 806048211 287082228 948296756 388792441 200095548 688828248 625488597 779429960 928702084 612527995 425024774 557690564 902513132 749768844 963472913 377973693 845932276 579919760 498299849 384033198 27491506 608244636 114958942 955018199 321979836 696086166 999534190 323498404 825735426 790703055 777803373 941506222 424238161 879807397 72779620 810914283 536344078 655037458 463722452 266910317 434801269 157612277 375036660 867441878 253905865 517422022 539155660 500593118 474361427 545536637 133426928 577915130 211391677 153905073 16687179 497445317 294921741 64417052 621966440 900129600 438669597 301200536 103583131 624272890 235135397 57553422 513977690 296271885 894256596 301791127 450024110 619750283 560449726 124055132 498240846 500411689 872393893 866283403 537636852 605155920 17814805 598550758 985803230 740814841 402449764 297192886 704479388 783052443 516310412 721609258 628579995 965733145 237551327 998034222 771790411 636908911 94785043 466147240 813156478 759849550 8846580 241703033 731078944 499360347 83823772 656626991 316100366 101182050 843403181 256392963 344014402 402007468 60247852 733385999 97020190 12807426 582808909 966707820 984571517 95404092 596167972 26921520 81879868 109624038 145994817 108063733 686062939 782981917 151362398 504378810 537469302 911797587 650897570 274363744 572156776 406830937 745490046 598741170 583838861 958753810 975176887 122106101 763303362 852033724 900408496 92411621 149906902 953576130 539487223 973925781 532196239 906039882 1408001 685353475 16943362 450784909 250434074 898981413 61819508 362434876 899955950 375632418 664108571 638299844 436437610 996219229 529413114 870463606 255646356 359004634 30503149 445789573 453113369 53107009 141919524 7679895 619019977 238876494 667736670 133937846 647790270 607892455 245448015 528674527 774113 123721407 831457130 92497183 73431858 591057379 704667582 693653361 122186700 542633200 748950784 9501072 719963815 507886987 573358597 845880358 770269844 652769593 169371707 250965570 234990554 714877587 859149546 561483940 951242215 78283045 186279928 854202663 422847935 314029491 450585041 676104931 454791607 626359055 643827703 681289159 267102118 428261659 127201127 756512976 20950019 569800058 51886364 174273446 493770863 694509462 33197507 922512935 984583009 639874426 456798738 52074149 646643188 455516060 531321707 215351748 166290807 82127025 275655779 347066063 365083565 426541852 980105666 192760854 508054180 58617425 189614001 277205852 566765803 529750064 869449210 716681137 503025556 669152721 84176541 293132610 215571869 482506045 187593299 777180090 466008389 565863333 240001086 478048357 201680936 98220 480092780 532268140 180303884 409847106 825260089 186247626 731723404 737125467 679888458 458827230 57156976 824347262 172830015 649963958 735901088 759022803 780151855 725678404 50371833 806361961 324449882 119007801 669252335 331910534 174731416 230961642 402273313 497753507 980218413 494776359 530058425 54133326 930482394 617404440 618257012 422817202 516878272 353600654 665789582 578109699 224710701 818972874 626313082 397218184 830103098 796568520 510651515 645835164 468680380 854947498 383734945 838921953 478910284 298329937 205763176 789184978 969054617 758110547 470408485 885965258 808597713 147991959 592105082 853197283 558691491 273580240 255297693 105833546 92209835 122838960 124832685 888061506 287306376 36565032 197544800 944180121 728129951 711164601 746862950 972445991 713346146 958837307 60122291 674651157 945963572 171913632 135562535 897916564 560567304 705776490 759563105 615024072 462625418 943631129 74067770 349518199 791595660 845989353 756252758 838211220 139057987 642985040 443525743 247383538 394675024 670856458 343653275 558917107 601232639 547999370 134888928 491084031 3092874 74269345 42940203 494619664 930652983 961388234 91645043 161211492 491567640 334932106 75742614 513979474 285358137 63698029 236755603 895356402 848909938 324565717 167224567 25387229 580131453 50159936 118731103 284764555 920268389 913901027 834390143 383144639 939732011 502321783 103668113 124542197 106646025 573984043 278607236 553005760 384890680 501995484 65583601 211897732 271464620 38153027 597890190 771184160 729174282 831561444 387363181 562057664 305582149 452392955 2379710 391347472 944379208 29370269 104625354 394078994 437241622 225629672 725127169 580949695 294953149 917611709 150288315 366919576 957923359 98132322 695114515 175467377 667423829 568668758 25646551 95039717 994808357 968114216 565180470 310405652 215359459 18390751 692212099 503982369 858726604 33201819 318258210 252216957 74001955 133661815 455522366 651987700 512565865 123799934 744632632 734342970 266046486 730793726 291848041 905454445 425758768 875268646 787754046 460122173 793246269 814354511 20352219 414114943 297622821 875085052 402118380 72888369 129551840 99148282 694701031 640943807 516997145 771074030 675106358 924954170 588066871 658843069 535138512 626433354 383803245 647297107 250480102 429380048 552779798 278965845 186345628 530708783 35192482 494169972 527121184 847630548 335087452 170587917 610462448 612345819 176817390 599457997 691497431 234405539 164298302 872060300 665099557 790567568 712307451 353404428 677057595 751593497 812406360 342590677 997572603 786877435 326403186 901887097 946607660 361487218 560839086 741886814 429721223 382405578 785224895 906106233 218223600 322808894 256612530 168390684 648910279 792670141 721073619 37529014 374947662 408344816 261422425 246283159 258621543 152214415 137743807 176368796 358008320 958937647 60545646 194095515 828785143 814144949 686098836 922660769 922283520 509092110 697795399 783831281 183734202 789075067 925091004 551058626 915277335 669846407 528400098 919879813 743404754 158996358 605661414 316192779 638595141 594661684 400863540 29045035 589497088 975410004 328729753 514504428 220323916 668193600 545063354 688869660 961955570 800978367 35014876 643845851 539492944 353265615 995156662 878288461 995217263 473777417 993430158 485741126 298029112 771198897 978857369 948997648 211119342 497277489 887068734 461898466 529643166 896528714 772623544 425356013 752269980 471091498 673135521 673105139 83383396 316742556 125913254 411773637 404946169 318456855 486688076 460052981 463676040 881662379 875517226 649722855 587774662 276936055 453427727 175830160 52463786 656795585 735329749 415015655 652321120 122365335 60061854 988078915 596622946 790445058 208480950 200802475 18242602 577483501 577313658 217525185 609498287 883595697 850959001 782877523 452162849 3504139 666580442 580424489 936517950 831920062 994177040 877653252 653817512 890964310 919890121 369536902 315850144 220122451 913473211 642969230 421452032 605193340 225717900 367925147 131526080 173582975 228386775 583164721 481765008 653078292 373523806 434606035 401301580 491196229 424850322 304678544 183199930 519362523 910425210 32097877 861293311 325312699 367159851 569847337 136751553 739967277 901623619 454784370 646121327 955827880 841399792 28864958 209646901 990380712 101459558 544211352 831334093 376773864 720074479 590489348 947342988 528094346 546184165 479769460 6716658 586613326 992504131 164418685 699077404 674239530 265376301 450510985 449694181 58744235 530389398 310762880 530281965 170984627 229149320 64990325 901301117 201394162 41336432 545522874 614493217 532283218 127650708 327947696 958245944 902974919 542605625 27746567 651331467 688106832 311779773 773444516 722456135 114554491 814843964 475299510 255693269 16139533 353710954 359698571 477674951 880007676 746877226 438186539 25913324 477370153 924575159 407729692 972412698 148197249 993580282 220227346 723380181 632500166 810385969 86643480 596535535 824470947 974364091 688233963 673700871 434018424 215069650 336202631 116447175 676472747 1493909 643429489 336510423 965023905 597130061 381868440 792298825 243228421 643862579 21654096 160103735 855251032 164300891 457119953 567659493 144915391 362367981 632179912 324931214 162158952 979984559 930761337 765618460 838291794 459754096 877470628 272001404 564103370 380744756 788308976 919416086 117762465 310781059 801279184 906658281 70472393 997661374 659255286 858087630 996685716 334977460 873346570 192919605 417783407 37024139 456957480 664697134 854977959 867857114 92788603 332740715 956323880 191005288 816062978 293644237 136615515 231417465 90395083 275440573 850059618 524084629 834467088 828317680 300270561 784626665 461988640 173344755 247395381 364880565 547236 603697841 116036794 992323785 691103566 449875574 590033801 600935690 772351771 236259781 706809725 155199974 181866887 690608212 493878654 239249083 301931413 901880168 835651917 112126112 657774501 543308863 315792881 813433278 189552304 344368877 120114178 256195659 880908408 574433577 510015098 37958019 755945508 769032537 526089586 256840939 920258892 842365799 37584042 662326745 898363187 669319233 399277739 497710199 657126674 945439872 308891652 524760558 448342789 446145738 847941626 764580952 507386531 887753932 699050857 479043250 261079761 743512094 223451344 976644610 961373712 166603676 434590249 199242011 32760434 722587232 831309823 144848784 550530216 618020936 904912339 652627087 161156787 937061956 932772938 473237393 79506672 595078698 953067018 428999230 96572515 288624224 288899951 593331936 730228236 102673148 928306484 32781058 30955133 697003198 61248811 900835516 140243860 201643902 824123620 838461207 17059950 816886980 68676403 719646257 97383097 991810343 261010816 445137769 733605382 527908514 739781696 118638339 721094506 79693374 254170386 712447063 192323247 854022402 894279161 132031536 193694728 421874489 358208175 643747988 633139218 513575886 213932084 482806554 647860988 274148502 253543865 169717368 326739398 626919439 577339074 366389609 607090525 172751746 997108854 153872654 595001929 65623413 653526252 709414325 603626360 333656639 906943780 314741188 307490747 449604320 682709395 889494418 714924467 852644555 230204173 317159661 652044822 385606743 154248197 83030492 271616727 435093834 923427834 791886573 938928678 110799328 799442038 552508437 870845795 609424779 747189960 563684966 898281821 57429086 172803705 889234151 257806242 152170123 397292620 763961236 303955333 442868269 19780634 248679758 207768310 961612879 796061535 333602063 629755049 624277512 755063266 795226879 797274446 555489224 95134906 175969214 648073126 219006754 731241201 209635721 272384538 712217402 315436947 240598893 532813195 513734628 984343460 51784206 404490758 962454463 81167505 322263842 626899512 263315042 873621586 213603070 369607206 965257809 700822656 869582596 710002550 370827139 622651212 764602864 213013480 191951865 641452542 468519886 17484295 973001448 320304302 127256490 594969842 738023304 853902131 876390722 771478363 729799003 508682027 27387365 398435155 731204153 521011105 792614047 327583075 133898887 803398864 933294002 249323525 778827122 836024960 379679654 108793633 14580940 809119859 578905207 607236074 127775412 883256165 97756159 963178119 435874987 650085650 628610619 796401467 99591667 535174813 47811271 853591707 819049472 236057807 488667809 849048245 929055949 172848190 96044575 513788285 91907961 104618420 434653233 285733539 687005640 376424196 681190924 314062250 521429665 113913696 271674284 753977325 541828530 682144391 241724774 646953753 770926366 689451749 314916945 39652948 973068323 966948187 140787640 416545673 97546864 68973466 574188643 115364384 91853062 555477984 252067362 763480336 795828746 222902644 9357329 918793774 792991776 676438120 92678796 112384251 680058020 268439041 933567332 552290521 256367934 565491739 339872203 311461781 669120334 284018851 930801268 502360861 611698334 463770681 204166397 202999871 135939170 337646676 604844131 880987161 101205471 986358996 845369342 950400408 83176058 789147717 53504374 566779754 432750402 47241253 104291020 403953882 804940984 644414413 211708434 540182111 275993951 850441565 870733703 98820695 564461874 270675427 280306427 949023370 897131968 980115034 742388206 331043774 231725846 968567598 394285915 575273316 152524885 426600758 735492827 821040741 104151331 226332557 810356763 748095844 225305954 264341047 192289662 126388157 344326001 267285972 768726260 253603709 721583425 54489283 824957730 513234299 682744115 191594150 268113227 352125411 826107233 506406344 933242214 236385884 161132464 471589968 250909678 908281709 981469823 31703089 432402918 739814661 732026758 300827758 398032414 216318693 923944053 988818716 572380677 932810829 585717350 318064172 972931153 55498294 156875459 423585431 358109232 569748587 264794529 131344820 359424800 562400096 448205829 315334405 866465812 336985508 546104787 909263409 379214909 905536001 246510471 798091374 253285732 271093787 736569070 926834250 836971915 750225697 96317152 890129621 231351703 948869395 485945361 933977691 681261462 5764697 941488479 267444469 995040023 919126881 361840062 555582825 633676374 550762278 627223638 468070339 43650844 985941239 120489931 329271629 300273590 823385993 969455193 885202428 329250575 118155995 791075448 726835148 578744769 987393656 405120746 725093775 701294699 664187799 636564248 941990421 489380662 168001794 212304648 228858878 502275566 880012425 799053955 189812023 755694082 408258787 352302117 757952175 45817678 586703678 72836188 391267440 659971682 414441340 350277368 880500548 5598546 190770720 192539277 591230347 880608737 411661053 30216002 534327041 443365189 955171939 714942900 853442021 909834578 627961441 337852696 76310862 77820022 354119365 934503895 53830596 410808580 590875281 289299419 748126487 542791144 878515330 461667929 820674272 705118331 967437772 802130545 79723351 881372386 612734159 183872713 282174943 241974141 942366466 862503760 807691575 885602541 79419485 510889946 491978458 480971714 553173786 738074413 106260925 177053716 319266400 415497804 647990512 324060212 78415714 837208503 452509249 625963096 967384706 871693134 559551925 796505870 872759612 570090265 545902413 123920639 971517407 254221656 602959161 160621865 577288897 523275052 700022712 519037614 686945536 203390297 227344765 495713185 131016233 795052709 723886574 877455524 874437517 304806667 979656754 961997633 490889447 501953158 872002916 846867160 631845462 388237597 901993021 518301163 732037638 497161464 982371884 856130669 455712238 49768765 107994515 156034736 902914356 467213195 903473333 280280469 749834424 487030396 678341319 834119794 837542222 982587959 724703703 32002713 957381700 691569191 340311448 999240018 299013303 870738853 449749894 785037897 774514638 299851922 197578406 133229656 733157889 700496542 860341661 496837674 678663332 685076044 712135318 141162334 474974865 801568489 390847419 499688150 330250207 841781789 46937858 782477890 12093482 9485556 595524872 163815139 112343135 2447168 388182285 547782261 266463330 518799031 786987242 47244817 785194789 942548423 3110697 803887860 143229241 726903358 619256675 576317788 463828885 882717036 970692182 896284485 645415859 954061195 694755782 117196396 581675906 893326525 152508962 463123759 237537877 441653286 946003989 354550619 782362805 341453988 928314761 810316224 499613709 544425525 346628205 238900718 284722792 494987925 333036680 513309065 26986441 988359000 390483173 433198042 771111236 901022634 234723712 683765782 619110043 56591406 835793072 409337754 58454217 604896198 726614281 468440661 371344438 80952088 636366889 982250905 975625113 259176972 164207134 483935544 31074721 964350596 591442760 503032303 434501372 254686645 627123346 683620985 247316512 85641785 572817439 345500450 434546960 488828987 955089262 715517845 197111399 144102065 209576637 796614193 831085655 983982207 415475731 464854887 128328914 966856192 946804071 512845166 369608237 846039013 555279228 333352695 79063326 524507104 197222355 189070017 961140811 512395010 50429734 666545940 343288320 260215708 321006184 862596879 717879063 211809047 418939205 231087362 550111070 52489927 382209601 879851682 979213541 315968830 819130481 598186851 258390011 686330659 908903885 38913701 96669293 275671172 857649608 481702849 255826470 892092120 604894026 823623402 82955204 95103608 643114726 415789550 166826472 342643212 801179040 932164901 541307003 728959575 485914397 637914104 544467320 505943986 75517557 826964288 928789913 859545592 470531760 137252965 175468635 358398943 784146209 695954017 115572202 108668615 142371003 649261792 241930458 274448575 753713504 972203122 901653814 896729 715290693 47530305 165538104 346578115 480019852 121621625 271381660 548473952 659666368 132667789 910878073 717251760 901389589 886400409 905068500 703358179 165895684 539931329 495297811 677032385 122415897 657757144 500837777 2360479 715062257 79488548 356606219 510627402 376428282 7210067 315219471 749631709 350849871 303340085 227837192 353729985 17923340 436799214 559331182 492702108 893062862 757866682 81611508 773132980 629508357 347865635 866066397 802614277 417405808 103116376 732967216 729204759 807753236 712909208 175778295 359073708 896628271 997493875 63628096 718055346 820396914 418044638 488958073 411460677 541729986 960435317 903588230 491956348 119633159 418253849 652319427 576047074 827030012 778291228 56508469 265167349 292830188 955232715 943867501 172360799 635882804 534154833 452062441 428166935 584700723 483200912 746438448 232691071 11141350 628708154 234270382 367153141 777503222 192980764 159364895 998708804 209120695 876967341 896322783 763796162 970189510 798882516 301249600 623830181 271242678 303563382 524743529 50917188 794001872 942196453 845995324 477031977 400386213 715371974 328025953 422855796 214552709 291074398 639022579 363019798 70757691 925001980 387096918 469035041 911235953 409481177 55731898 720451708 681921963 883912212 360602741 650996135 317418981 290678479 497014696 392760206 349902277 301689587 925252996 784147473 560940704 22698844 765042083 576572868 451366957 964127186 978714950 981276810 939770940 453500367 363418949 719676059 749550901 690627086 122112816 771720734 164730052 59677563 673566480 298762104 797150047 669863484 140471699 535085813 319833879 918625987 623951808 903412238 903972490 621024072 616777577 483846864 551460665 276668965 308519952 535003475 408043088 809039026 883981334 312018870 284867640 902066350 586851616 624038392 121399330 43923688 430935431 45564300 244929397 147375363 328924085 215794065 95206007 817834303 858409573 663715612 205385474 640260807 665605701 940434067 960957812 270540538 898188768 144452569 801344161 641588878 835474580 349443120 764340661 654733382 451977266 242212080 777824950 352946729 215917738 621577658 145117054 339287708 296108327 536004220 429909333 613612789 823009178 850091529 397779582 653654132 280583097 911583856 339617629 301870650 442434918 704483699 283948667 174231638 942430893 685972092 143555790 433656945 45837596 235870534 63232343 251471533 352284525 281137081 589148297 630024107 174246090 310986014 498324769 426531288 891925924 621777732 532670146 567917002 117901555 666344277 377312961 539974290 681216402 482028350 420598190 314014278 188263769 70937227 83933961 599112141 594395188 147844085 319343488 333508363 415189605 881509650 369668277 582548454 975872024 16660998 172111339 743036831 4588761 545633701 855618224 42758213 259977339 836288189 545818822 502322656 817976498 848554749 845239815 782202201 389643829 244277260 504867543 69329061 532765628 137891112 612570760 306920 397818666 19278928 851692923 953348639 244347956 276943768 245793489 754186886 778023530 345461478 986370850 760104128 353166528 20224529 231383418 45705636 37575323 399977176 944898639 817812038 212617947 226677753 942534319 543972845 609599047 146605902 979596559 387479889 870908933 339151585 142054313 366799312 164548737 473477094 161421342 26684084 600753209 145021661 355662824 98338707 675819748 691471109 954175297 80596408 658898737 229135134 787095285 293319147 205825714 325085836 380149937 654105577 52038779 621528587 359875117 810451541 164401837 631167876 906370238 143200423 867938002 7996448 476063647 540231334 807936610 927141776 643339237 830297386 921319555 516872038 2168774 564939960 557044006 361683572 506019356 402374344 54037222 890270639 22345999 722933025 449670831 965282759 30344079 273707098 859989332 20945815 793738582 992610054 392603657 790485185 587180782 586369206 856284693 595298620 283757180 458871572 417157031 204538934 600574905 588770340 499841547 336046941 676588819 268910131 224755110 777906406 846845348 109645328 47076940 110377459 49470110 679178911 241501666 459991660 34553095 786720823 675536010 291284539 273079878 668899456 470758237 424021820 273111761 43463130 269552407 131867576 444899625 704886053 815576248 932238513 538102615 304510251 875043471 696109340 723801145 603469925 507066295 288983880 404169479 577540383 976826021 518634560 899675701 420101622 298683166 703981197 401482072 143574716 599992036 443289963 848967597 167309789 948828151 458949473 935867569 265521598 131989971 514745214 266202710 452418322 124928015 473031134 270752717 552495252 816065256 423674743 952914192 106065853 764394969 272742166 272013493 372279910 793916889 656885445 297388478 194693261 32027820 383405649 558492476 856589793 607976253 726841602 696387647 686145948 985688142 940254672 638708737 574468480 596772881 887239141 557898312 945936608 125650401 532509551 458482235 56770079 352090494 101295533 884098103 293658566 454641070 561188660 886132184 385474870 32393194 73141452 90413779 111890711 770473319 833337956 659101497 261620518 684204285 317846006 189549049 695954191 205597237 479838431 658382313 672434886 158413433 127261031 775790682 701957459 896703804 272229138 161038888 430587225 304017207 551000189 177507051 163199803 45925948 803652909 487240874 459671644 278180097 81789188 99704877 700197143 726082516 182003736 858290127 671780632 121021231 808129837 891730673 379466246 428402899 627165317 209389896 584401696 670380493 825062845 893442096 287273445 811061824 954847292 416203441 81675819 161181499 548238391 106790709 505193357 1736374 477445166 233778600 597733496 408464116 835430859 833597860 47738039 510629289 779027877 705552511 409224102 137152191 372527902 273208813 420909488 768380552 150608362 102091118 464097797 988047432 10896066 432213926 727505183 623686431 97373482 799530598 609827513 3250521 352960701 256546294 935432000 19656592 735900050 404277561 621041520 232191138 720483652 73854813 296751132 161225617 791633348 133103981 258881449 525256657 264241443 53800039 920580147 315327831 539939147 793201172 854650069 381912120 873621486 438180012 528540517 734554527 539770343 789339010 65140137 766145133 642815104 930949295 500510800 860328397 263720746 216703791 42827043 675915206 856640326 525868422 755945090 192251343 538730017 125707967 399972346 606934232 728936155 729301483 793249739 315955241 915404929 371371290 604339500 275816644 824955936 121617798 575287062 433672773 252412177 934033783 524002086 286266882 112039581 928444454 689875072 568218680 960372911 655218954 562360766 827437375 276584658 235497049 98462177 168989956 620134648 715540822 690084360 633357757 506261445 924056843 858704931 307209437 521898121 750990405 977579098 117138815 982351094 225575530 500431713 579290638 412613883 860961435 559405456 677996847 143536111 232354926 930862255 318320722 952032757 898151850 606900893 766777548 993524663 3020885 79980059 81867042 848213939 254081710 667764754 344269474 426154671 736631644 44333435 288074399 933880509 419578576 1754453 394344061 728911405 68096337 444980875 925106881 606824858 644001364 30430578 385205716 415777463 282081765 537058201 605338466 792611069 42240277 810429039 153796680 828994534 723972510 206254103 944970591 50823459 210039048 728476170 880938235 165481276 689179576 76669790 67936066 186306669 73620957 497680448 87095135 268617079 245660777 114126856 702589835 757776524 351684486 700998943 671555795 328799769 221196709 511537675 778112373 297735837 208610015 79028964 513866096 480085037 201708828 960475202 101537631 108480236 395954762 232864934 998778504 100805803 530474850 51570162 843692505 673863804 793694979 262631177 425184887 168333800 788168687 372100576 118015430 623606861 830709914 726533077 232353117 694907351 671941866 837093661 264642957 332451918 96983781 940107399 995037302 591209529 458077721 891688833 239712678 180341792 634526685 302818320 232970057 248589602 530647016 498487992 171285512 779560963 654663437 981286517 397995044 765268754 463289529 178945768 956739008 681437686 238030674 931666512 711787938 879129305 183932784 183412677 967244379 728956675 327657993 827411230 939923001 651273205 842091506 68887832 775889160 747990669 956712088 654760835 401968769 717310562 872756773 287721611 976289514 10879275 15596998 41658615 868539597 815061931 232929367 460197748 859667849 907382851 392533696 255848516 669328606 997456747 25877200 392997140 27347836 813916728 10369658 809882650 827785533 593014922 93061097 219265631 950653517 201915299 953329891 492739831 789949134 383762716 223687756 790746816 454779051 597882083 204019537 787207201 164710948 7167036 269168782 716627789 61004553 858079763 6911648 424717867 448505640 197007606 747486637 976258309 871089313 617040335 461053617 344200516 71648998 400108997 186763646 367702897 175582021 260532887 845467004 336169004 282080649 945948384 676263820 913664082 336285878 372260720 389410042 218898658 178476372 928908634 565146975 360410492 968946238 479228569 211356669 349333374 885439426 776547546 144586741 631561279 3163284 373604210 832830488 230620423 904032303 68207650 564723452 275459833 511697758 680312444 31174998 988856317 127469936 146294964 687643036 923026178 358366665 152167780 267366837 265931537 899942085 93971936 60122468 607110947 739860562 875591336 907744201 490200015 346932790 593098403 379933221 798431866 568447624 944212353 595333289 451251155 423441968 893094299 582539892 719809488 722922080 372103355 968130662 413709191 820464014 73791639 151340338 953699136 941705574 691153707 771666567 555253074 573058168 631687359 511914452 259402353 585214944 552162272 236467101 520961600 472581465 292848355 525640327 125704270 209255294 774918813 190132264 751751444 524201498 450587918 48744319 948183659 783233228 866037925 576458313 47594817 775302974 23823196 512339712 992692704 483620468 574879000 575758938 560076910 961357268 803383999 50630261 939954349 867459567 490778189 891328614 304200595 815330695 54523191 894859225 386796549 719274643 214039006 490413166 958164501 779077408 980349632 191269623 296294926 998611846 718918670 888450826 338178375 649195237 133452127 887960814 921580625 726556761 172106987 65471181 847394851 712769382 134684260 486522849 803152438 905820791 190482182 832643084 962396098 556130320 979892975 184086304 263739706 175791862 482267740 276692100 198006387 986460994 870266319 476794985 538408421 785718328 434994403 468012046 316013416 495633490 504307704 948717855 840574763 563987176 906941107 943984364 459804641 592573170 40243940 460659747 60000344 685175795 998692133 154966077 971867988 136100483 556965009 957355428 272912135 703651801 474960921 644159683 146435630 615817991 628396251 775279645 853566840 109648921 881516596 483030237 523683180 722967506 158745453 495772924 962647001 672227862 793825424 139633273 571836501 655742872 830636639 204933141 655391407 181391841 62230335 953312740 850807641 76098690 562006580 551299956 112164625 395100413 480774909 581078217 895102587 191044286 708834114 887932543 716244783 715948996 709414868 457798757 439198770 671572482 544413730 510796384 591043118 759123018 141785263 741890734 714545630 449428310 425343437 969106886 123142629 865070136 507104402 345435952 784395608 259965314 701058388 478878403 768317590 530080403 865676980 26366594 264403069 256897769 781757751 335600844 661885085 376509867 933664707 742302727 47693246 473893790 365452899 632108026 405898910 218417500 414161030 517375024 576489840 833103871 610489093 79885280 909536365 158883916 282098943 226707253 522231015 939059876 253140530 629379659 478287545 705478540 133841145 261527707 232945868 627616523 841324745 223830588 889118596 584032711 88276527 964910486 768099919 490474487 599205285 913847600 568727075 495562329 425365697 567406075 305732237 373796914 939151651 403927024 142268694 342205221 271039388 485762276 143753412 337897363 238461782 376523455 954635939 998066783 358289926 355266567 232598471 843374351 136198751 642935410 952123445 430934676 833423913 466922020 128776538 469660506 452397743 106355532 20292613 30498947 316680938 205188066 644075179 199808568 975701730 36871749 655483679 271591411 976966316 840762566 327932878 645899019 736884500 760444415 356271887 832619896 677190581 890711086 655098679 936512583 272002441 353453864 978728386 667277289 429815582 58707139 76149123 193993643 972703874 159568611 675404713 986691526 932848861 653901657 982206601 640739850 565318388 356871847 158124333 834873827 713827502 650747266 162172013 867612402 161921029 763682780 646503643 370155187 554021891 264807380 182689129 245679333 577128311 708443699 294054577 72306912 982164362 560767656 618616394 755181977 699683974 515461526 278729285 579233434 561275913 760598021 70934383 463743362 600051513 369077600 628692791 448590489 408320184 250547759 882937229 455716806 375555505 527850505 307511773 437875886 782702979 245950652 994316021 151255957 511404892 422516235 715859975 344519874 510835 513366715 324626472 51125915 456909643 664016273 587101542 646487800 992963922 615207169 512327839 177911384 255880218 713354403 188099720 141601880 138368934 593544730 713283371 426824697 119911608 630239756 287307096 954664586 32314303 92046276 106423456 898738269 424516470 556914493 375234978 195502762 925410291 699756340 70838430 626246612 881478240 597560322 231623974 277754828 771174103 620586825 100193271 95069418 98950115 102695048 732739808 112844841 381838748 391547855 563236297 629045870 580554001 160968740 517199457 707503326 684528830 286273756 615057212 18874769 561046032 567701350 276614325 565078392 148399514 691166530 828303973 178608561 193687526 192813124 667656457 150842505 286813330 993154468 120267936 600678313 910126864 486173424 71639060 323261541 275236938 118747871 623886416 913211893 443669904 638694454 104926496 868951550 515975587 721209743 763442372 353981514 811235117 288626631 615055089 916206345 268373508 218134467 222833912 417652792 790378158 926106613 620103899 361802457 275274687 950644779 115381575 770229359 339059199 731769364 170103101 597715150 616895114 174045544 890144991 612822059 128183469 489593259 483304655 58069079 778364043 917587137 172805143 817582263 279043824 342001964 304488507 682451475 659244413 994495315 362764829 255051816 947592483 382037172 324991314 2629620 929889145 318655556 910814608 125971115 907403427 76148748 566457384 482182713 997483998 755816140 12547916 920514837 404779159 614388164 508206673 429428239 475909421 893892236 96584333 503474630 293939551 104305922 361118777 744385907 481545827 191765538 575809504 242255750 497746856 750403062 513810371 633307807 83680083 472741992 842152334 624975853 715392511 700755734 266005549 900868669 422435615 394939984 120349705 517085689 891784047 463918558 779280794 257726993 379878820 444417793 553267829 445835344 952588130 556535111 194350427 513071706 795064884 822272158 914440970 887596443 922683886 649961309 545348183 537258362 113354217 754309311 541889942 924270837 925339192 252196591 67628755 345290786 412783214 78318228 106907248 374375779 280313704 759489333 238840620 684529578 715000936 236348075 355371072 497617445 531593066 346149634 443082986 765379190 862678325 89300852 37567028 348717645 238695614 758919866 584537465 583142010 464072625 650411697 154215192 732838696 310543708 144810321 150973236 18373388 599521936 242812430 128985802 81129706 349645414 600319196 604127558 439123603 429523029 82164714 992184822 302313394 602481380 990032690 259792174 105404443 668745948 107604147 47236331 943155489 715726168 459874236 509406616 387367415 678642633 507962546 810031811 134897454 173806170 397585920 157744193 647761809 539208096 273595781 69389618 50357552 648403318 358495430 486779168 503821924 401190222 526096827 610167984 17170978 458610946 798452053 731563911 148666532 536255539 647874342 895596128 168954556 867148218 97948837 704598600 748179365 87583894 750925668 703158728 590012937 73768951 471709454 215174218 7412265 626127035 283262916 894759608 166960698 882625460 554690650 670061399 546395290 298045692 667092004 827981455 355477028 184219616 513582358 155340160 571468181 126349254 985819798 463450210 583686746 752410988 853553275 203029133 666113623 759848863 530549191 511315627 794314178 153777642 643083477 844254909 434434633 104910892 612931898 916917484 660554459 87246908 97455320 909177950 406853114 885595342 260895434 660639931 496986462 421046221 522853834 463424591 279935300 154166306 384318566 997077178 811915029 342443636 430976965 546185275 301458222 670951000 116342403 388791587 454257493 916970166 516147848 244006400 762901186 932327547 169225246 60138483 631305140 921863918 644215365 703724706 42989862 662017968 587586265 139115296 250411957 435545154 438585136 322703509 728994729 676182556 966319539 700882030 546490002 252090135 302102741 625254668 862390300 680758917 492592401 90219152 154532097 46077530 714087876 818652022 970783856 83311059 891202607 499099190 278022977 741683326 195040448 617939952 818893306 291437176 527258502 79066881 432995868 155012767 604289285 801628774 124736574 22418254 614720048 403337822 338140668 262665337 417261980 739800814 642562957 882622808 481924893 855010177 366857801 801344276 652324004 846830439 553415846 337199816 873031574 474433017 17112705 898390709 43572752 640334074 322485921 97477929 745572544 22980020 514802250 125105821 827106198 888052138 106010980 433169945 915361890 310951867 717933006 90479524 566227228 213889037 897995535 459608701 95709930 349994238 290285648 473437750 680766925 880426266 74679108 3389035 192157109 910097742 373560868 774750159 211330654 827688399 636980866 324279608 411546161 632714553 553477974 531352639 272875733 740722419 922685378 175057736 179750577 798759433 486351453 950767499 650925340 285788333 154196303 2493925 492468939 923472543 791102624 846310679 859295927 542635994 5671104 817740776 535410233 918021643 72275181 327450678 412691524 714936431 680928657 495515346 230836156 732677482 534963799 603162879 224321986 635883844 613257875 148584753 207674767 317686950 264386034 118467772 818957721 376417649 18483469 485729464 897841425 470549761 822434542 859849511 26578477 687133671 359435704 687745734 985346186 964903684 86065526 363587331 350209781 784828578 369657742 61816993 798739382 193339088 855221708 87663765 387070595 317618673 431228182 585896662 293310844 812950767 958762695 948223455 354633004 393095283 779700760 656302091 903601965 90568927 896169012 75209469 542785822 717231117 677181199 646770959 333633303 636051788 282231352 534263441 82731776 187487931 553563380 613092349 118668875 366866837 68593229 526166976 742464608 718948566 430061406 147715955 212135336 321025097 69393970 187833078 944513093 815182216 965223441 204616150 389735665 38864705 863132136 45417363 386965502 794242486 371822723 453080074 154403843 812406814 727667074 105977819 280989295 297552454 59040309 871351898 814037140 435279467 32293084 417771025 168983349 864502057 626340092 631902005 497288556 651512016 893460636 150729966 34088264 477108505 275203655 13149888 312479287 554147772 996353051 128424766 207514896 106417306 482613338 313324291 979868133 825738606 577683360 295244149 964581014 129710399 390218777 580857004 740445837 995813133 387449902 403919895 484005594 755946155 567849635 849250943 232584424 633646414 469527376 445934317 992383029 414308071 144893760 734607906 299642552 333364810 11080369 952868569 79722887 33247180 962768864 498555217 932298507 281140994 73193313 187732479 222393129 217357267 771462355 211035597 731117616 630921451 821193614 805575449 279023961 224866637 835691993 785534414 709481865 582062783 632452160 540406626 657663643 333630562 182422985 702890671 487903068 340141033 434194464 373626212 39158838 742753658 557179071 35761447 289355009 485136908 447627082 331438221 247846675 598014141 463312741 600779643 106081522 266398993 963381739 919271797 720215935 546712310 924762447 77470185 203109940 135547692 522324690 904534410 494760303 992332560 250597219 391377356 773819127 603846982 528092757 304884484 142598262 185748263 269619928 691879482 281621019 319227541 996083526 978048430 230080652 677621297 339929707 102829322 706165608 719448421 477025419 916912793 191037599 264801965 481331001 339821180 28555923 841408589 375678137 461654982 698478268 908995843 668520487 56648700 175185687 851070544 362591042 319946813 821305096 712296230 388621202 634244279 290282482 362997347 84187273 176742503 449432624 567613451 632408596 811576984 487081325 356709027 178462955 891868888 437301504 54134377 458792762 360091518 477288522 532892911 615294295 313286039 311563742 720192190 357706959 914633574 199627910 800323253 813664622 970667207 597407493 865521916 424897683 641565574 146729610 625113916 789044790 441044122 219648234 14902265 857983553 622005470 467812842 658970281 526206979 250465862 648980904 207825341 208716072 556708743 658171917 551699094 107142886 862661862 834709117 694810364 239592909 259465474 10322059

CORE C Programming 
for primary beginners by noslac haon
Introduction: 
Programming does not simply mean writing codes; it is primarily concerned with structuring the solution to a problem. Suppose you have a problem and need to solve it, you need to come out with the steps which will be used to solve the problem. These steps are called algorithms. This algorithm is then translated to a program code for execution by a computer,
Algorithm: It is the step by step procedures used to solve a problem. Writing the algorithm is the most important and time consuming  task of programming. Never make the mistake of trying to write the code without actually developing the algorithm because starting with the code causes you to focus on the syntax of the programming language rather than the problem you are solving. Make it a habit to always develop the algorithm before thinking of the computer that solves the language. Note here that developing the steps to solve the problem is much more important than translating the code.
Program: These are series of instructions which the computer follows in order to solve a problem. To better understand what programming is all about let's take this example:  $#!Suppose Mr. Tabita has a farm and needs to clear it but does  not have the strength to clear. He then finds a farmer who can clear but this farmer does not know how Mr. Tabita needs the work to be done. What Mr. Tabita needs do, is to come out with the steps which if the farmer follows he will be able clear as Mr. Tabita desires. The following steps are the relationship between the problem above and programming:
The land to be cleared here is the problem.
Mr. Tabita  is the programmer
The farmer is the computer
The steps he develops is the algorithm
The instructions the farmer follows is the code
The paper, phone etc is the programming languag eg: c++, pascal, fortran, python, virtual basic c++ etc
Here is what programming is all about, Tabita needs to come out with the steps(algorithm) which he tells the farmer. If it is done through paper there is a special way to do it, same with phone. This is known as the syntax of the programming language. Supposing the farmer does not understand the language Tabita speaks he needs someone to tell him what Tabita wants him to do. This is the job of the compiler.
Sequence, selection, iteration statements
Every program is built from this three basic logic principles.
a. Sequence: Consecutive steps or group of steps executed one after the order in the order that they appear. From above, the first instruction may be to check the boundary, next to mark the area to be cleared with sticks. The farmer has to start executing from the first instruction. These steps must therefore be executed in the order in which they appear.
b. Selection: The program selects one of several operations and performs in expense of others depending on certain conditions. From above Tabita may decide that if it rains then clearing should be stopped for that day.
c. Iteration: The program repeats certain instructions a certain number of times or until some conditions are fulfilled. From above example; the farmer may have to clear a particular a portion with tough grass over and over until it is leveled as others.
As I said earlier it is the combination of these statements that forms a program. For instance, a sequence of instructions can be repeated a specific number of times if a condition is respected or another sequence of instructions is repeated a specific number of times. 
Whenever you are given a problem to solve do not border about the programming language to use. The most essential thing is to come out with the proper algorithm that solves the problem.
Techniques of problem solving
When given a problem, think first of what is to carry out the instructions and what your device (usually computer) is capable of doing. Think then of how you are going to explain your solution to it (this is the input) so that it carries it out. Finally, you need to have an expectation of what  your result should be, this helps in confirming if the problem has been solved or not (output). Then think of the perfect instructions it can follow and solve the problem efficiently (algorithm) 
Whenever you are given a problem, solve it manually first before approaching the computer. Because if you can't solve the problem, the computer wouldn't be able either. 
Example: 
1) Write a program that displays the word -)&Hello world,-)
First, ask yourself what the problem is(understand your problem)
What is to carry out your instruction(in this case; the computer)
What instructions can the computer possibly follow in order to display ,%*hello world"&/.
From above you then understand that the computer is only one of the many tools which a computer scientist uses to solve problems.
If you have understood this problem well, it is clear that the computer does not need any input in order to display hello world, all you need do is give it the proper code(instructions) it can use to output the word ,%!hello world$,$. 
2) Write a program that takes two numbers and displays the sum of these numbers.
Here you want your computer to be able to calculate the sum of two numbers. The computer knows nothing but only follows whatever you tell it to do. So in this case you have to tell it to calculate the sum of two numbers a user enters. So how then are you going to do it?
What code do I write so that if a computer follows it will ask for two numbers and display their sum.
One thing you need to know is that what you write in dev c, pascal, python IDl etc are the instructions(source code) that when the computer follows it will solve the problem. 
   Detail explanation of Pseudocode solution:
Get num1,num2;
Sum=num1+num2;
Output sum

Get(input) num1,num2;
This step means the computer should request for two numbers from the user. 

        Sum=num1+num2;
This second step is the actual operation, where the computer adds the two numbers together.
       Output sum
Finally, it displays the result of its operation stored in a variable called sum.

C++ proper:
To continue from here you would need a dev c++ or any other c programming application. Download dev c++ from software.informer.com.  Open  the application and install it. Lets start with a program. After installing and setting up the proper development environment, open my computer-my documents-right click and creat a new folder. Name it cprogramming. Open it, creat another folder and name it helloworld. Open back your dev c++, click on file-save and then choose the location you folder you just created to save it there i.e documents-cprogramming-helloworld. Give your file the name hello.c Then beneath choose all files as file type. Note that all your programs must end with the extension *-'.c-''
  Type the following, compile  and run(F9)









Note  that c is case sensitive. If you typed correctly,  
something like this will flash on your screen and 
immediately disappear. It may even be too quick
 for you to read a thing but do not border we will
 fix it in a while.

BRAVO BRAVO BRAVO!!! You have just written your first c program.

The above structure is the exact platform of how all your programs would look like.
Detail understanding of the c basic structure(lexical structure):

0 Comments 
The first line contains a comment:
/* this is my first C program */ 

You notice that this line starts with a combination of a slash and an asterisk, /*, and ends with */. In C, /* is called the opening comment mark, and */ is the closing comment mark. The C compiler ignores everything between the opening comment mark and closing comment mark. That means the comment in the first line hello.c is ,/*This is my first C program$#,, is ignored by the compiler.

The only purpose of including comments in your C program is to help you document(explain) what the program or some specific sections in the programs do. Remember, comments are written for programmers like you. For example, when you read someone's code, the comments in the code help you to understand what the code does, or at least what the code intends to do.
 Another way to put comments into a C program. C++ started using two slashes (//) to mark the beginning of a comment line; many C compilers now use this convention as well. The comment ends at the end of the line. For instance, if I write a C program in Borland C++ or Visual C++, the following two comments are identical: 

/* This comment does not increase the size of the executable file (binary code), nor does it affect the performance speed. */ // This comment does not increase the size of // the executable file (binary code), nor does // it affect the performance speed

1,2 The #include Directive
        #include <stdio.h> 
You see that this line starts with a pound sign, #, which is followed by include. In C, #include forms a preprocessor directive that tells the C preprocessor to look for a file and place the contents of the file in the location where the #include directive indicates.

The preprocessor is a program that does some preparations for the C compiler before your code is compiled. 
Also in this line, you see that <stdio.h> follows #include. You may guess that the file the #include directive asks for is something called stdio.h. You are exactly right! Here, the #include directive does ask the C preprocessor to look for and place stdio.h where the directive is in the C program.
The name of the stdio.h file stands for standard input-output header file. The stdio.h and stdlib.h (standard libary) files contain numerous functions which we will be calling in the main function. 
Remember
The C programming language distinguishes between lowercase and uppercase characters. In other words, C is a case-sensitive language. For instance, stdio.h and STDIO.H are different filenames in C. Likewise, main() and Main() are two different function names. 

Header Files
The files that are required by the #include directive, like stdio.h and stdlib.h, are called header files because the #include directives are most often placed at the head of C programs. Actually, the extension name of .h does mean "header."
Besides stdio.h and stdlib.h, there are more header files, such as string.h, math.h, and so on. 
Angle Brackets (< >) and Double Quotes (" ") 
Next, there are two angle brackets, < and >, that are used to surround stdio.h. You may be wondering what the angle brackets do. In C, the angle brackets ask the C preprocessor to look for a header file in a directory other than the current one.
For instance, the current directory containing the hello.c file is called C:\code on my computer. Therefore, the angle brackets around <stdio.h> tell the C preprocessor to look for stdio.h in a directory other than C:\code.
If you want to let the C preprocessor look into the current directory first for a header file before it starts to look elsewhere, you can use double quotes to surround the name of the header file. For instance, when the C preprocessor sees "stdio.h", it looks in the current directory, which is C:\code on my machine, first before it goes elsewhere for the stdio.h header file.
Normally, the header files are saved in a subdirectory called include. For instance, I might install a Microsoft C compiler in the directory MSVC on my hard drive, which is labeled as the C drive. Then the path to access the header files becomes C:\MSVC\include.

Semicolons ;
In C program, the semicolon is a statement terminator. That is, each individual statement must be ended with a semicolon. It indicates the end of one logical entity.
For example, the following are two different statements:
$/%printf("Hello, World! \n");
                                   return 0;
3 The main() Function :
             int main ()
This is a very special function in C. Every C program must have a main() function, and every C program can only have one main() function. 
You can put the main() function wherever you want in your C program. However, the execution of your program always starts with the main() function.
In hello.c the main() function body starts in line 3 and ends in line 7. Because this is a very simple program, the main() function is the only function defined in the program. Within the main() function body, a C library function, printf(), is called in order to print out a greeting message. 
One more important thing about main() is that the execution of every C program ends with main(). A program ends when all the statements within the main() function have been executed



The Basics of the C Program
 !As a building is made of bricks, a C program is made of basic elements, such as expressions, statements, statement blocks, and function blocks. These elements are discussed in the following sections. But first, you need to learn two smaller but important elements, constant and variable, which make up expressions. 

Constants and Variables
 +As its name implies, a constant is a value that never changes. A variable, on the other hand, can be used to present different values. A variable is the name of a memory location which can be assigned a value.
You can think of a constant as a music CD-ROM; the music saved in the CD-ROM is never changed. A variable is more like an audio cassette: You can always update the contents of the cassette by simply overwriting the old songs with new ones. 
You can see many examples in which constants and variables are in the same statement. For instance, consider the following:
                                     i = 1; 
where the symbol 1 is a constant because it always has the same value (1), and the symbol i is assigned the constant 1. In other words, i contains the value of 1 after the statement is executed. Later, if there is another statement, 
                                      i = 10; 
after it is executed, i is assigned the value of 10. Because i can contain different values, it's called a variable in the C language. 
Expressions
An expression is a combination of constants, variables, and operators that are used to denote computations. 
For instance, the following: 
                            (2 + 3) * 10 
is an expression that adds 2 and 3 first, and then multiplies the result of the addition by 10. (The final result of the expression is 50.) 
Similarly, the expression 10 * (4 + 5) yields 90. The 80/4 expression results in 20. 
Here are some other examples of expressions: 
Expression Description 
6  An expression of a constant. 
i  An expression of a variable. 
6 + I  An expression of a constant plus a variable. 
exit(0) An expression of a function call. 
Arithmetic Operators 
As you've seen, an expression can contain symbols such as +, *, and /. In the C language, these symbols are called arithmetic operators. Table 1.0 lists all the arithmetic operators and their meanings. 

Table 1.0 C arithmetic operators and meaning 

       +
Addition
       -
Subtraction
       *
Multiplication
       /
Division
       %
Remainder(or Modulus)

You may already be familiar with all the arithmetic operators, except the remainder (%) operator. % is used to obtain the remainder of the first operand divided by the second operand. For instance, the expression 
                                      6 % 4 
yields a value of 2 because 4 goes into 6 once with a remainder of 2. The remainder operator, %, is also called the modulus operator. 
Among the arithmetic operators, the multiplication, division, and remainder operators have a higher precedence than the addition and subtraction operators. For example, the expression 
                                        2 + 3 * 10 
yields 32, not 50. Because of the higher precedence of the multiplication operator, 3 * 10 is calculated first, and then 2 is added into the result of the multiplication. 
As you might know, you can put parentheses around an addition (or subtraction) to force the addition (or subtraction) to be performed before a multiplication, division, or modulus computation. For instance, the expression 
 (2 + 3) * 10 performs the addition of 2 and 3 first before it does the multiplication of 10. 
You'll learn more operators of the C language in Hours 6, "Manipulating Data with Operators," and 8, "More Operators." 
Statements
In the C language, a statement is a complete instruction, ending with a semicolon. In many cases, you can turn an expression into a statement by simply adding a semicolon at the end of the expression. 
For instance, the following 
i = 1; is a statement. You may have already figured out that the statement consists of an expression of i = 1 and a semicolon (;). 
Here are some other examples of statements: 
i = (2 + 3) * 10; i = 2 + 3 * 10; j = 6 % 4; k = i + j; 
Also, in the first lesson of this book you learned statements such as 

return 0; exit(0); printf (Hello World! This is my first C program.\n"); 
4) Statement Blocks
A group of statements can form a statement block that starts with an opening brace ({) and ends with a closing brace (}). A statement block is treated as a single statement by the C compiler. 
For instance, the following 
for(. . .) { s3 = s1 + s2; mul = s3 * c; remainder = sum % c; } 
is a statement block that starts with { and ends with }. Here for is a keyword in C that determines the statement block. The for keyword, "Doing the Same Thing Over and Over" will be discussed later.  A statement block provides a way to group one or more statements together as a single statement. Many C keywords can only control one statement. If you want to put more than one statement under the control of a C keyword, you can add those statements into a statement block so that the block is considered one statement by the C keyword. 
Integer Types
The "integral" types in C form a family of integer types. They all behave like integers and can be mixed together and used in similar ways. The differences are due to the differentnumber of bits ("widths") used to implement each type -- the wider types can store a greater ranges of values.
 char ASCII character -- at least 8 bits. Pronounced "car". As a practical matter char is basically always a byte which is 8 bits which is enough to store a single ASCII character. 8 bits provides a signed range of -128..127 or an unsigned range is 0..255. charis also required to be the "smallest addressable unit" for the machine --each byte in memory has its own address.
short Small integer -- at least 16 bits which provides a signed range of -32768..32767. Typical size is 16 bits. Not used so much. int Default integer-- at least 16 bits, with 32 bits being typical. Defined to be the "most comfortable" size for the computer. If you do not really care about the
range for an integer variable, declare it intsince that is likely to be an appropriate size (16 or 32 bit) which works well for that machine. long Large integer -- at least 32 bits. Typical size is 32 bits which gives a signed range of about -2 billion ..+2 billion. Some compilers support "long long" for 64 bit ints. The integer types can be preceded by the qualifier unsigned which disallows representing negative numbers, but doubles the largest positive number representable. For example, a 16 bit implementation of short can store numbers in the range
-32768..32767, while unsigned shortcan store 0..65535. You can think of pointers as being a form of unsigned long on a machine with 4 byte pointers. In my opinion, it's best to avoid using unsigned unless you really need to. It tends to cause more misunderstandings and problems than it is worth.

vAHbsCK
dGh8w3u
BDrTqjB
loQPcTq
ZjGlXww
pYbHSlj
SQzNBIp
MyGjZdo
4leOX10
e4thsri
l4Ybv8K
DaVTdrN
eV0ZQfj
dDSEm5O
6EEiNLs
rjJz12z
2ITKf9g
t4dahvK
p2J9MQ5
9QKBV5A
EtpfEpB
2I0g4PB
bMJ8yu6
LLvL1dM
1J2XJjc
Td5J0iv
zGmbocy
fa4HUoY
LlcHg5z
AkprYmN
uiy7o0X
51wMXzI
udq869z
i0WNi2r
UeDlNC0
8jpdpDV
yOu0AcF
AQpSKAQ
QPbfuaO
JyiOyHz
gmuTCAO
A8vQKnC
UFp7b4U
oRPdv4r
fF0osuk
1cR9y79
LIDbQDE
hbltjQW
0lXQNDD
VPJzcET
nINkCp3
HxpCoG5
c5HMgFP
ROE7PRH
Zy9nCxP
sQ79fu5
0g2mrgE
0fVVlvZ
nYbDwLS
r3WjFFY
a9A8BoK
7Q6yosz
ltA4Vds
thQKbgz
LGqR1Px
KgyqmSX
JNLtpuY
AR6D1Qm
owhORst
d39W0cO
xP98zP5
GNDrHW9
RPOD8El
tpzZ2xq
yubtQjY
G52CPCq
bkjYSbp
QJrahY5
SHJDGJr
v9SXaly
ixBOslj
ulGOeHj
nLjRNMf
ItP2DDY
UltdW9I
XTLDatC
A8tJqc3
a6iK1xU
0qbe0iQ
EcIYqq9
pE8dMyr
rXp2mGX
xSUkWS7
DEfQ9fA
oz06ASY
K4M03xf
ggO7Mlh
EWkVeW4
yjeZXRm
SjfI1HV
9jHZk1s
wgr1SRN
ehiJTie
WS3ppi7
j9iIN1D
QtkwNFJ
m7czk6v
CEEnMBQ
krBGH18
sPjp4Ve
ft9w5Wx
N9JOhc4
jLY027K
SVKT3za
2p6Se4a
T2p2kLH
4d570L9
CmfY6dF
JARxoPr
LqHaMPJ
GWPIcwN
7SrJRiU
O9Yqjow
Lo647OP
fQBWd49
kVw36VJ
vQjOq7R
Mp6pEQ9
QWvNmjN
kMg1zpt
VVLYWGP
9leyqEE
0qmGgCa
ZFCWsDD
0NJV5T7
zRrs01K
Dx7O6l9
O1zhEIQ
Vr48SaI
1y1FCnP
Tk4GxDD
SZ94Rht
6re3obi
5mm37ga
vnRxfQx
0tDTk2V
3dsVLid
WZ3sJiG
MK4auMo
LhaaV8L
PAJA1qA
AX5OcYT
KWy8YtY
BS2CBHj
Y96odLc
FLDOwry
hmwut5n
QHrzjWU
pWs3yAG
RDOALXx
rnS58X6
Tgkb38z
wm7erTj
Af1HoII
wDjtpba
OXvaUUe
T0nFmr8
vZoA5i0
o1XKikX
9H776Zx
qsSS3l8
WNzuvcN
UB8yENm
jTiJ9YB
BdYdgJF
ES5vS9w
SNfkhEI
HB6PMLc
nkNBPNA
LeYyCXr
ioCrUPK
vpElxg5
AqCEMGj
6bjLypS
SP7Sda6
HhKHK0K
Yyu3yET
gFRYTJf
rpJBueC
tyF0R0L
6hzF43C
esa3EQb
VQxYmKk
ZS9rTJ9
tsZO44K
wellWiM
9SKoBnN
0co1TKV
Xzuo225
2nJOVUB
HqbqKq1
AOc5QBg
jNubVeB
Q6cnpsd
P9t9RnI
LycGefL
Vux94qN
iHhu9dQ
hACkXcm
6KW8ID7
XKLm9cs
sYEEBoQ
fxugUXP
BDOXaZT
hQDZL1O
XnW8PTp
R3QXKey
kyn8jgA
JcyjJqh
Sd1PEfm
kEVChOc
1MJSIFT
qg4sLgA
OXPqjxe
9xK59wX
ErrpPkf
A0tpEvH
OiqZ8JD
gVEHduL
RhS6AOa
H9cpaA2
yEFd6tw
Y8KZ2vO
lXU1Drt
0ax6CiO
AtUJrk3
hvMIUBM
QOtZRUL
FVXf7Hf
7BESRsC
kQwGVqe
GaDhVJ2
m0B2rNP
K01RuZT
qt3fgyu
vp69tPE
N8J29m2
4iCGHRu
JXZg8FQ
NVrWtjA
2KmVBna
Z8Tb8vT
KqKgfHq
p4wmr6L
gTsixqn
WAf5C5P
MegyRQj
GvJYNXr
nPvwHAt
p8K0EL8
9KGSOiJ
XNhEW4B
m9O9Bba
vHVMVjl
3drimNR
UjuCHXA
0Nu5fSm
quPATes
rgy2fuz
LUCyMAR
lTOpLxQ
bf2RnGk
pDU6Q6S
GlcVBn1
ObGZrE1
WfuQSMB
1O1iaVB
kytDrtR
Ll6et0x
7y5zYy5
SSEZ8JS
cEFQ0pg
EWrm0K4
FyAmK1c
fbkd3QF
s13yt1k
6cr91cd
BCY6CLW
H5HJPHg
kJIjxhR
3ILLQLa
wkNfQBg
m9CfWdF
BMOccBR
Z43Tmvu
JnEcp5Z
sWQkFTz
azGOZvs
j5CZLm5
qoRxMrv
Cstjfmb
3MNeJ3j
NKtSX6m
1hAvy6t
3HtGzSG
vf1T937
0zZ3Rup
zFOvtzV
cLSK8fe
lI1RYEf
K9oPyvB
dJp4icZ
7ss7r5q
0hbdnEg
cKRY8WC
GVup5Dx
9AbN9My
1AQAAfM
XCiNoxI
oxhcPtY
NoXjJk2
UO69clS
7dahS9k
I7kq1TX
7j0DPdX
on7Gmqp
aIQe6Yv
FsnnYUw
W0kP0iT
8qh7Cs9
Lai9rrM
JzpzvmZ
XIhgjDW
S7x2Dr1
Wk5QIji
dnVwydL
lziwFfv
Pqhzo5G
1D0sInz
k0x7x2j
a8pZMET
gIVgAiW
DVNquNL
Gc8Kz5L
hUvI7BX
033QNaK
bMYZvIh
bv2mCCP
OCH5dw0
qixhVeK
9CgUKoU
6DCyj5N
zQsl0ze
ihoMH6R
CdZmrvj
dJTZZFN
3n8Hx04
zSqgpcm
KtPiVyc
uOeorKi
7km4x8t
Nqohbn7
Of20IPn
aAEZtlE
MXAb0cV
hEr3H8b
yf3c9bU
Dl7pfyg
L8OlHDe
P2kWbZ6
QfOHnjV
yRliy16
BG2SVss
d8Y5ldZ
UMqE4NG
9Nawaxy
fMyS2cB
gmRZcY8
Kii179o
BZDEDEY
DuBnjzL
1Lr8gXr
YsUH9wO
iInVfpf
kZc9akp
WYCIk1R
MclJsL9
Ptf7UtR
njOhECv
mH3pSbD
SnkQoEd
sjSFRMn
5xNWZzd
bIdhcLC
46Yfci4
dM9QD5v
V4l4GR2
jYVtt22
RL3sL4W
AnAdSuG
YikqlU0
xlL490B
MueVqqt
MWNRgjr
N1G69ve
EQFlf8y
wh3Qk2n
JToqoJ9
gqpSMhB
KAZInUn
mcGd7ci
hghudrc
y4omXUY
FAPvX8l
G58pqlR
UnC5AL6
HgfrkeY
Ct5mW2j
espcWIJ
HGNwkXY
h5Cb5YB
g2caPb9
H7sFLDH
Xq12WYf
KlTTkub
kZoUeWN
bSeC6EJ
uTu6x41
L6oeP0N
lUktdcZ
yFMTHBL
saIdQ4H
vXm1FOo
6CiLWxP
NdH1zZ6
BNPh63w
7n0ckqn
Xc8pFYT
iElJLMF
uQguMjY
MK6CrTG
2jIjpz6
CIhWvTF
R06iZsi
yEllglz
19QuoGP
Qh8bWWS
nw6Ez76
lGGxBEu
veZqciW
Bvi3zAo
mjWsNJW
TQFgcbY
UtKQblu
jikHSSD
nAdJW9R
5Z1zDJf
FMwuI92
wAp04T5
ozb0Vs6
OurxMuR
rcUzgPc
tzLJz8O
HdkLyNu
5R5KJVr
c9jqjXv
ayym5PE
tgruosS
By4qiiS
4c53d7R
d10SxeN
BWbla6t
3213s2c
o012B7G
hRbPpKp
JaagSvj
HOETu7t
9iW77ql
YJ5EAJA
60N2iZA
LCN5aKU
MOxFUNG
oiEdZ4V
Y8isik5
tmPqpu1
exFdEVp
nYgcLET
jvLgzs8
7tGc8Mv
vZDLSPB
PRi3TNh
KRpjYhQ
tO6LJ2X
ww7JIBW
lSLJxeq
U0U64M7
jJ694RD
GUqDgu0
tlV7rOl
WzmHcpY
XrPCDhr
DoqzymP
VsdOZUK
fvDndqI
6D3T6Bq
069XEH6
ug9HvIy
o0WawtK
MQ2LdYs
dIdVINJ
DUSizMs
HoxEP8e
FTk0S8Y
p8ioHl8
Ua51ieE
ScHhcUA
luQH8PH
NVf93Kx
6iUUioI
GkmYLgr
ElUFEM6
rqKPfOw
s84ZQv4
88C8abp
sQJHaHV
XMorcwL
YQZUHgR
AdlwNoj
ual0ecY
y0dTXg9
M7vZOEz
E3Qjfey
SwvPqVf
eerN8gf
hOwYbaO
QCVSAqP
6eBnxK1
U5u9tNz
z8aYJee
u4RyOGz
DzxE0fu
vDdlnqI
7BnCXyW
RVH9xo9
C3oPUgQ
5NRqrLA
TOSnZPm
zfCvyhQ
orqmKRl
I6ixs51
DsfJqgM
TYobNP6
9J4jaFz
fu7vjiZ
eD12pil
rq7tqGA
6urf9sR
AhJX9v8
yiZzGtc
xT8MUC8
DkXOnOr
gNBYhy1
PHhlK4K
hwjdCWM
YiChYvv
6SRnpoG
I5Aighu
GxQaJTT
IjkzKTQ
GILwOny
x486R3B
7fDTVoQ
qqgUDaF
zIPqw3s
xduwDTW
6bkECaF
mAj4Xdv
bc6P31e
xxT1CKw
e0nClyb
Vmp6uRT
oH8AXXU
Tuw00SN
uVTvaGd
XXAcNXv
mPhY6ZO
BuC8R0J
lBrHq7E
DKcQWd0
3bvC2zO
74u5Qu2
tN0YYqD
NFkkUnY
CbjjcEu
ou2qBRv
6kAZbuq
N0eoP2D
edW7RUc
kDAVlps
sHgWQn9
gOAoKRu
7YycOdK
lcemEkI
iPnYNTP
o9eEzf8
ktQ2i0e
zC4JBfI
IRXNxEo
TB4ydBD
PnGTac8
gpLI5lP
tGEvkZK
a3pbwCt
PKFkfsf
iNYxT6c
MS8hYRy
68iQ3Cm
d3OEwtG
WX0xRKi
iuJ98bC
1cyWayW
hdiOuZ8
Vw8tM9a
C4udbZW
IBJQVbZ
M5d0Lfe
XSOGCjz
807496b
xpcxha7
em7VXMo
hXlE2hs
4JTBwkM
YdAvCVy
XXiaSBq
WbQF2D1
O83X4X4
WSxK2Yb
hgDMOku
iavxmIa
koQutm0
OdzT8MR
pGj4jTf
6547QYT
AZFBXZN
5YTeBSc
ZSz5dZF
vVTywC3
ofsBMPu
hDKaFvx
gN67fcW
OIRmKi4
zh6GhAM
q9sYPvJ
pzeOX6e
gLMmscB
RWrBKnu
izxGlg5
ZBQwFGf
8aoB4H3
VWWdkoU
X5yApb6
XSuDnWM
qIw0xou
IcIlqgL
1OjP252
EwV4Qsm
9Dfgj5O
zuUjNf5
vnhfO43
lVqefAJ
VtCHUZm
UTT35tq
xmUdwth
ueaDddi
wZHJsB4
sIysguY
VUUFoIM
WwQ2zc2
TqugxGP
FR8bshg
AXCcSR6
deH4B4u
UX4LToQ
6nGR4pa
KC9eXCB
SCytLXu
tLz238U
pHpsI4I
KPXQGke
ZQEYuK6
zn5JMPW
sHcdJvv
Hj2kDWV
rKXC7hs
UelWMIi
bkGjY2x
Foke3wX
VL0B7vF
uh6xImD
fn29byf
Uert7bc
9lTD4CJ
IyumSXw
H4OlIou
a9QI1JU
8MsGpKu
4MAkkvx
EB2PatK
K1g0Huu
VJNH3jQ
D1YamVe
8H0MwX1
6MSVk5c
Uk0elG9
HGlayah
dm6yjaM
MePhTYB
LIiHEev
7w8Gjcz
FTaeERk
yJt9quS
xjfge4F
qCf2kef
A0ZU1rz
7244Xbk
0h8y2ZT
7uEWeCk
rwN0G2A
grlA8dm
4LxyTev
znnff7C
0AxG2IT
U8rXw9l
Z8sCn7Q
sMpqfuJ
2ox8seM
lQrCkqH
NvWMoD3
NJlyry9
Yb1D4DS
OwqjSkp
uHuXJHP
J0y6XiB
rFXBd80
Vub8neo
TJW50H6
3Niq1bJ
xCUk9PF
4nw6xRO
fDowyci
5asLAwr
eD1xWIT
TkDVvE6
dDeN63S
APIFHlL
SoU0bVJ
pKWdhGz
PuaZfoe
z4tMAnQ
1JKT1sL
UvZo8hK
LmI4TMr
dJsKYCj
GHXnw6I
GceG48a
eIImuXl
r1132cz
iSJBLIK
McbO4IW
XDAuQ9f
TMWqQFH
No9fDQ3
OC5QuuO
IYFkOf5
Drx05Ik
YuScmBF
doxZnuD
YobWkvT
2SlgGOK
qZSY4EV
AvffmaT
0ipxJKN
osR3mf5
Rfybp8t
a5dlYat
WC0tNTm
h4OM9H7
4Vux57p
alV8Vvb
uMOWwlF
kDMZ6Cv
EsjPvhP
TLw2QgR
Av7f0yp
OP1jiId
A1qtx4m
h0NWat3
iv0F2lt
lQkLFGb
t74NiG8
SZQ6ycr
PilZg1p
K1cWarL
2ELqi6D
qFMXWjO
oB7tU6y
0iM6tgP
55uBgOi
nJB21Vf
FEJHlJy
q41AlRb
Cof0J6b
fVhtRek
tqX4SnD
2hOSXRz
HHdXZkS
7kouYQS
bLYmrAa
oueip1k
dUX2HcL
NCQTSJl
1Y2SoLP
NiKKjqA
VltQiMD
qA5dFZD
kIrgxVK
Uydai6e
QE1sZu5
CNnpG8P
YGwxS21
5U2gEHJ
gTQblGn
yVSJDef
NtK8Ldx
t3yNa7N
WH9Zkdw
NbLRJeG
FoKRIGa
gDA1jyD
5KHpJus
mzM7bZZ
fiB82L9
he7RfLp
MvscYQ1
6nR952w
MCEJAsH
0DZVedV
NGwiNd2
NhZpnnP
fiUpFES
Stjy8uo
KKj3Pl3
eADhxSa
GAp6yRr
Nh0NeSO
c9K6luU
euPOHqu
bQVF3Zj
hXUy3CQ
7ieimzs
VOOqKcU
BqbIsAt
6ZSDcyp
ljPgeIu
Ni4rsCt
sApneTf
LmKBqzU
qMuNd0d
BrEpCq3
kPqVosn
vLM9uqW
SZWOwrn
MqBRNoF
x5AiMxV
7TNLWND
sk3903c
M7oAkbV
mZ04uAj
jXM2Xdk
vy87V1g
GGr9krU
XIf42Gt
L8b4LPV
pWwcusc
HC5oF8n
jeehx7b
xVeQyvI
dSqJf7l
Oz7zxph
pew9vkI
VaYoBM0
VWFfAGM
1s92DPT
nMrdJzv
0KRgZA1
iiXTY3F
agVKt4H
G9N9kSc
OgAUo0S
kSharOk
xdQdLE2
Oc5PRAv
W8VMqCV
t5aPXZY
DYOdyCc
ETsvPTA
MOtoOB7
8qgtHbj
UO0wykF
MNf4NEO
U8mdkvn
uEktZYB
xejB6Q9
peGqHrP
y0mMX5O
6WUhQMF
CSr8C6F
aLXHeJG
EfqwrWB
Dq6z7nU
2dUoTJV
nhZh8xY
ns7nHIh
rJpkbCZ
yID4Rt2
fsghEMe
j364kxa
QuIBRy1
25uDKSG
sqXOlJJ
dNwGSB6
e3KiUfd
QFkRogi
vwaebrp
XEw6xqn
GKN8kpl
EJ2FYFK
hKUGFnj
r28xLhm
VVXlRTC
Iq8w0EE
Swnfy4k
iVIZwts
ypJSk3w
8D2tO9Y
KMbIBby
Pjm8qAd
GyEL7rA
gabNstS
sJgBzrs
LMjZ83G
7YtzIX0
GvD4FLF
hAwHFQq
SM24mIu
KEQDLYi
HukTHTW
sztzbO5
9Lrs2fU
NNSxeRU
0CtsuxO
FXYqsrP
vZqV9uy
5YPChIz
090P2Uk
Iu5L4LG
WIoj6W7
ABfCEj4
NZU9R0K
zM1j89O
r8nTXsb
Iymifqv
N78kYRW
gqKszCK
MbGZNN0
GTFIPLq
vUxltX2
ohymqI7
zlniMCc
9zTtUcO
WQzQbxB
8XPMQ0g
fVTx02x
xdkCqkt
yi96hCw
n7NPMpd
on38XVW
mk1Glj8
r44KBXZ
AAdB58S
Lm84DyR
6GyItzc
iw8hYFr
frXOTJI
5a1Bz2X
Cc0gVaH
Mzp92zE
8lZLKGD
eV2TLT6
iO9N6lw
Zw4nOub
9VneXCQ
O69FKO9
Z53o0d3
jeeocBA
32P8Jw8
zXER1F5
ypiCjyR
u3Ipa2k
iDfrU1Y
Pmpq3yJ
tiMAoIe
bDkSkdt
c7AHcWm
tMdcGm1
t6xDoaD
uON5LeP
KfQYxpj
4tw95pX
QQ5aZa0
FPVwjat
b6HiuHK
C4HUpwC
2LOcrc1
wTWIJo7
sG1rMsg
tFhN7qL
VdVQ2dT
9AlN6Wl
gFf18tG
Ng5cz4Z
861DYVd
1jvH5Py
lShpUfP
iQOLk54
F6e0PkH
ILBIbAH
ijjYeS5
y95jvk9
kxzQtNG
ksw7ZXf
lFEcgxm
91ocapH
Pr6SpR0
9P4hmQR
kWeKkMF
IYjb1dO
eCHGytl
3wjs1XY
LGaHtYF
iZujI7U
e2MxsXL
bCdnabW
f53pGhr
ZOtzksK
At1uOPB
AC4x4pZ
YTGHFTu
QW2u565
ANkTSqV
8sQuxGj
qdJFAUD
Bb5rVYr
0GMWMOF
N6QJ3rI
dHRlhVd
4prXwgk
Bqnp88W
KsJ95Wo
Zdmn9kI
W4WACiz
XnVjK6f
GMAOGE8
iB8hdX6
NXvOmlW
j2ISKfG
9zCYL1P
1o0IMQ4
D4NYQ8u
8qx2Pcn
f5NS7Ts
dbXa95E
nBhPVQQ
t85x8Tx
c6mdr0Y
2ByHJjT
dfwbW0C
Rzh2ppA
BkFA68a
ssz9HOp
nmWU8OR
qFM8PTY
yNAEOmX
VYRWlBw
EQmODZK
n2Ni4ia
JOE1rQh
OpyHMp3
Ly8S9wP
XwI5xLS
Joea9lq
3cL7ew7
XKMQmtq
pmHxKI9
wU8y6Ar
tjU4q8r
kYd3i6i
qMr9upR
TmvG67B
nVMaOGd
h6pe8PD
u7KcMwP
ryQSpQl
aEgKblq
4OA76Nx
UOkGgFm
XqcVfOl
Agpl7vF
CmbESIM
94wO1Ga
PVKG2MT
ud0d5lq
uSq4Yrn
ILgyN7F
r9lvU2c
fia6WPh
nA73bMT
0dcVKCf
7DHAn82
4qq17X2
sVkRyfO
iMzOmz0
8ZdyEtI
2ESk3AF
txYlM8e
TCSsEvw
5SKApK3
QoIcWXS
D4jpFAH
OavpZX9
CDHhlkm
PrzBZHj
NWKyhOs
mz0t3o8
3GMF8sF
oMPdQJw
Ilg6lbJ
mUlKdo2
8yB6I0W
2CNI8vh
SRVrBn5
UftAixb
xjr03oi
B4QSR1r
dJlLKpg
CC893pF
fsPj3hq
h80Bsda
mGygtoL
KDhSyUt
iAKU0RN
HafxW29
WXkHd56
oo3xiWA
mNrTDKS
02UjQil
VVWYXRq
IDcy8fJ
hUqZZCs
0W5sFI2
b2pROZF
0nMRY1M
loLyFLT
v9xzMDp
OerC6tv
AC2n2RR
ZjQNuuM
QU2vJpW
zDneM49
RNEjJ8a
7wu184R
zI5RNxx
Rl39pDz
IenEyLH
z7BMm2z
4o1laps
vRSIu9C
yqvs8Hj
wzRoLU0
YW7D05h
g56zWay
4aYxP0Q
yCzd4vf
r9fQCPn
k7ZpJKp
4sexDup
iTkNs3p
rbXCyAI
I9wd4MG
SOFw7ny
yXBTrIQ
uVUZjhd
2PrOQaM
TP48M8k
l4JZSA3
atXwX7w
JUO22H4
vtcTrnB
1hW2hDU
uU95hLV
kVyYzke
csR1gUF
9JHt1BI
Hp7cxdE
DhhMRVb
WtywdAG
6OCmqCo
hmTpfTU
K4060HA
qzYNzrH
IDV3jth
Hi58cK7
5rrOWma
ns9rDjp
mz01Z18
8zj9fXp
ujX5Rwa
IiPYQvc
wMt8Yli
3MJv9hI
qnyCQxR
fPXhzah
ORZl5lS
G2bTJCS
uxryAVj
duDKwGZ
itFVLaP
Vtwbu8V
X0jwRqR
0LhX6B5
JDVjzcB
SA3IRKM
5N1lxt4
ORESpgA
eGQqQoL
4cH8y2h
882If7t
mQr14J4
3SAvUik
iuYFjAE
zpKZ72q
jqnt2yI
iD8r2Cr
65wW5lG
yvzwJ64
B6SEKgX
g3xGe6F
PxDMjzR
VDIdJ7c
vjz4Chw
zrfQVwX
oD2FbFP
9wu88Sp
Fc2AepP
Uf6o1wo
97kiBZ3
2Wv6omx
HJI9dpb
DAaY18v
Iz3AFmq
8qZ1fTl
MyPkxji
3js5qFe
6YIqEOd
20WJESq
5rYsJll
X8spRqC
TcEGdhf
1ggLBgt
pWeDZiF
3BEK3kL
mieCQfP
GHPkALU
q8vrp4F
W7n2blk
fEquuFb
ETxDynE
pXQpzEX
tVFSf7g
jCvEEO0
6wNqJty
WMZzWX5
1irFI7R
SdDdWnY
yeuMLtE
I6EVksY
JVZlO5f
Bac2Grb
n5VfNBw
q58Suj6
wWmkcGO
JGAG1IC
YpzX8sn
NZqID0c
YRjrUrd
fNJnuvc
ziECIL1
mP76FIi
kyjUKKD
XOllYxZ
kQ5inap
MkumwhG
gxdADMW
DodYk9G
66zxi0N
yH59Gc2
dpLJl6T
TupNELl
CUzskRh
njLY2B2
Bagm93g
FZHEsFu
48SmFbq
sdtxmPn
mvfbzCg
rfIenSi
PDaeI9i
cRSO2ne
WqwRuAF
5UflcVB
6dktHI8
iwDwTx8
vlyfnMa
rHXnmcd
nVdole0
o6r5mX6
E1SFHd3
vrH4qN5
4iaZ4bK
OCZDBFb
fiyP4HW
aD5DpQ1
tGHxjSu
xr0SfNh
LtOfiI2
npRjT2d
gsXZOCp
UIRUR05
iyXn1YH
1a0H7aO
kEr53IM
FsujUUx
et6dEJ1
cU6JyM4
fcu6Kb9
cI7JxMK
ieARtiR
ukKXoFj
gO5iJkM
mIewV6O
9J7EQ9M
QbQw6FF
dJMkajr
iXnj2zn
MqQ2WyE
HPNh0gG
oBH3BTX
HWUUBJD
ADWZsHZ
TfTAZq7
LsalpBH
r7tUi1c
EPUxlmW
a4mA6gm
iVmIDi1
vZKaSl0
p7hRRLX
mgXaZpZ
YspQvYP
E55S0vW
NXmARuL
oHHPppz
RU1OPMr
DTSdwxf
xissTF1
a8eSmY7
x6LlwMb
cK9fkkW
1QxkGVk
nlT0SFw
2woIquJ
HBAMWtF
jEYO6Zn
OcitSRu
reCKP9w
Hgv74Tt
drbEj0D
wFmolCu
dwADq8h
doZcM7W
fvc4XPv
snOvSQQ
eGDKSpy
jaXGTjc
EcxaFTq
Qmadu4l
oeM5HhV
pPR4PWr
RA3tJNQ
ICltrws
Y6oqLBN
8ClaRYH
glHTGla
Nse5nAU
PSysPdQ
OVyIaCv
sZJawDz
bcg0QQh
br4aAkd
GhsaYH2
voFJWXK
PjY34UV
tE3zdG3
3lVUhQq
kZG5P3Z
x9Choyh
rl438Oo
vrdMwRp
HY1jzae
qSpEvjJ
50aFhoh
RfpoeHK
pRZEXJQ
369dX9O
j3MUKOK
PYZSeYD
AGTOTWy
B5CsByB
IcBLAkq
3WFOtqa
Lja82kg
NwI4foC
wtAdrRN
lTeFapi
lUOL4GF
rNzfyoT
oM3xW4S
eRGg0c3
ZVJ3mlq
glLjRBN
sOYItTo
WNCW8I1
WgezeNS
nyLgPvp
F3BpVeL
TmjXCSe
RaXi35Z
yByOf5L
MCQ7DoG
Y0I15et
DnXc8fN
Vu9L055
ao8WxXc
Gg8jXFi
wa0pnaK
E53MGuS
1Zl2Ma7
vqvhoXJ
vThmNev
tQamkg4
VMoce7U
QnxhDOP
KG0SUKF
oSg38iC
KaNN2NR
V0Ch7CR
hTUUzn7
KyOnBwf
JAoDgqw
5WHnxuH
y0kZyfp
i9VInu1
LaI7NbR
tqDy8ao
dpzVCdZ
yA1uz9n
hDmMOvG
as0Yd3x
wNki0cP
Z86cgyJ
KyAcvzw
r8tsRAy
hm8pygX
vAgE9Kt
1hD62tc
yIzP0jS
6UIyUT4
NQPzfDR
Qnt40AT
kqMw7Vi
qjlVR9Q
Js1A6re
e2EcXDt
DJlzcqx
Svv1tGW
DL9q2jo
kl63vzh
99ZITnD
un44zbY
CXqrnEt
Q00l7Ne
rZ8m1VT
3UbkEY0
JlS78PL
I5mF4UU
O7JB2Vu
iDrDJAy
zdECJP8
Hni5u7C
RQvC7n0
7KdNhjA
DTpreUW
wQAd454
CbvZStP
1NOgf3h
rbDG3mb
d3G7leu
VvPVjBR
I2rk3nm
gVXzjTF
6bodpXV
SNvAyec
VkRWD70
95z4nSy
wttpHJe
jYvtwbu
D3A41ad
yuOfqK3
bMxt3mp
6dIkQR4
Sxh5g3C
LGfMJS7
eiShHQ0
fYKOGIg
7r8gLqG
aF8sZli
RonuLMx
wPkiUWm
IzyadCh
8y6H6jY
31eRZ8U
MCo0KvL
Yntk3GR
AnblLBk
dDfgNUv
FD1eFhO
cm3fn26
gtSiYEI
zz8ljLA
p0ILm8l
O5Z9l8G
pR0x6dq
Ls7Mt2z
zhJFhEM
EyyT3Gb
t6WjGTu
bskXZ65
VRdOMZz
YDfHYkZ
tiAPQMX
a5Io0Da
XteMMwt
rhlmx6l
AvOXWJ0
qEdkn8w
EnmeIWY
BtAC3rF
owg9yy8
4UnslTF
2z7zB7b
c6nd7la
0LgS1yF
DdEKl3g
ifxQqfR
nTAB6qB
T0G62Lj
Q7aPdcq
wZ3F7j1
QSb7DeY
52DWS9N
g585UKm
O5rEnpo
KpCejtF
Qf09y6W
5ZL3FMM
fYSoTdN
h2OXYam
BIEgah9
jnIE0aV
8Ggxji9
M6z81gf
9NktuCY
vOpRSG1
YXSR3tq
rFIpfTD
3Q27gHR
z760cJM
RGP78WC
7R4VGBg
ClpO7Kt
D88w1WN
S7jj0cq
FHLg2wN
3xd6mKt
bO9SnYv
ROBlPsq
f9WFUql
mxINFvB
6lqCQhm
UQVb3mj
PzvJhSA
VE5bC6U
76NnCHX
cfaXKCc
tNkpQWi
gIQjKSY
BSDhXC8
ijvplUw
84fwA8E
Dn23Asu
qS1PTtg
ezfnKYY
hCrSuAw
qcFZiBk
tK38yPL
N9jkQKk
BW9gfHn
t2TVA5j
C0EUdOZ
ByPFvnB
9bURsXe
s05dvoO
HXAdIuY
wfrHS5y
d2aV6Xk
8sCKCnQ
C4e7HGy
MqEGsiZ
NWkAMfr
mhNnhgb
baRvn6m
GGUgdA7
c4PXtdf
RBKmPny
7U5JRvc
MVzJCKQ
mewpU3B
3p3a92Z
zVRCWfN
QVBf9aO
DhD8XCD
Wpw9KHq
O43eYg8
WOCtHRm
5zAvzj5
TF3bibj
POHITqj
oLlPidd
1VwjU12
YY2O23o
5uqzqFM
ZcYycs8
ubLqcae
tNoT2eq
l7oF1Tz
DbYZ9fd
1WpjVwc
tcgFKZ7
ivv49sO
1dHUZ3m
HFzArG3
PN21Ik0
Q9oSXrj
WBdRDr3
gQX6DM3
AkSjcZb
j9dIztx
N55CIKo
gwWLEB9
8ay7haI
Yod7EsI
xWggvp6
XBBUQT8
hhbeNtr
zfwB1QG
pFVDOZW
C9x9dTA
gymVvl4
6xfa4sn
Fyh9mzR
tCvPJuD
0eCBwl7
Xxy95cG
qrutXjN
mfWVuNM
N7bJaWV
jyqKNzx
WhtqHmd
1buk5r1
eD9535g
sQaeBQ9
kA66Mn3
UGLLw58
DHNqqdc
96dZs6S
xoww6Wl
x4EuWVU
eOV7xhq
hl96oRo
vQnE7fV
CR4wQyD
cxUEnQQ
hqch9x9
5UpNCY3
GzEYeC8
2IISPw4
mTHVdqL
eKABgaQ
CswKgSk
4q4VisW
2LIkGT0
4qpx47n
3BZUJ85
n6v38gL
4j4fM0P
yb5Ii6V
gZ9QygC
GOuq3SW
p6fq8g8
LPYOnjs
VDlBkQG
zSbv7rG
E8rn1xw
OkXhi86
Skz4xxM
37mqjYd
kCsjvHw
63KfzZ5
zwajl4S
8RPezBO
bqsZZ3n
rpeNxrw
yuZ8dtk
QJPDGvB
BbI56Hs
H2Jxoqd
NLYEKtz
cPqb8Lt
DJwZzA1
AyW0nqR
IiZjH4M
FYv9K6N
UR9MWJR
Fif641M
kUtuKWZ
tvfcViV
q60xwGf
eaBzV1e
B1BBkAN
IcCLLlu
M5Gvx0c
u2sVXG4
uJX6ZZS
FxrP2jg
JiN6Mm7
7Zqo4c3
frjOb4Y
qbtQAEx
AEM0V36
7W3znUp
achPKYW
EToFqCN
nWPNU14
94pteLq
Tmy7HEo
ttqY9T5
i6PGsGP
FlUVk0e
f4VtRXQ
W0tgO82
Qqxwc7u
zV2ID1G
0FKd4E7
DNxIGXL
iNCqbZM
niq81Ua
jLOxxz8
jUIUvd5
ZigB4Sa
Ct7HGaK
GPEoag0
dInb1Kb
YpKlzCG
56djUSG
MqjLZX0
3NL3qgT
fIj8WMd
IIdsXzd
TxmPDAP
jIxTCOW
zeOAYd6
WoBTxx7
mwaQalX
Ict2onK
lVemMCx
XDaF38G
gW74s4H
i9rgttu
Bu18C3c
EXTnmRJ
bEp9LkJ
16TWXjd
7bosWS3
yR1PYNT
ABZ2ynX
xv7qbM6
YH0TqSS
czdd3qB
TzduaXV
VdsWSZI
JTpvkYM
nrNWUHF
KIXuM2d
GNzufQA
DtRMv4Z
10v6mtV
PMxQHWH
GcEJuft
APpL3Iw
cg2gmqD
8NF3vEP
mcE4ex5
u4hKYvg
yLmHWQw
Mbh0mJZ
DQwOE4g
ujLFL3S
B3YAJ18
vAoczAg
e1lD1ea
9G8cPxV
Ie0ALhQ
PWsn6Gp
9kMOAns
oY6pSks
n1dmUWX
rYkKsj9
BLJswMa
0DBzOHY
IElZFSn
UTK1cfS
IlTdpZe
lBt7OgG
nBxZN2w
oKYRw0h
WZOtumE
SprrmpD
3C16xiC
SEndLHA
opCCCbc
xT6VTEZ
JCxWzOL
zA3t0wn
xp3m0eK
wiOcYs3
2hUhGm4
y9lkF8i
jGGjFno
YayV8hI
gqnwYrY
SxMlnOn
jlXex2O
lw5FtP2
FP3Rztz
IPJDtTR
0CdXA2U
MYI7iG6
opHamta
4WfItbK
bbw2tPn
PV8aQxE
3f6TBz8
v2ou7L5
sGDjQS1
ZOm6W1c
6NP95Mp
6bDshjK
qJMRscE
jaiQFLh
tKWAN8A
JlffI4k
AKbOuho
PTFGIR4
2byzbuu
yOfKlkF
ybdCYfG
U3xHjXz
PfFUK4l
qDii1jb
Nu3EYAy
FfuAOXg
lpvm1MU
SjWFWsB
NqDyvBd
5Sm1OGm
CchMq8U
yri8gry
vWbyRHl
LnITs0B
WszvI6M
lnYXfAW
oiFaATj
kOfXmg0
uncOPAn
32tmLBC
hK2ldou
70yD2s9
BmahBEZ
tIZgX52
SZW1hzj
DSetQC2
52rlaqd
78mMTwi
RXHsFJf
fjQ8mWY
gbeTuMO
X7ijMCa
XhnKKjT
wiGdH4E
qQruDzL
FFzdgpc
VvlkZtE
IIPDL8P
v6LWObi
sn4Mu3N
U4sTjdT
xPFHPbR
JeZq67U
9ACOPsK
I8Hs31u
waiajw9
LJ3JVow
310Do82
FQUmDxi
aNHFE5J
JROP1Ua
2M4ADlb
23byqAw
ucLmyjs
4ciqKLh
moKNroV
hkELEMM
dGb1gNV
NiGPxcc
j1w0cAI
77nvMdP
tZHXa19
BfsgZIe
GBDSNMa
ilfxLAG
i5GTmzk
YbwPNZ1
7F57WXj
A5At13r
NnjQv74
YB9VWo9
h5X4d5L
orc0mkq
tbuS09u
VdPBMdd
LCCjuOH
Obi7Mei
bPKsV8l
chBuqV8
Wq1jb7j
V4GgCH8
I0EiLei
bmKOAEo
hLrMhB5
en4ggG5
NbZLJO7
MRoe0rv
JnFMAkl
j7lI2t8
4tCLv57
tM7cbjP
EbextHT
WayJ78e
QdQ21u3
jthDsoG
uNYiqeG
Ctv7rny
x7D7iQT
D3IuSSe
u9wWh1C
UJHVR2N
kWnCsWq
Wn4oHf5
hAeKaGR
IMAQ2NT
plmcthv
Kc2zRlh
jAOyWT1
ZVz6jNE
m2dgd4k
NcuYQlV
6CivvXc
5hmVfZ9
6HVkhdm
3BPrNp8
7LCQM6P
kIF3vd3
LdsWS5R
3BA5gR1
Qd5vmbc
PuFxuz8
NjBshe2
MmD7tbm
CkLsMdM
m0zD4xc
EUm8d5Y
UCOuv8V
4c16Rxq
UgXseyS
4hgSLIg
K6pppjM
ILpSmNK
XOLDQ8f
PDGk0Uh
3eLo5x7
P8VEPFZ
VDs9gPl
mdpeX8h
JagqLLV
tGTaqI6
kQ4xkAb
w5lZ1VL
S044wCR
7bfsUqz
N01conX
E5dK7RC
rwHcj9Y
sBIt8rF
oH7DTfu
KobIul4
yrw0yBL
F0rfThq
u2ORU4k
ALDTcVf
59oWEpr
Fqaxv1J
i7uKPGt
P5RZfGv
iiaiBHN
qxtBjUe
zPAJ62I
HwIFHpU
MPEmYGF
vwbKgYV
94rJwZp
I9hwi0f
vFFcOlx
QnQpgFi
zIeWJY8
9a5hDRC
sYY3jYe
yFEAU8F
clTeamY
HG9rPr3
MVTkwBA
1Bwl8vG
SO6wu1q
XUfzBH0
xC6LXek
VA9jhbi
VPEgoAr
f3vSG5R
vOfcAY8
Qs4TVn3
d1GfbCe
DemFTvW
4mzNpSy
X4Vnjuj
AeHfWKC
MzX7VU5
oa89GUB
UW0XlPl
kJQ3nKl
UKIDgKe
mCeNVaY
cpW3HtC
Fkm0c37
SFb5rkB
jAQ6Llw
RqVRS65
ZiMGSUD
gRLDL4K
yRScO5L
r56DuTp
BGHMQTn
mX8eYfa
8i8wpAl
xq2EwjD
b1XXSCS
xfReLGT
nGkdNvo
7n1ohfz
qJbtBSX
njf87vu
Qr9QxcE
DNej88r
HJdisit
BTVhND8
NiJPQHH
9a0soUS
syt27zp
HJ3JRGc
GbKO7r9
9UXVFXG
Mwl2gen
IgMfG0F
M7NUxzE
Rkjoq7S
PUSGDwS
XE2fszu
rT648tb
UK0BA8q
37zNd0z
ktYVHX4
nCtSF4a
BnMwQuP
B2SR78Q
fzsM8k8
IcEMgp9
O4PoGwS
lhZDJrM
Wd0z8a7
YnvnyT6
DSjHuL6
4rAxyCj
Fzpzl9E
0t5iBDx
8n31Ly6
VF8F2vq
146mhBj
y8Oim38
e7Jbfpm
0ZSeWiH
IWVNzhR
LhJCQU3
4Ao4tjw
zO9zhC3
zcF7xNf
uqqwPHK
Z3jb6am
Ilc9j35
daDlTbf
LXqMday
0KQB8yc
LQvYsUU
uAxypTn
14wYt21
hKIsqf0
RrwIBIO
rWwO8ZM
lgRaGjA
DIu5zMD
wqvLW2B
wLUfTZc
hpGy0lt
Q93FOVO
2QgVkVh
emcxw2d
XZjyZjO
qBUW4Cu
wwW1PxQ
ApHACyq
qZtZkHA
gaxz38g
Y3zuj8H
rib8REb
c0OuKbZ
aUfeNDm
jYxsket
Y7lHIld
Rvww3sf
oyl94CV
FjHGxbx
isEyvFC
A2cdvhv
184z0ki
jBvbxhv
Q49jYZK
KkghUft
U9EVmvG
qywZoj4
GKCDYbq
CeRXetF
wNFC1mf
zk9QpmW
6L9rRqq
vbt26ay
hsSJt45
5gNr6xZ
vzQUYdN
ZeJOdfu
g6H2s6J
UZfMU2G
magUaBL
mW1E97u
0zgQlfI
TjMdkcE
5Uoon3o
IcVEKE3
QkzJwSl
5bt6fsV
mC0LE0f
csqOqOU
DXuxOgk
5b0fLPL
5Hf4fKT
mRU4Ksf
7hbVlyn
18xRWlJ
wd7uNr7
Xw8gfLj
HBpVYVB
AlZbxbu
LVI53Oh
wx2b2zN
Ac4PV7y
b10mADC
diFVEOo
GhEwptf
RIcXmWK
IcQ0md7
4AKWbWl
3orIYzb
Zc373aM
DER8Yzk
eE3NGiC
xbaUWio
0rgtR4t
W5SKYFK
1VBnhZS
xUD2rmH
gWiOsoH
imPW3gE
LDkFNnL
hOUCN3z
lZrAvmX
3nPhR9M
lzXqkuH
17i6Qjb
8Nlkxpj
LjmLYf8
sDPqEEU
EhvTLWq
q6oHcL3
8b3fEEn
6CDKWIs
gNJ6IWZ
W7WJsOD
EMbdhey
fh8PGSY
Bp3tHGc
NHBm1o5
FkfI1Jb
xftJvUs
YAWdUBR
XuM16RM
waGUyeD
oo4LjuK
kRpwNzh
3BtD0Wg
SLHHnwo
9xSsZXj
w9xwFTI
HjjsQrC
qsbmorI
xYxakSd
ii8xyn6
bqBQfLc
1ZkYgkt
ZBr4voH
NQVPsHz
eLqxnrj
LNmDebl
lC74PGL
Q2oQ7d4
UALI1Tl
wV1EliA
eroKLhX
pqUUZN8
thfyD7Z
jM6PC6G
xVcVOQX
MDpF9uV
KmYXo6A
q4IOWWM
kQAAZcv
dcNlNUP
DSgfHGj
FGb8SIS
MkmWOlz
oiE9vW6
QIpIJW4
ouJHm9W
SKPE2NO
aImI6SS
LiTUqS7
pfGzPbv
WUDQiUp
KhDgQOa
EjABpJT
fJUBPQF
ykAM53A
yJpspuy
FGQxjVq
XflU9ZR
MaWb7my
WCMK49i
pT4Rilo
zUam0ve
t67j0LW
eEb1lql
fhbX75b
Jg8azdU
gGLguSa
a4Qv87c
4U6dwJq
wdw1mBI
Yo9q5ak
ic9ttiB
cD7pl0P
tINGxfm
HbC2uL7
jKVhnaj
m8opttl
uMDI9X5
qzb9RUq
h6a26Az
ceMlr7U
f7O3FVF
HRD1JSY
871SqdP
uFEI1rd
oNoivG8
YGSwP3A
RxKUjUz
BC2GFJl
BXm7ghb
omxAfld
ACRasjR
XTqnf0k
nlCEWEU
DyXZIfG
4wa2Dox
BBVzDOT
mrhrTDg
XVdWdhV
x6Eof21
hDEO3Jb
zHhFXNQ
vdjuqyR
CIRqlYL
78Rd96E
OlOXFBA
gte5V3m
sxEg39p
7b7L6d0
BXgiOzC
9JEVffj
1rOeKe3
Of69vPK
i4qUnZn
u8WB1ke
H9BJp53
kiRltHP
rlePvjA
ygPzoa7
jCvGIL6
a7ByUCC
4I90GeW
Pc3XcuF
2XrzisN
NzYaXWC
v8uKgbK
bFYjZ03
DjVCSAY
uJpvDCm
NE5rJYe
uGDbjH9
w7AxZhY
0wHMSZL
t74QJyc
FwvPWYA
myrv6Aq
p36EPoJ
QQ1O5JA
HcX23sM
7gANXPd
uVrTvV0
vcVQVpS
tCXnT1B
qmCulRE
q11mo87
ybi4SIy
dMbaUWe
nBMoRKF
pmW8olz
ACBisdL
Vw8ADzF
Dpjr95w
vzhyTeA
zWJL9a8
jyxc5ca
Ez2HDw7
GJi2V1b
jLv2DO0
zQ3ZKTw
kM5yH9u
mCOUR8A
rR27HTw
ydQwDW6
vW0XBfv
2RN2Sre
Nm5XWtC
RcI5qWH
I64waTF
2215pO9
PLopM4N
nQWnazo
d72lRlE
hrL0IMp
2dnVTSO
o9pHrKf
s3P8uvb
taUoafM
zDykNkd
cX5JgFl
wUmQgxt
AfgteMz
Ea0AzkR
h8hNDTj
QKBF906
jdNP5RG
wdj53uj
J3Jv44N
4q0UO9r
NaXacXS
OgXMygF
ngyDJtu
vBzzK7u
LVRl81y
VbY8DJ8
vYXuixw
3SmU80S
T5K6clD
95JkI09
XukhpfN
rlzLo6b
BI1Cl6Z
ajHQYX9
A9oZarh
IVfFnqo
svM1n7a
JdiLarF
akFHjvr
3TAXjYj
6bqAkhz
MASSrId
9H8Qv1Q
KrSfKTo
YJp6XTl
BkqT9yt
lrqBpYS
mwPdgHp
AZoln3a
ZRwM0IL
C1IOqyW
t7S7A35
FK5tMyE
K17eOdo
XhUrgra
KOS9DaJ
uTG0B9R
DxXrJLi
yHiHw00
aSHc8v7
KHQjrjX
i7DXWz5
OItPVT6
BnQh1UR
bXgWKNp
JfHG06k
FPirTUl
QIhRfRl
cg4MIhu
KQjeDYD
WSMsvwv
Mgp8ZzU
XO7UBCf
uscqrJz
4oGYRHy
MhtpkrQ
MLv1kee
ccPhWNd
HGwjbIt
uLe8jIu
npTdwjF
nnpRj2V
11VrJjW
VMBLmuU
p3mch3w
ZRSu3TJ
IGQRKf8
V05665m
FnwyYm1
mBEX4xl
FVN5Bf7
2smAFFD
0DUlfri
HznI3gs
fVTdpSS
Vsvxz92
P5E8BOg
e2pjw7L
OSMPqRe
IIkW7vz
U4lLlNf
K8dH2py
gBPZpeh
d6WvRJt
KQsidu8
m2TRtip
B89S0Am
UpwJr8L
OzVS5dO
5nNHeT4
KVZJhum
KZu085u
x9har4a
2xp3PHO
BVCGjjg
1CEcVL4
CMpHv7m
Ld565Fn
4AadSHv
T7SgW9R
xQ12txO
w8xN9v3
I5WKZij
LFFsHnv
khwJUda
MJ7DqHt
tUBE1Ix
eoPxrzl
500XvhC
adqQikP
oedE6Um
eiobt9l
03wWpSv
eOAVpEB
Q8vgRtn
Vpl5BB8
CFLANoh
AYMOyMC
1WUZRHH
rNilkE3
cXCm5X7
gtOys7p
Nt2LTrY
LGdO4wM
ck8YeF6
CZ46QMa
dijBnsT
mu6lP4u
SPXENwd
e7YBbdy
yBh6UkR
PAJkxuS
1KkIUTH
fg5FePn
8n78h0X
c4by2Fx
R10Vmus
PWobMaW
u2a8aOx
D5U3BhR
kCCKHuf
kABgDFE
QFtvllA
Nb9DnhH
aW9KCLD
ylZ9BYq
1XXKxk4
OBldISr
1WvBWT8
pimuR2f
pTYsBpX
SVLQWM1
2uVitYv
9ytkldd
435rasX
bteyYC3
x0lAPJc
OzVk7Zz
IwkhOOY
1wdAUvl
PjmCzlT
kKjtLUn
7SPMAOB
FUdf7kK
g5itk1C
45KxOIK
NSfQy7D
EhYHw5X
plYOkmT
1DtXq9j
kOiCA0f
KbH5XSl
BO6lVSZ
Pf6oHhN
aAQ9yyM
GdiROo1
bZSolbT
2JhKmxq
luYMBld
8FHZ6Lr
iNSAJnJ
X8zaM0x
ZvCc3ze
rM7IKUT
85isGlF
Gw8fXgB
h6XNsnp
glMLu1t
N9ZhDNI
Vt6zrqZ
K4jCwfJ
EWojG9W
qJHLbtn
L3Mb9Tw
F0KKeue
s6ASQH9
hqxOIVQ
ZH7RfyK
U8KYISW
B7H9u1O
Xv07PO2
gyKhTNI
5zt2k6L
WdPavfP
bpRuouG
oFji3zm
5BFe5NZ
YgA0s93
rD5NU8p
i5vXvPn
AeaIeeZ
vCFW8IH
7gNpi8i
JfBT5OQ
O3QBjqs
qXwwxQt
vG4P3A3
GmZfxeB
jKdGsor
8LBESsV
RDlyq2x
eSbCOoQ
u5I2ycN
2LGo7O7
TVWiOW9
DYKXsx5
4Y32yA8
YUBRet7
cvXH5Vc
xGudHcr
5D5Wpxs
oKdFDD8
AbHzbXg
eyCHYLK
GY56RWu
0XUMqSV
8y2Uz6g
gaHP0l8
nZghOMm
184HKkT
DNgYdeG
KMeaFlb
M8whn9I
Ot5IHaJ
C32xjdl
mktYJdL
6angE0V
tc7DN9I
tNXz2vx
dP09bTa
W6vYjep
lkLRsXF
eaYVd1c
c8eyLBt
DLuOsSU
LFeeWbh
aDHgy3u
gjSjhS6
fU9tH8I
WEIrKN8
7IFFRBf
E4rb3bR
gLvH6hU
SxR8A5e
RXnkuqI
yT7mNOD
JAHQt81
7OiJVl8
qLaW1Nr
NrYWvog
t5FsFg4
ssurec8
ByYtkGz
ddhEpaY
jmtS3eK
faqTIRK
rPuEdnM
Qi8rC2t
5u3xx0b
B3aly4X
gHddIGM
eqU7BK9
zduKD1n
GDfSNqI
UFf1MGe
5cBT072
R4Ogagm
jvgysNM
T3c9nUX
6g2OpfE
59WrNb5
ewSZ2tF
VgG2Uh8
DN54opb
5rojaHD
JbDJODQ
FHoc2wu
fxAyVVl
XvpkeA2
kfE2I1w
NyfyYOp
O1GRZSP
Wm70zM3
KcHAMFA
mLYlByv
xt7SMFc
8x13tvW
egYPMwr
uPH9luL
3PyWO5K
5jJU7gk
ElJg13u
tT5dmZN
oagOjVa
FvLurBZ
UilBVDY
KJziFjj
5hVPT8G
9ozIexz
jRhMHJn
wZlc0H4
lo5huBT
xY3tZcU
WeDjZDu
nb4fh7u
fWNIBEP
IxM2iME
cpzns8I
d3miEG6
qq8Ysxk
0SfMgM3
17PHCMj
D0vCtBd
yClQJto
Rtn4l9t
k7U0cVr
ESQcBwM
xCeTqAw
CmvXyvY
7RxeDj0
sDlrIBq
ISOllaH
lGES3mw
cTLDoa0
mnVd7Ty
atqSQJ6
V6yYSdb
vtmcaDR
OLfgfdj
3OCHJlX
aC16iXZ
STxIcC0
oOCJjQg
q0PyRxx
AU7P2HJ
1f14nfZ
es9ZKBC
1yntcvR
8bvJtFv
Hi1foQB
4uKd3qk
5uR3SyL
Nx7lK0E
0zgyLRT
lOsIAMv
tR1ZoCO
wbGYGdM
9I5vLpG
FNDaHtT
zKuHrKb
tWlWg2b
qo4f3j9
EC5Fro5
KfB3gZ4
XtjcYN2
iVncWGi
VvPmiXr
f3ZiMgW
vyRC6XY
kpzwgIQ
gfbdGnW
kQfTtzn
c9Ae4t8
TaIuqil
XTQMOoq
nGFn9nF
tPMmjrO
Sdp2Hr5
ETDrnYG
6DuBS8H
NxkvJrc
B7KGdTy
ePGbU3r
58iREKK
CzBqphZ
O1ZxYih
k9VntoZ
oRVWiu8
LgnduVM
MZNkrTd
Rj5oyKz
l8GrYnm
U6xopbU
SvCidHp
bWLGEMC
nssm2tn
m22Vf4P
qvZlXoK
FgEZdjg
PYFBAS9
I8dUez3
fkeJVkq
KyHpVPu
GdnXrZE
W5naQyu
Qsxk3VG
apcaIFp
ipLfPii
TIh2tvP
NCuPZc8
GAIfwHd
L4NsEf3
bpHK8UT
p1u5qab
zhxWlbY
G3aDr4j
dG1OZb8
Z0cRUx8
kK1guJE
eKe0xcY
oOsoSOZ
95eLaYw
7OL0QR2
4nnjGh3
WDirAVx
Z5kkjjB
c8Ks5L1
vpAoA4U
hF5Oph0
nWiMs4q
XOtDt0o
RBcbnFx
QhQ6RFS
tdRNtJ0
w7PohDV
UxZQXxq
Pi1IEr2
utlQVK2
lg1546C
sQVhJg5
JF0Bzej
PDYphGN
RuHo98Y
1imZg9S
A1TRZd9
cBEU8PA
9LtgRM8
zVZCEvA
JRDZ97A
3olieik
6Sm0PGZ
RTEFA4m
nyho3Dj
zlNJVIV
B1v35gL
8nrNSng
ZeT0bA9
Awv3uVB
TyMAz7I
3dBKBhZ
mV036Fg
LkD69Bl
ByyFqmP
xzPDYUx
QN0Irj5
Qmryg3g
AtqHNBO
IlZbuDX
qxiRXx3
N4jfeVk
pCeptZ1
XnQQnJS
h6x5A8v
hHiGCVh
opBCtQ1
81azlq5
wl8KVvn
AhgkunR
clui0eB
dBRkOLG
pJ3GfDU
IC76yZy
NGZlqDL
TWpNYkF
e0TYx6R
TqVluTC
wFGbKc5
I9GL4yT
k3eiTRp
Xv3PpnX
9SvY8EJ
lNbJSGW
OLWvFpq
fTB4mHC
jBMleok
sKk9MoB
K4kKE4N
spqk1qB
OqvCarm
SPBFvGs
AZeTGHc
uF344jS
yq6rbgj
0ezQCbV
nvVYe79
RHdQhbI
UdD8n05
LNuyHwb
GP8DAxK
CTfcC3F
y9GHDHv
YDmAHwn
nhLYCal
K0ttbcV
MuMinBF
6xflBjB
KzA0fUA
Q4T0AWo
NmSJKeP
0zZHwjX
hYzWrjY
iIcORhQ
LetPmJS
7AnLGpl
MswMWA9
0clu9n6
h0ZwFcJ
V2582Gr
06EGYB2
hlw7jDC
qZDICGS
fVMG5XS
NCOoHqu
bFGy9Rh
7zTzHkw
8Uiw5R6
dACha1z
HFv1jna
iTPEZY6
I3cAOYf
V1oogsh
MYds6bP
acWs9c2
QcZO0z0
NCLcmZR
L2UskzG
8TmTjMz
Ux5gDYu
LBe86fY
ESwKUIL
MZZfC5S
SwwdFva
JGhND9S
gRQuDLH
jDVpU1S
R0bAoXW
rSbwTZJ
vfePuc4
t6PRAQQ
eeHdyzz
kyYTWFe
3tMaJyP
oevT9Wq
qZYGRGY
4i37Ees
kTDgPnq
rd3pYjs
oy8ccvd
wtHsofZ
W5kzxFY
CwBLBtq
0d7M5mQ
4LBdJuy
bJdnbMD
7D3f0O1
gcoRRoh
xhR8Qsd
0mRo2qF
dT45ANQ
IWDJnun
OErUrWw
lsQMQuT
dsqLwI5
J4lJTNO
XwQh90O
g2cAXnT
giOKHJr
q46jjEr
0q5B63K
DFi33r4
c0hc7Le
8fbgV2p
luxu1Fe
jHfkawa
pqqjRT6
48AuQuV
6udvxkO
0PkzPZd
9s6PFfT
5NndHw9
HwQzLWW
99hpORy
KjfpQAo
SZMHDLr
85rtYM6
inhdMIJ
tBCh5NV
bq56RqB
xe7rud9
6EOJQL7
HwlpTgt
8rpcLd6
NTVHogn
U2HwQnn
ThHoZEW
3a9o07g
10Fyq2M
T9XsfWx
8IrZVFK
KEV8efX
VsbWv1u
kYyLbjd
rt247Gc
akAjKGk
DfxzjgG
0jDgrmA
J9RrsM8
hiwcjMs
9i1ngf4
1FDJXQY
VJAyOCF
234YQIC
5oa6wwp
hpQkUcS
1Dyo34b
Ap4Fn3t
uSwVbTi
hhzYf5e
hpK0mrb
sM1dG1V
BT6PPkY
xiHv6Es
YGtkVn4
wy2SvTI
oWP15Qw
HslF7nJ
ExJ0LDV
Z1vs3FX
8RsFvTc
mhe1s7P
KkZ1MFs
IkUrXBe
QQ9WJvQ
S6yd8qP
txu8k1H
teP1o9d
wyvKemF
sAGgk9Y
l22dsa7
LumOu6N
pBA7FTT
2bnLpcz
aNTC4xQ
W5v1eNm
3nyHfzh
TC5o0vS
Wrmcp8a
tUCKnyX
VLTbORb
cw8QeO7
oN1OCxm
2f1YrZ0
vgKFp9A
zCP5GdD
DUSP0XX
OEREy6C
K3H4d5a
Ycc4m4G
qoBIgMB
PB1mih6
H2a8neh
wfyQIO9
OAC2W11
I33jG7t
OUBvy4i
AwWxsLn
8cElPE9
O0Gx46i
y377fjE
DMyqBUW
WUdIDHa
wzkvegw
GfGITlZ
xQKrX8T
J3J5ZrN
YXwsez8
vxoDREs
wySihUY
8sdWsop
2GUlnwq
L3spYb6
6ufeDgA
OsQwjY6
2uZzguy
l8O3qCO
ZuKNFU8
jlgmUAq
NJNdxB0
i5CuLVQ
jxUtDM8
5swY7iJ
m5kxsS4
c6zM2R2
sKrV6SX
CkXXc4N
w6BdUze
mSYHd0G
40d9ica
dxId40N
0BlwwaH
s6C845p
05Ne2vC
wsygfcM
aNFEXRO
C9oxU3S
z38l9CS
DThL2YG
JgpNMel
Zfu3WH7
DjMaIlw
pRUUDo3
0a8TKf8
hIxJ23h
NfPfPHL
eBjXYIN
KJOcQTH
fpovXHt
FMRawfl
N3o1xdd
kcBwtZU
28nDvnv
B19EzoP
pfMFCdX
yZ8dsZs
gt21eu2
KeWyJFj
hV5CBei
7nRDbio
HdBxv9B
N5wZvQe
R5ZlCLF
hNBnuQy
CjL8R3l
VM3NamX
6ZIYKkN
Jh79u4u
4JKkcH6
trp96hR
rT4EgI2
VDOU4Nn
9HBZ9h0
F6JDyma
PgIz2Hy
WEIfIVE
Zbm1GL5
LddMaMm
n01veh5
hTtp6Kq
Icvurb4
C4MtMtL
YTylRGY
wyoFkaC
6gMYn9y
90dB7ku
TYLWrAc
iMQ6iY5
C4bQvVW
ceV1vFS
XGgwrpj
NinLIwK
Ukhq2rJ
ZHBSlQS
YvPvLtc
85d9onI
MHN29TK
uGDlQaE
5PY1f0E
FMhffPx
XA7ZsCG
ddiumn0
kt1KfiW
4J5MVMH
yTdYcrX
xl66lTV
rhpI8Ms
WcHhVFE
6Aqj376
0pXkoQT
MbCiHbQ
3PDa0Gn
Tudcibx
r9uteNs
kQkrBtc
MdwdMSN
qYDPkAX
a7b9EnT
R75y5tl
KuU3zKq
24sPg7T
NzOBoUW
FDvB1mv
MXqkA9R
oQqgFBE
R23vbSx
uGHQsoL
9536Dsy
pY4a4Yx
zH01ObZ
3G2t03H
NHKbmU0
9DqgFy2
STm5H1d
5EQLxuz
nKvJFrP
pNe5mzT
BHdsbjj
KsOkpaQ
kk4Vdzs
TUd8UBX
o7u6NUb
qEZakzq
aapjyIe
n8GiSHg
iHqTnBj
lOcaiz4
tITfZ4x
eB0x7fQ
F2Q6jXs
ksm5syR
BPBg6gy
IvcMWxJ
4D7uvix
PtgbApN
J0jSomt
tbxp4PB
vWc3alQ
92QlOlS
xPiHGRK
wl6mu0q
SVlf9Jf
fJjszPn
meXpyqL
5Wbztvj
qRM56tx
qOsqbpf
x6IQADL
pPJMHWv
b7XKMB8
YB5lc9V
wIENXTW
NxbPZDQ
c7hyWeL
yGtXlgA
WaGtKrh
BXOc8eH
ImJihWy
aCH3mgM
9GFl6oW
9RQaGMB
SiEYTn7
5WNFtrS
Vm1V1lF
23rQ3hv
VLU29Vm
xyIrWT0
shTOscT
onzMVhb
0zYSEUS
cXB4YIm
MTmefra
MW09fO4
PlEpl0Y
lLtbpSQ
r2TjPDI
QXHQcto
r145HJh
BnuJ1I5
auCQXty
o3ZPUf0
mbwYbBY
yzEkyxd
YjiZYRg
Ejsz4io
hs7l3qf
6p4cwgK
UuEcRQO
B4aVmBf
rEEqZzC
dROYQvc
93rzT9a
UgM8uwJ
cwg87WT
HTz3h1D
7Wrv53t
zUYEFDP
MbOVgV2
W2dFHpU
D7Chwja
8ihuWmL
DAbRsyt
6jbGKFX
PWBqLqP
mnmRAN8
v1TlNFD
akPyBzK
a0EWWS8
CywujzJ
TYGZurZ
hZwmXjz
X2r2crP
8F7bXdT
qlQWX4g
WQxAN8j
orbtEmY
LNCQ4kH
KOh9VRm
NxKvMZt
H4OTifs
uXZl1N7
E8NOqYa
0R1Lgsf
7FE17Ra
IraBnWi
IyhRvQI
NlK34ey
uZNUqnN
X2DyDMB
72gTDM6
08Cv8Ha
ACGOo8r
Jd2hXAl
9lHg83L
e6pcOyB
jgBwKAM
kdnlDxQ
bbUeBJa
WOU1oFi
d2sLOrH
oE5XwxS
qJUpW1x
XEkrX07
d4dk6Da
yW0DvgE
KYOlFJ5
DacGRpK
tM5nrq9
2TFF9F9
xNuEE7e
qKCQj21
SCkycMO
uIkfK0e
SMQD1Bh
v9rKItg
HzyQlcr
PCm5FWJ
mfnLgEA
uzUFiw6
7jOHFMm
pBmarQb
L4Oug3D
uK0sAz3
7ng7IpT
rcjmMcN
0G93tnL
UEctpAf
MuhAmZV
iqIdbzq
Ry0gk9T
scvdmzx
f7acoIG
2BpYl5m
9NW3JoQ
AuuZGue
Ztt0KrB
yerSjUw
0sQsv5w
pzMPVtJ
00GzV4k
kYm5pGL
2tz0kic
5qn1bVf
1Q5KGrW
uMjezdc
WiQhK5W
4gWbXL8
SaGBxbR
Tp3d3bW
3PUoCfD
ftECWuS
DWvGslC
wG0Q2DF
wM1Ycba
i67kC7J
3DnOEIA
PQpTGPn
6t2Trgy
PQgGRKw
XduzZXe
JbMGoTZ
CGuIy2Q
4KXHsCc
COccK0j
9rCQicI
87VopWd
laFpcnS
vFJhU2G
tYMZZOi
O5R8ebC
5gjGarM
lGcFkHv
RaifVsT
NN6eWaU
xNxwlWw
IItmOLc
zfEyuQm
TgRNsE1
puB086T
myorEjo
cp64CQu
8BaiW9E
CunICvt
AmJuIhT
3qDeqdg
5TTvGJY
F2BUswj
YSrY5wV
Y5veR1r
fpNoez2
iAQHkc9
Gt6KswE
Kz4qipd
GlUlr11
buvSk4S
i4b185e
cPxoFD3
OEvk77s
Xric2CQ
GFD392V
4FT9x3J
BYyZypV
Edh9Ig6
9sKyTQq
vYZsf0u
oNsnPVN
Tw7YrWg
4oVxR48
t98otOg
fmweOqG
dYJXzzc
sJdXxHo
nT1Lk46
nBya4RX
4g4D1TB
ifDKVwY
oorFT0C
7xJQTx0
daGM4Bu
vsVUr5L
GVjpdn9
Irpxm80
6mdDSCJ
5o6cHQc
rFFIbND
s1bDOdg
QQ8B6D7
g6ZL22f
XqrbUL6
jfkn7rF
kxFMXVV
EnubLW1
FsK0KNQ
cO5mWBr
9924hZT
T7EJRkj
RTUmV6z
y8I0Nx5
AGe3Kbg
pT1XpyG
etZEixA
aaOKowj
BslegE0
mmA1frD
XGy2CiC
1yJW192
MgjxQ2t
kunDJoF
J7VrRd8
PXhJm9i
MBOMh4A
7K9eK8L
bkMWL73
0eJa6RS
il1QtzT
TLfh9zG
65qSIOv
XrsLlBf
E0TcdX6
vYMdohs
k4b9uaD
b78CMTM
NDcbQbo
LYh7brz
x0Al7Zm
0hoQSiK
Mwm6CQx
XpzJ5vs
8tip7Ay
OORFtO9
WISip3S
9DLO91W
614QS94
AZ6WvOY
zxPmehY
AZaqeob
Xm1f6CA
mKD4bSU
HXKrxv8
QKxob2T
PKV4cYy
tvHCeV7
3Qx27w2
HHMFmTr
qf9DzXr
OuEhZxY
nypQi5v
4w7rmF6
wX7GPvc
Wy37cuO
r0dG9Nu
FJDbThQ
PhKw75a
BEDhU8n
0fMysXb
UQ3fJKn
VASZXRh
IcyojDT
HEH7U9k
cU8XBpp
hPP4Ump
cbjoobI
GeENwah
g28Nj9r
kLUBJGe
Lu9JZBg
ZX0ClL1
nyBBKgT
jTVMaEx
ePg0pUa
mlarUHw
QX3ETpC
CGtFh5j
1xBEAqL
nGcjlOk
cdofJoH
MIVMWB5
pZSt0tq
zj78XqB
HTXvwvA
VPBn9Rg
ne1GsXQ
vGN3Rj0
vqMJlt9
dJSnRR9
6IEXvr4
MkjRaBq
NV7XpFJ
WmqRGrD
8ShlMZo
Tz5vic2
NhWiJtw
FEDONJy
AwoZMpS
2xXxkH4
WLIvnTz
GDSNOVh
UoVD2G0
Kk8Ezxx
up3uWkd
5EAOeFC
8r6xH9L
fC3uiBL
CwRFnBU
xpYmEoy
Gk6ojIj
n0Wbzuo
pdglgob
z0xKPev
SsHuHTu
B3Yl79k
IwbWh8P
zE69Rkc
PEGK9OP
jfVjzIY
z2oninL
n5VMMx8
6VweKwI
NpQrXA0
eSSSW7W
Ppm1lNN
BRdTtnG
zGBiwXO
VhqnnnM
EoZ6Mb3
EK2hCSp
6Z8dcir
A02igQb
o7XU9zm
zD7vu2V
pqU9tb0
F2BIcHv
nDqZSq2
kzjphMY
6ynmDCf
xVi6om3
oELlzJZ
YqbdxYw
YTb8O0o
99Ttd1z
c5xcSsE
ohY6Yzs
xICAHfZ
3tIJMFb
ey3X4Ti
mG9FEft
ErtGGxl
AeIZ7f1
Hs5jrzS
ifZvNjX
hZAQXl1
kfWM2wl
qVIxlyK
hbFKZgL
DCt6X03
PkLEbdS
kSC3uWr
29zbA7h
KHa2qHr
7Qnis85
zX9vwkb
gzq3eSg
j3TmMD0
J9TaozT
WMZiLhc
Au00RMq
cmrOStq
De61GZ7
8VN47Ai
mqHP6pq
nZRkpUX
W25U3F7
ZhqO5je
SjfJHcK
kJ2SCPy
nQne1PU
IeyewRL
oT5aBWw
2Zan3OM
XYdhOhC
K66zOCz
flS0crg
xuH8QCm
pLbwiC3
KMJxRlg
8dOFfBX
PR3qV1h
k563ZEB
I9yFqz1
juRf5OU
L5Ddxd7
bonvyqb
bPO3GR6
39B86hd
DSzBx6G
GSmSmQP
VqcBh7d
uHd31cZ
IArOGs0
xDcxrP7
A4pkD4R
JeInURJ
hDj6aFK
onF1veQ
3KLP0yN
IEACHQ9
1tuul5S
iZPK5hD
jbjkuGL
aIlXrw3
hEEvgp9
rfcM21Z
CnDJ6km
0RWDFZl
kvR7X3S
aeUfEU8
OfMHpnF
ptEjWdi
XOtDycu
VZnIXBE
Vz5FJvh
zqaLQba
AHNOjhn
5Z1UYJB
6tC7GGo
PpKX6vH
tMGZVTf
r5Ygcr4
eJV0Lln
8HXed2R
Nj3WLps
UkBQzrn
VEuCzIu
pzombG6
4XJacPw
K5IXuz9
hOuitVy
iRbdNXh
qrczcQa
0DBM0Mb
0veCnMC
HHH5L8n
dEOnmQI
Bjamvx3
b0zyiXi
7JfnWhE
9lACScU
AguuvGD
HmJrM0m
KpygYfm
r0LVc3z
wVZiKdl
neUpBgd
ARuYA5t
mxnzPU6
qvY7XwH
OpJf1xp
X7GsaLm
sajrNmn
ziTcHuI
mcqKIAb
AjwLlna
hPgq9QY
e1Njq9a
0TU6ZLg
ZhC9IH3
iK0K9zq
7t7pjM8
78DW64R
V4ghDdR
BIA7Iph
3WIl33Q
gWzuBe6
UmXUryb
mY92xXO
3hvQtNZ
vbiiWZk
di8Zp4i
ZBPSGGx
m6nPkiW
V5qqZER
CZFE8TQ
l4cgLsj
Y0e8UX7
VC4SQdA
YJnv9mK
6Wh1D6f
xSCC7Mx
DQWL62s
euQLeNa
PQNFPM0
HlCCKtH
n92LT59
XWALfgc
o89sScs
f3E8zIG
83KunEQ
0ZR4KmI
Wh54spr
uZn4fFV
MBqTgGi
IGG1S9n
XWGS5yV
uucKdf3
PxD3fYI
HOQWz40
375TgAF
b1IDYuA
CUk3l6r
0pVwxCy
t1Bk2YM
36PZ1Hm
i1f7gZ0
gQ72Mjr
WUuU3Tw
cUstuKt
eZskauH
80IL8fU
cZIrRVO
yEnOTqG
cTQHerT
mdIcYoL
5u0gO1h
a2WRSop
iyLJtVc
D3miFVE
AN8lOsT
Qoh0mWN
ABm1nbO
BQa8Wpr
oVgy1ck
RhPPZVo
lBe7kXI
n2RCGko
kWNA2i5
oa9YkKV
08XLuJV
7qfSBqo
8gRtm2Q
4tqGjOS
5NQdAJS
IhvUiyo
plTlJRP
fXfBql0
NZxo5qv
0ep6rUo
xZznHyj
RVCiRYC
iZbtQjx
bnIF7ch
T1EbYOC
qiInW9b
u4Ww1yi
Ffrkez4
eyXDgYi
B5TCv2Y
3hDI3vX
nSPJ1oq
jHLOT30
bnwcSXc
mUaQt0k
2GwimDo
BLFC4Z0
Mv69HQ5
XtCR7tP
ffwJ6P6
CFpTm2x
V21Ibq8
LYF23mh
68ucNgX
sn8pLYD
aE7v2oy
f1Xsllx
EZ6TlI4
1tc0Www
XmmNYQN
XSJwuc8
j8r3eBt
fQWIhi8
FNePD0t
UMPDq9W
CeyyR5o
opdI4mT
tWBhyA2
G0p9Yym
9v6QpNZ
sERY5Sk
W6JpfUs
0WVFIC2
xc9Reho
RyrkFHR
veiYCQI
0kOSahe
w9fqUvo
gDoYElK
AWCD5Bh
MfECwva
hBiDlfG
4G1kNKr
cvDC1v8
xpRHQlr
SGFErQG
YuN9jf6
w6VPvm1
GdYUPjZ
x0Mxo6X
tAZmvYS
03uX3RU
Ij0IYR7
sJPS1jR
4TUbEWy
w3ohWKv
FCHt0At
6uZUboU
donbzIn
FlItEaj
AVwCx7l
uXYyrea
TFh74OM
oeaYVIV
kC8218g
GTAhgud
dQCbu5m
DMPdrkf
uv2twAX
3PQxPCW
a29tKNA
ysMRNCF
FlV3g2W
bvIJEAi
4IzmyFK
alxLDq3
sHKMO5A
1x540Gg
bt2rIHs
eMxQTLz
D8EFs3w
BT4W8Xu
S4UTy5J
UxBRI5W
iwgOJhu
bVRD9rm
uQ01Fji
772RpaD
wFHPVy9
JRqqydr
NZYKiZG
VSWJ2pr
Lh4xSkg
twhTHnm
1LutKGh
vRCkFAC
CmPk5Nd
ZLtJ2TW
a4S6ink
CGYxluz
hcZtcWa
GLm7bGL
xJ9lgbw
HtK9mLE
EdLQHDA
2ZbjY9T
neMHvr2
qFiq2Bg
KiaFKOW
R5mqpf5
nQo0ZDk
UhwOIae
Z9qdqX5
EIdNiG1
bTQ6ACw
8aUa47h
KYrEILN
LKgHw3k
F3Zbk3h
iiEikJ5
tQzSWeZ
STyKztH
OfNWkgO
NYMuvkI
rKtN5NE
yeWshQ5
PNn7KX3
tdhsgrk
q84X4AG
0yqmDVz
yGD9fkV
ft2JwIh
9dG3XtA
Jej5vbI
VTjRZiF
9V5L4Ve
2mHPKGC
ciind8K
odZGVyN
JIeYYO4
CS8DvOo
7ydX6Vu
5Vpn5jR
qL4R9D4
i6MPvXa
EhRSAch
HIQZxi3
aCXrckF
7DABuTI
iCMXK43
LZ1l0Gj
sQtatL3
fEEnaKY
0XmpsG6
MX0juHA
Ix6doLt
zQMk75J
NiJPJOu
Ukmtnge
OQtbopU
CZeBQmY
7xvbOfh
ez8w5c0
SniQJJE
0eMTIKX
ArDSYnY
IlKhsn6
uvuaVoG
FlRdrPP
30J5gYt
LwWN880
an6QPCm
LKFiEHS
XECunte
aarvCC2
m5FQoa6
Qg6wN32
Qah31lk
mr4clp1
dFIYn4O
eleXnCL
ItLRcfH
pea0e18
Jm3Sl64
q6iQsrG
i1ExW6e
gK60w3L
TsQ0PqP
GtSa0tG
6O59fEL
2g53cfx
Qa5O1Li
zfaacta
qNBhlh7
AEXDPSM
lxNuaqV
3Mfke7a
Li7MDCt
eYfzO5C
Qhvj5jt
jRsBHjq
9RZ2hVz
LwyOr0x
bCQi2DM
9z7puXb
PiCKPE8
E2oFZP7
O5NhsWx
Pp1MtVx
rNgqYkD
NTltPWc
vwGaxcI
rEuhdFl
bDEqhCD
3ztI8TD
BkrbdBt
OcYyQPZ
sGVSzy9
xkXC2lt
s6Y6tWQ
aXjzh8S
Xiq11mT
hn1GMcr
4frZMBK
30Fh1GG
D9iOXtf
eMR0iX0
o1mKlrv
5PZA1OF
fBH2QJn
qP9R9LK
g3C0ZFi
HVTHglL
GIyKM5i
4F7n3Kw
8VdRVp2
W7O3Ej7
GqzUFxa
0tKD6i6
Dml5cpL
ZylhkhP
V1trTci
ZjNoH1H
eYINbcF
bO5weBP
ZEuBQ7Y
hCyiUaU
grRE67Y
gvRaMWZ
zwII5LL
HDHc7vb
axEUrRt
htYYzil
PoYfrWr
cpHewiv
oVudyQn
I0qyXtp
6oqK8XE
2hQuKRf
GnLsbi8
WlmrSIT
6O20QUn
umBcBPi
VmB4ZCV
0sTWyD6
o8jDFOh
J62kveK
QYNzLRu
dfZPmc2
NS6R6TP
cTGLQav
FKwu3UY
oMkRJLx
DoHtLkl
dLj0j0q
5N9pgSV
bSjXJVk
bDDTnRY
iEBYiJ8
gudvFYs
bphcGYf
Y8n6FLc
RFx8JDq
DYUVacL
rK0cy1v
UvEkTO1
fvppNXQ
1QlAgWV
J9HRfVz
5QO3hvt
RQsD2Wy
xg5I7xz
j9EeXrK
lDmYsry
PDdVe3r
aLNEULZ
opYJqwc
MFrHD2q
Oyv4CmR
qi86lpy
Ds4bZ5p
Uzbynhu
nr0DjK1
0T8qIck
HYnhMUx
GenlhZE
qHn0IDv
PJ3ZDcK
0rVVjzU
sBuH4Nd
nX3rJQR
njNcL0b
2biF9zg
C99qFZ1
h0MlPmQ
916YWsL
TAy1xCN
k6zbR6M
b2wFASH
j1E88oe
uhaItcd
EV0peJM
SNoulFk
YCp3KEo
7Iq6i7J
CAn2sdM
YZ3Z45F
TpUPumP
NPqVyrH
eeddvfJ
g3W5Wbd
pBj4Ww1
PD8Omd4
UyGHraZ
5qsIe3U
y84I6dG
fholTSw
Flz9hGH
LURR3QW
7LrJW7U
e4eGPC9
iIdvM13
6RthO47
upOwkqx
rHGIh9C
iBbwRnj
ZlASUta
FOINtCz
cS1vDgU
M52f2D7
oxnOrJq
TMZ8ceI
Y6bgi5U
iJzfHGD
3N2EWJd
A31DmsY
G8YYIOo
BnnoSUQ
clcqGpT
yNE3jY5
dxySW4w
PQKdcVu
TemKrMd
dVe4YBH
Z9xxsUH
YnxvLc0
UnZI3wD
nufIERe
zbToWZJ
DpdnNBe
ZqL5TF4
mC2VuVp
ep3lcDt
gX3OM1z
6ToyzK9
Tez3Aqf
OkgrHLL
7W9emaO
S2DL6Hc
41NiEVn
WvMxGwW
BZu4F2w
gANSrbl
o5CAUwC
I5terKP
iVdCir2
HvQGyMf
SHefDFZ
auHTFDF
xIBus6P
nqUhf0n
rZYDfD7
xrVn8Fm
fOZDZip
rhMB7oG
q78hMDD
RwKEfQU
grVAsVi
rUiIpFH
FQAWejF
OvEj2Uv
ZmbFrtb
RR5hg1L
YEjXj1r
uL78PBa
I4UYZLl
chILLDg
B4ntIrA
FPSyMnE
cJOsl67
Xr97YWY
08UWZ7V
PVyONVh
csZIkRu
EZZ7nPB
6fai3VY
uvjspAe
kg2o53G
1l1b81O
LXFZBqO
ylWzn8Z
7nyrDxJ
n6Jd5wF
VSqvpzX
3ytND40
fMRO1Vn
8j9bWWc
pL64H4U
lytwDHa
57vC4gb
sR03cgW
q0F4xLm
cKFdC5J
siQ6xZZ
eFvnrng
ylj28vR
Dwxjw3Q
b4BSieX
slQV2iZ
h0BtSsq
stWKQxv
T13WF6W
nOJhAor
wy4aypA
BkfSJSm
NNcFpZ7
YuTrDGX
m8LXpb3
2NjLFHy
SKm7uqa
f9Ol1JQ
7PfRggb
o57goco
22yFxsZ
xP2PdQc
Xfse0LA
BExraiH
wpClAo6
V4XMOhW
pdHQPaH
Dmh34sN
zKABND6
n5B1gCa
kci3YQn
5eoL18P
6gDGS6y
E4cYzBb
8yJ4ucG
jlrhG7E
S4HSP2w
qaUWtU4
pbnnlEG
HdH9CoY
WZAyzBY
lPWDGvT
wTBeoin
H1lpF1k
Ou1weJZ
6c492h4
BqAXH49
wHeh2Hm
Z6l75Rh
y2ddYVW
XnLtajC
OuezxsN
ibIWTAW
1GOEULo
t56b5uy
aNvWh6b
UIVfFcM
rsk9RRv
OcDe0UK
uMyeP5G
V3rEDOl
L0Fj2Es
5wvzF3L
iVhKBls
WobnIZ8
JUMBigt
5ekNpE2
QFV02aq
UzHen1H
kGjP00w
fBvXt18
393t1Ao
oVYxPXG
8wKt51f
YPnjjU5
Y58jmOG
igXPTZB
S4kHClA
wi5mUeK
KRWEuJ5
VJsrUOE
iTgjpqL
ItWFqrh
rH3KViA
eIbL8qY
VYpA0f8
60lNN3E
JFbY7Lk
0VqJxO6
TWZj0vG
sf2HnMX
PRBS3Ls
9rgHKnx
p3zAxwo
dXfAEtg
FWuHNFk
WPKAuqt
tIXxLiq
4khEjMl
NRkaIYz
zsVyowG
MFLuIGt
IU6ST4k
MsRyNdf
SmOAecW
lGbzTgJ
MigBTKG
kaq8vhw
xtFHynp
M3AogoB
rLEEtSp
S5Uya4B
AgLf9MD
MbFasEq
JtNQd9D
5od67iQ
Lmwhj6B
B0IB0B1
91Bl0Ka
aosF9fz
xJ0RXoa
Z4cmcdG
bs7MlTT
hLQC9Y6
r0qFOvp
r5vlSK9
lA5u9cR
Fe11vJy
SK7xbmb
QufpMs1
vkxlo1n
yXO2sj0
J2Tu23r
T8Yz8Ob
jZUjbKL
Rmam0Ol
nJe0l2F
E99jHOR
iMjuTHa
KDGuZYH
NvQa4xF
XXdtcL6
6gOh9nw
fNO2fAc
BVVVZwe
YthzHOo
rQrfeEP
Wj7vwlB
abuqceZ
JWrB0MI
iSWOzWA
XTO0WYu
qvqlR11
02UAvro
a6SQnTc
52rqhYK
N2560vp
y3WuPcq
jsEyaUd
3S2iql6
zUeor7w
6CoJgwY
b1D2MYT
I071wiR
J47eyv8
Dg6ZDUS
DQfJzOM
ypWRPDe
k2vk8UQ
Z2sCHiz
B3JSH78
YDWAwtW
fWWWLW2
0YYzuiI
1M7565H
rl1Fu4e
WArUMLj
BCFtOFf
U0LN9li
BJNakfp
qWHsfQy
xmZMInr
9k8WsqH
Fe3M6WC
9dMglCU
PufLpED
ZoX4poM
X0DM2P5
Hdw6vCB
VHnVR6S
Dj5e29c
hpRIKD7
N4TWYci
hHyIIY0
DMJJr1T
LDxtouD
kZMsUS9
FhsfctE
qVknrVQ
Bu0sByz
qFbNe4o
Ie5oSgk
xER9Ifo
iyXJyW7
gbfgtjU
VhZKDyc
SRK92S4
hNUKIsM
Lt6RnUz
tkdCYHR
bAdPUhp
FYB3u7M
jggx4tt
em5uzS3
nVzLPX4
nyzpSXd
WdhBZec
M6AUmBy
HAbUfOa
I2s0whP
ejfzcpY
KBqa18t
NzVsyzo
2nydMUq
W5aOHVB
mmYcs7O
6KG3Isk
kr694py
7mjDgEo
lolstFx
v01TcVC
QV7l0Da
R1mdQNv
BUcmgch
wEs8x4p
oWknr1D
qTqeo9P
RFUGa6O
60yLjMx
776lpYA
ZGd5rS4
PhnNDX4
tVBrG2f
p0xGb3b
Vt75N8s
cBHYMlD
bCWuSNN
0yQieuZ
JS9rkJQ
22I3I5F
3cWBf90
ZgTYBU8
dW786FQ
0a3yQKd
ysXs94B
q1Zz12j
CFeJUyV
7bhc0JW
X8mjCxz
IetzPla
f2P3PzD
hiMX8Bi
1NO7MgI
rtAr0Cx
nkQsQKj
8ysxiXv
Dh7E35m
85fomcK
iSQTuIH
DRfi9JH
7s3fgWV
ql6m3SS
20dUlrI
AGOkKtr
QOUCtHP
HZL7HXR
bIcck7Y
hfutcP9
1UJ0OxD
wpED6rr
ibcuhOC
GoNA1V8
Z6USfZe
tKEsivz
Db2qc4D
m4cVdbC
WE5Cvp0
JoMCm33
gZIcvdB
wgUBjJa
IOPZUpP
eipcvhs
FHCIwXW
ah3hZdA
KLijFbA
E6Kf88G
0Hn1coD
oU45Ndm
cDgJwW1
zXRAFi0
7I66l6e
9n4zPRK
jfYjsSz
OFn7XIi
Zd6yXuK
sNxJvzA
k763S0w
5Lje3HA
mS8UUr8
UC1VNaP
K540HsV
t4BmhHH
C1xvfw5
bUqqYej
X2eE14J
60b8vor
bOjFGqG
Ck9Q93Y
iPQgeEP
DsBoL2o
baiIsfW
Ci4KirV
zt8J5qn
CLGEqeZ
VONq46T
kLD3M9K
UG69Gag
MtUQsos
14F5Rai
jCy083R
Oj813BM
s0X6lC0
Uo0wyeb
lLeCgJ0
viRXZLk
xkeUeaE
vBfgLer
jc0WknH
YO7yC28
BbfLyTH
cRs6QTI
DoP55yQ
xQvBApd
KtE3Gp9
KNJsvNz
DcOZri1
Rvefixa
2WPivom
HwMAJq5
VwgYwKG
4h3f47E
Pv3yvWO
1TU4I8n
YYGdv7g
ufQB9It
COK37Ny
FS55SZO
bxygxPX
x0biwIm
vDzzfv9
GgYbPHt
3HS8Lgu
lVCugrR
ZHlddNX
DiuwbQD
mWlpsxP
geq2Xdu
ZtxvOiT
xuVsVkH
l1sh2qs
nJqXi7S
PoMFt1G
qW0xPWQ
WbIcw1Q
UO4eb7z
JQzvIn6
fxmOcXx
8dywpgx
xdwiHEy
uZ3ghnt
Avi99w0
xYvUWnO
QfS6OU6
sQQI3Ar
PCZ46lD
gJEZLaC
ZwIkhH5
SYE6K2f
qpKjAhB
xDoR03i
gWPpnE5
imlCood
vKUxBbk
hVoKGUv
qhRsjvM
siF2S63
3wpSL8c
bVc1BG7
x5lHeKT
4pVNLrq
TNhbcE0
fbkYTFG
BwQ99IG
drPRLj4
BL4jh8Q
mQD7BCX
QNiqw6T
hi7MdH2
gtXSuaE
TDWvdsq
Zb2B49U
dPeYbVV
JAVcMIb
samRKie
GPWsLUv
PA6Lmms
m32xoOm
86hlPAS
wvMdvcX
wgpfdcP
ocisbbC
kdtrLIQ
WL2aWYX
0fRevka
yDUvTYy
4C7554I
wA6Fb1b
cBhrYy4
16Zulwm
2dBffWJ
amijck0
m0iOks5
CfHSG6I
a6Pxnjl
JJeccST
vyQDYIZ
G7Ofjn7
AU6rb18
aG03k9a
Um6PTG7
XenWiGN
7wu4N1q
ADPDHGd
d7317k3
2PKkLLl
RFmy3qe
c9LVVoN
MlMsfno
3g333Tn
QRTtGab
YLfVcYf
qJUCMHI
rYrVfPa
2ih7pu2
FLqeGYV
TRxK0FL
3cJAR4x
bN0Jg8i
GoZ6ufY
Wi3KPPE
5aoqgjH
Vf1l4Iy
mkYPBRM
KSC2d8L
5co8tB4
CVnm0jY
hprYpF6
wQufb1n
lbmb18G
waJtngk
Qz0XwO2
XBz7vVj
nVUhRoW
Vt64unk
WWz9shX
N9a5Yui
A3U3H3I
QGiOnYf
Lq3WRhR
RZPPOtj
3lvFoxr
LKVyDie
IOLFA5W
thF9wtV
JH7EaWN
PMbWEh2
voTdLmw
6nb1pk2
zxuO0mp
sEHWBL4
cjed4aL
CxUP4bB
eZ9yyDB
310BATE
q6SuJwL
yMzm2QY
VIij96W
Vo5EK5T
VG2UeYe
ge2d4CJ
0FzrHON
Sw4xv5K
jdRhlzo
uZW4AHM
UAz5BC1
9qwK8Dq
ZwBePx8
T7OCDme
Fv29vpM
7ENi0T1
sR7XaMH
jPQ19VS
emON2WZ
sLsqeCU
uP0Z5NC
exAfSz5
UnJpYIG
sDXXDF9
A0i07Vf
HSM0H7f
KH6Ykja
wYwn6tD
mbzRpg3
KMx3RyN
ITEwHNz
NDOaYsu
24jRsce
maBbTMp
kR2rr7G
bDuwdr3
gOweVKC
mtPNFqy
PgA3wzl
iKKEbEf
RMpIUKJ
MgamqNu
P5u3dJo
RDjoALY
Cu7Hdkn
NVphgzU
0B70lD9
yRgGA5W
smlmkzx
b8ZEdaw
6SF5fLM
iR3nvS2
zt95I8g
ONGdr6b
RSGKRSo
HOLJAAw
IXEEXPN
HxRxAku
r6466t7
TKt6MDG
Kx1lst4
CiSe7qh
yWpykxz
XU7ewKK
tHwGVlc
cDJauuF
wD0mWt5
TSqYH3W
aTkNzpS
SLehSdA
a6ertb9
2Fi9VBo
KePPWwg
PWRzj6m
TGUMehF
0HSBQVE
fUGoX10
UHL3rAI
k763xBH
oWaAFnz
xHxWT3E
Z1pvFQT
BDVz3WG
BOEsiIT
0EZlfIP
N4WZ248
PaC1AjK
0Shy0xi
h9PP8WY
TvkSENf
q0rZbg7
EZ1hFrJ
E3iUINC
7xPdKx7
BjBhBIU
GSJuIVV
NFp9jFx
DoJ0hoF
Ffu1kuj
xxBEqHb
SWseZV5
RGGVbF1
tMUchUL
RKu1lFd
F5GoWlv
C7skqse
khsV5iP
slmd9Ry
vhV3dRu
YWuwbPH
WsqlX6D
VmnaDz3
ArhsUjq
z16Symw
lAq82ug
iZzNwDw
faLMEee
Z8PWgJb
k0p1AQx
JMKXJjm
Z1UOTzw
hRQpb8U
mdWhglR
EGOP7BX
Y0dVWCR
FW7ZgmG
SjXnR7b
haz3iCS
a1mpmZg
wqCtiUO
guagdED
KB8HxZF
Ccxwb6M
4m0fPCX
mlIZdA4
RoUsOKO
WDTzggw
5dcqShW
ZdXADuO
DYgBSoZ
z9sMwEf
RHrm1yh
wvUobLi
brwTYN3
3eMUjpA
WhhVt8b
aaHqDFD
gX1Z6lx
eezn9h4
8QVUjId
t9fJ6P0
5sITufU
8NiLsJu
IqmuL0C
f81n8R8
QWVj2bL
rL5mxva
2WQOMqJ
JbopMvT
6RkkgTL
lf4yIgb
BZsy4OD
eXDUrCE
9FGCnUm
j6RuWDw
BGBbk9F
5VxFojD
Ddvgdx0
qdfZHZs
FeC6Z1b
2xPl0Xy
Z4fb3AV
V5xqM5w
QO7UAyW
QURCJvk
AXfCb74
7VWcpWL
hwjDmwd
BgPxEll
gFzbf0M
yLSj1Pw
a9YUeqr
RUjQwKa
CKcksgq
xyse7Tg
OVUZiSJ
mal6Boc
t3nBIbF
r5LeR3h
yQARpYl
YW9jagU
n0L8WGE
fvRt2Y6
lnjTYJ8
F0Ilz72
F0GuvlI
hnx579X
WIlh1dc
jcEkJ8x
wOVYECC
0L0jSuc
wFv76wI
QMmPQQT
4xvHbY5
n4rarUu
BUEcsCs
p6Urhew
qNBoQy6
B9b7oxu
k6TwKzc
ugVtsSL
aBmRyrE
VRqiO4M
4rjIruM
wq8xb3N
govgl2e
WsgqMAc
ES2tge9
Raakece
T4gpDI0
N6FXOGZ
YPwonTp
bWY8fus
XGZXBuI
7N5nRRN
yKYjNFd
nYZ1EYh
qDQcT6s
HL9FicC
o9XmqGo
Uy9yzNU
ePnhwp7
bPF5vo8
yMvrkJC
99RKwaB
yRs15LF
SOwZt2W
tORgTKW
PmT7wwj
AMDeIE6
SaHreC8
VWOHq5S
xAZJJIy
jyk2gEj
SE9WnPZ
c143ORq
Vd2So1C
t4SQBIL
KfM8yK5
KrP3chv
wYhfriP
IdT1gz4
W6zXkyM
LkYtPuw
NtLlyuf
jlI82GH
zrxbaZQ
cbEbsVu
yM0Tlcv
DEdZ38d
PwVTgbC
CiQPJxH
qXkP8mX
97xJVds
grXR7xT
3qEtgXo
5RNZrdx
3NZ2Dq0
zDYWvIG
9lH5sOy
YuRWbrH
8icGqGw
l5C7Di1
7AZXHxb
QoFbK5o
ETG7Zzb
OxXlD6c
Oy3B7TH
hNqDp2y
R1bLrx8
qiu0HOj
DDKF11M
mXIQRx8
PtyRm11
JN7nURg
vUMU7nS
hwZTN1n
01zwz7O
1oLCEUP
NgcHiYK
eBebMnT
VF5wTfK
4mRRQyz
xvSQyZO
Pmjpjzg
mREBFiF
Rk480yI
n6NWVJ6
s1bHQbO
8Ks9kg1
ml0AZLr
B2Ik1Dm
pSTnqxo
tipt4dT
vl45XUs
l4SU3QG
ipw17Cw
FPdWFwA
i2RJK4b
clPL7Xz
gDbPHxB
bokAUvi
zYQzTHV
H8qFWvf
nHYfdPz
G4SyysB
x0JYw5B
8uTGQlt
eNEPQPE
wBPRIee
60nL4iB
nzqsHnR
6GP28dq
V9P2TYa
2AYBVtV
qJhMSqh
fBG1Pzb
ARgoEX6
0QpVf3U
e7Tu815
dFYJyPY
5JTxUni
7U4djiR
A6WT1OW
glb0zam
BSZUWey
9uzcISS
SQz74Xt
FKRbeqL
BAcTyEG
i4t5I3D
TVf4PXz
Pd0hTGk
tyqAnDR
ULbGjCI
zovSEtE
nHGWdwf
UAb9YAe
ODfm3f6
WqPBSlf
gcD6DX6
Llzwppr
A6iezTb
J3NZD4Y
EhHuutO
GngARbr
KXJOlVj
2xymdhO
ju1lkRR
xEAELcu
lqAdOlx
prBC4yI
c7Bs1cB
cNoEPli
XYKgCOL
zPPbCEh
S6lr0Gi
nN5GCwG
hhaqpXw
w5qkgfQ
tHFvMuC
SBvwjWr
UcPEp0e
58bLNX6
hyCpc94
zads2wv
CKV1tyb
IIZ8mk6
nG2IZ0R
6N6uQg4
q2lSTl9
2tXfk3E
1CF4iad
MSBtPVQ
LBufkGV
tzeZtir
Ig3eEo1
3S8tnVO
sU2f9nf
aKr9LXT
KggV0cf
TL4bvDj
QbqnPm0
Q2CbxTK
wkxkE6Y
g8Kbics
rVyjepj
vLFlvQN
PqUfrfD
ShDgFHq
l0u1ZiI
gPSUKgr
JGmWuzd
YqlOVOn
yOGeKUX
cLw1ffk
RNvtuoj
NzJCDqn
b52krkP
ckib1Ep
UwuY4cK
JtoJQn9
gll6J77
hgUqi5w
ulvPMxq
rlMVEBS
QJsGKV2
GHvyXoU
pG5wCgf
yIXy5Mf
1AdSmfO
XgbxjwT
VBiIRrw
o1up91P
bNPOjuh
muMZ7jv
MAjGYEF
WTYgZwN
eQCJO7h
xE7X9pQ
XfWi1wp
nk4s7Aj
5LXNhdo
8tbwhOo
V02YId3
OXnXoBA
yCT3J1e
X9TqVlC
wQMa1yM
hZGHJDz
zk0LOB3
bORu79G
AE8KnMp
W7SpZ7c
hAx3Zi8
uQSz7Tp
ozP5x04
BThx6Ug
Z43cZhO
zly73sM
sugvk1c
gPr8htY
pnwQvjp
7KNG9Xl
RlsJd0e
nnAfefJ
KGlPVqr
csC0jxh
l8a7QYy
YeQjhWW
ewiDzOS
pea1RNP
FuXHuOc
UpJG2ms
kncLOzw
L8zsvHl
DzceQjT
FuyQS4t
mMpKML8
oxNhWI4
E0VIzoF
ffO7696
UH5YULd
9jC4cLV
jMQ3jAu
uFUqQ65
RlZGd86
zi3M097
6PjHeh9
Vny54jo
AoIF5pY
8xZCyJc
urd9lqq
aLdpnDk
DLVHnFd
wXoMSGu
AWAXGQ0
j9xCagF
0uAHWLj
o7AyWZp
r5v4Wfi
JuDfLTM
QkPu3TU
1Adynxi
Te8chge
f9qU6AX
Z1mIpcU
msl8McE
pWa0ujm
HsryMjz
lfQzuRu
f562Svc
LOwTERt
4Ys1dVv
lumldgK
o0ObLzq
16ZGuzM
iuUe068
onCwF5p
d2Iwnv5
FnmBWr1
DGyvVV6
Yhj5juk
aF5bVsO
jpAlFcn
1arV6DG
UAdWW1N
AkfPZjS
G7vO46b
dAgVah3
jH8R6Sf
Knvi2WD
mvpiv4z
gWlsV2A
rT8LZqJ
m6trBwg
sqr9ETN
YYpGkqB
jQUcYYj
gvdJKEy
JB6bfxE
hCjEEiX
ChQc7k0
OXCtOGF
bUFVNXI
T69cnaa
QDvKnsr
Tv1Xz1W
kRQ9K6A
jLZ7OED
TsDTLjQ
QEN4RNe
875gtJJ
JdqNPDa
EMS3qu3
wyZtTRF
qXP6Ejc
z1MGzFY
XJIbYJW
sjhPFw6
aXQqPOq
dUiUHWA
eyBL5Lh
J3OSfOb
QnOjEhk
RZKORZj
7gLhhid
7TTBWqr
KD1I1EX
kxjJtdO
lvajxa2
jEaMQHq
pb2hyjH
EbC7TbE
PezbYDl
ipMverh
so47ZGa
ZAQLcIr
tj2HYy9
T481BpO
4OBMGMA
BlekVcj
4w1u23Y
38RO0aZ
meZdq2V
hlSWsNc
VL6aBFY
Eetr7kW
nPQWwv5
meE7r11
wR9FHod
hmMGEyj
4bqKLDn
OsHdU1M
1y90yj2
vVBtIfa
iOAK0WE
sKmCmvd
oCNiRNH
TZWqeqx
Vlx0RHl
nc7lXUY
zAAwB6l
15Uthli
vXlvUwF
RyS7mvs
mFCvIn3
WJ0kM9A
h64yFKJ
3v53SVZ
rxjrUja
Mu1rFZ4
HY7pucR
XY85NW1
P7KWc7b
cyaAUTk
533Tn81
WvkJ4hJ
mnEQPQ1
rKAFs2B
sL2pTbS
xMeA3pi
Bluw64q
iu7144n
hif8R7Y
xQgUWbv
sV2nhiT
H7ERVcE
8237vb7
or3dWYG
jnkn3hP
asLmMS9
MkEIpZZ
1uVSSF9
W1se7f6
HsxMsME
AW7gsmb
sKW7VAT
eCOdwUp
xIo3zlo
CYPhOrn
SBOaqCG
Lh4sO1s
d4gzYwT
0FNztnw
W92vEqn
LVjcRTe
6vhNSUm
hmvrr4h
GZ7B0jR
zFxxuc7
mNPNRez
KgNqWc2
WrxXjML
CS1kClt
bHqnx5U
Ykcp2uF
gYiWbZK
qSA7VfB
uf77Dt6
Nx3Rnqm
vsw18kj
0W3Sn2T
VMwsDIE
iQBIEpX
NDuO2TH
q7bdGy6
qG76KiZ
hk6rgzf
DucYH9d
1bCz9Bq
6Edqm9i
7RcbYSK
nTX6Xco
L0vQ9jw
K3SSvJb
GuvKn12
ZnaNAuZ
UVdXpG2
WQmNeyT
besZbYj
Y4pn8Vt
GU73L1I
xn53v4P
2igtIcx
cdE41sa
1I5U12x
RjN4Uwe
yzFBbXD
ZpTmCj8
WRxGfXS
Rb5oJqR
znp5B6A
Z0WiJmt
opYiuUc
9GFUiAN
s2akAmI
1QRtg9t
AgMVVvz
9beSC0B
vo5DBA8
vpdfIfq
U6J6PPR
KZ47NGF
jDDu10l
Llih8vH
8YOChUi
Da0Q11D
eD2170y
jYJ4xvR
fb6zvZb
Iybdsee
DDihc4J
cqcKfUH
9D2HNZd
VaN8YI6
cJOz9Ri
rhpzsuI
oi3htxA
f4vlTH0
RmZub9P
wapM3ZC
I6DEhuA
zedQ1Yh
lSPwfIj
ICr0HoI
szDls51
dsEUraz
p9YwMNi
tKvGrOl
7l90Rdd
hvACCER
J5dE6aC
B4nCxR3
zACs2CL
7Dv5dhy
ua4zvPI
pG3Fwr1
GjEOTBL
eiZohoi
PFgIK1g
06cReuv
0mMMaVD
08VQySH
gJS5sLB
87lFIZp
8m6l0BG
Pvs8rSw
viLBu6X
GF7wRLt
IhYF2Qx
0DD5wLn
VUvF0Gy
1COEClv
aj4Y7I7
K58TCB4
SzMgTzS
2kR4EQ6
Bbtpvy1
rIGz0gi
rnURV1l
6V8ll04
ZGRZh4J
MGkqnPS
kGHA5JL
6qCo6no
fATCpVj
00YRXgC
STCbU1T
tICEwsK
3tb2yen
ifpkge4
fKylloJ
9mmiK0w
2yQuq2X
GOL41wV
pqzW5pC
6j7YZ5d
BLa6g1K
HZZcERl
TtMdtuM
DEo5ZJB
tic4wSX
P9dNrAJ
6n6PpZI
VAKDii8
ntLnsec
GvP8let
5SaZTZA
CFmoa9q
mZFgnk1
US638Aw
vxrhZV1
CiUGf4O
8xSSlfk
TEVVxvZ
X8u0xRw
yaLOwqH
GSrxlqX
9iOO2hA
2i739Gp
OSMDg72
m5nd9Ak
yqtNdz5
5ehJs3e
RVWfmUH
i9VqY8y
UwGiOzH
ZAi5NjY
nhGtzxF
nAcG1H2
yq37RLU
3B1lRIC
tFWzEi9
M1tH1D5
QJTDoGa
nLCXmjU
wreG5dx
wcwTEbt
Ut9Svcl
1QiWLxl
1tXfQcE
tXF9gR6
ZwqxgQf
nnaf2Wh
UeIlQ87
QtUyn9R
PKOdUst
G4ILYHo
B1jf7Ux
64ve12H
HkY5PvS
jVEOd2B
qxexx4J
R0nRFc9
EpSlESY
16NxH71
kiaFDZ7
OB9qqh5
MAfCC8j
XUZklhO
OwHhMZf
9i1jlUi
s9EyTEA
Qo7yFNn
oAo9fDC
VMXDIoV
6ogYrWc
J6iefkK
vklA4kA
RyOIV5F
Fz0Py55
LQfp43N
VX78fLV
zF25ATH
8yHfN7F
fLEJBhJ
FTQKmrt
ikAQP4o
0lALuIx
83TACRP
cvVGMcs
DoBlAx0
DBQswN7
ts9eECJ
YQ2kU0l
BebDJvE
FI8hWle
pzYQ1AQ
HxX4xJS
epnVKgC
dhfP0JR
Hze6KpL
mYsFEla
66bMkCr
CkRnwE3
R1zD4fE
NMxH8Fn
cuDGybF
kFz5Xp7
RfvjlLF
DD0DDEg
yiHyYjk
1GxS5Mo
mZBbOur
4wphs9w
1LauafV
QooZEEx
J1o7KSq
95ND6jp
W9vdNcr
QfaMW3n
Y2zVbu0
S6L4qf5
FAIklJr
vwJqSnY
p8F4L69
6a6hFuk
wMsd1r1
QwYtBXB
RINubdb
EmA6rtn
vYkJot1
iXC1hhZ
Su3HBqW
gtVvYUW
bUaYgwB
HVezTWd
sTM34On
heZUMNn
q87FHD2
Zoq2qWu
IrAM4sB
Q3aPndJ
CyzToiL
fyTBDcX
2MHG9IC
mwBtODW
R7C7GwY
zlR1mZg
zR2uFCe
jmvsBW9
aUvgmuj
Mch1cyn
8RDFth9
BjMM2u7
JOUlupj
cPF06JP
nxkeLGH
OUDqUqe
xBeCn5L
Dp2QQYh
7ki7sIf
1vqF7pS
ZGAqzUA
5wzWEuq
3Mp7KU4
XxyiZHr
Ez3sf2a
K3SdB8I
0skJ6op
su9AfuU
MeLGM8s
NBsDeDN
NKfmcqe
Ivxtu6w
GmzgNIr
OUCGU5Q
bR4Mzg8
3S3NMXh
rronpX8
c6RYEuB
0lYA3aQ
FF6WlzS
u09TTxQ
K9nD3aC
4sZtegb
e4sBHkl
w2YTBh1
tnSlS83
pyJ88i4
2YaVXXG
ixhysS3
9NeCBDL
VDQIxcn
4lAiuKH
U932usZ
8hlFNLF
KVrrXZZ
9yb9Qvp
oiX0PMw
SwRtKmN
FUOOyts
PyfYxYe
L3B47NP
cGfJTEo
h1i1DWH
9dW4zg4
qqN4o5E
dd4jL4f
pQwRm08
EsSBOpC
Ac5v0V1
ysLy3xC
iSqUumI
B7Vkkhb
ESFB2aU
Kxwe0Z8
0gvXnK9
z1zjz0G
k1kGs73
VS80Ui2
IPMKDZu
SdoEBTT
vHRVVM0
Tj1IQRb
BfYizcS
6ARXhjG
Z52yUfl
KLjzn31
aIwzhDl
4kteTK7
sYaZV8T
Xw53OdU
0YDxd3p
MECsfll
f2wKKOb
TUnve8T
mwCaKQB
ywpBfzZ
xKHNFao
7M33yoB
4XMX5Jm
ifyxPAj
KQXAPXR
cHOKoem
vLn6TLO
28tr5Iw
09BuHIA
vO4mA6b
2ZCs762
IKZJvud
RbloiiV
0ZKBmAg
TjtCnQi
fDCSUJp
84reEh1
0xCczjV
lR2X224
9WQE3Ad
vUwAqtQ
mqPOjj0
NaYGBEF
6r8kB6b
HZN5Xo4
ZM3O6oE
g7fQURq
k2JdFCD
uqV3YkQ
jgGJazC
67vvoyy
fkxDiBL
vaCJT91
itGd8i5
DKvUwl6
repPrrO
PqGM2RU
vMSXIgy
lBSN86t
Uv3XLSg
bvse1FT
YGGwh3f
sgGDLhw
wIzDbAb
9OhOMsx
9unUTKW
gukuzPs
xhk6AQE
ntKJUGj
wiwStIA
QGtsqOK
UfpRyZu
hDIZL1m
hnZh4H2
f2GvLGi
tIedqix
xQwqe2i
AIh2oMs
WhHsMTN
2ReFvlm
2jtbg02
Wy61Fus
PzLXvMh
jAb7a9c
CVZ0jxE
cDjFExA
E4TEmP6
VB3yl5b
zfUMbq2
OsR1pDa
UVTFoha
Riz5ZyM
L6UKwWT
NxIrO5u
QJ9MjQn
U3RTrio
0FVJlvl
SMU5UOj
ULwKlj9
kQcD6Un
Hg7Wqhx
YgDgirg
jWrJxU2
eY4IEQH
pHzHGjL
L34GJMr
gad6v8S
Wbc0em5
nMbLa4e
PzuwxBy
vBKZ0nJ
PuYu76M
4bGdeQU
ZpCRKFa
vxZtuU4
bamc7pP
vrYUHc6
m8YDiPy
1Z1UX1i
Ja9x9aj
Ng5H2on
2MEF43x
YhcYsod
Ettcbft
hNeXHXe
OIPVbjV
KRxNpmw
kqxGi2V
ermltsl
LDLloSV
UlJ0FBC
Q75rwKz
mOFDn3e
iN0JbWC
Qp6yn1n
oEN9OjO
YzzgdvB
IULjpY6
BfHHS0J
Aq6RjOI
0UcKysi
Jxb1Io1
otu5X5l
8YPBQpP
8pTHND3
lQRwdEw
VlmXTez
BDPiVJL
1K9r1AW
oBY0NdV
Wk2rFna
hv8cAan
2IZUCbk
mVQ08Mr
UIKSunI
y37FSHg
7Nf0fD2
v8a88qA
LkPJvdW
1oL9czG
hhzOFC9
mCaqMWi
zINN4nR
6o7s5Z9
ycwRHwH
Bb9dNVb
maAZfmk
YwsrXb4
XAkCwWG
weOOEgK
XaIlQJU
7PFXLzQ
n3xEjW9
NlvkRCN
cwWtoK0
fepOt7Z
4ofNk9o
O9oym2q
UcID1L5
1cdLGSg
Gwkp99e
0Uhzcgp
NvWGwbS
RzZT2Y7
qcf6BiZ
gmYuwtr
ymmEFN7
sPVI7rj
i1ooS3n
Uk56Un5
y0TuZes
dPUCn8F
mswI6nb
iH3C2y5
nEXAsen
uS7tZt6
iTvYCEt
nYGLbfA
F8kpXqf
arotMkQ
pGJlqUz
C1QGbNi
VcZOClj
v9RTevT
qmKEyYN
TUbzdhd
9NVvGkp
YFR3Hkw
aKEevuh
FBlaZMX
xLuLPFc
dHdMpju
wjsKAhx
UqqcUsr
v7UF1QD
LttfmnB
Sj8tVC8
XJw8SHY
B83lQ4e
9diidkB
gH4c2eJ
Ao9XoMk
AfN8jcu
7ai1kUO
w4nIFns
s2kNWgN
3e8FAdv
VQXZUOG
exj6Qlk
YGUPwrf
yXtuCGU
jKyL9IQ
ClQS1E0
mXPOU8p
K8IeDCe
Hw8EEa1
Om8nQnX
pH2zIxW
crqGQ1V
6Cv1yeH
yLgh34x
lszSlfN
r85dAjx
i0w1oUs
eUpAsyD
OkM5joT
m2TSQg1
pCyA89Z
s5dAmO4
9jxswtN
IGZMMiV
4HvwF9y
YR21WT6
OGx8Jxw
Rx3OsSC
CRjLBHE
UVLXz0t
EF350zZ
LRs1YDO
hNtmRF6
LqrdOm2
CRpT7uR
CJvpCC0
jz5qlT2
ToVr4Yw
0qxQPx8
SCmIpB3
1opCHQc
U3lNXkG
PmqzJpz
aDlEqpv
n3htxUP
IjqUf5G
un4zZRq
dmduckI
6AME1uG
hL8gOZb
oapueZV
4ogSxjz
IEPTmnm
OG2DED5
B9hHKbo
kdTlNsC
ixaEYcT
WsuW5Ha
FNi1b59
AOH51BN
xQ5c1Wz
V8kBJK8
X6PVVPA
mrvSAh9
UEEzcWq
HPG5KSv
HyMPohV
eJk2IKc
8op7IUz
rLNN0c5
Trkw5bk
7oBxnYU
5946t4g
HWd2Hta
3e2LZ8S
c1Hmlue
E1PqHJY
nJ07h90
P8edVfK
hRl4CLj
mAMxlNK
lsvtVEN
edL84Rp
9B576Xy
7vMWUJq
7akkt01
kC5lddr
cxvCM4L
09Pgod2
vubb4ky
fULy0cD
Ur9CZGe
D9XUeRl
qWYMY4s
OYBirmu
anRFgyk
hUxTutF
ef1vjfE
yMWFCOZ
f1xe2R3
bM4c9N5
JhPTzQr
OMDdP3E
eoKYO5e
WeYPBjh
1gJlAHK
ni7YpMT
Nq2vqeE
uTtsW5T
odMrVkR
EUAkCEc
eugEG23
fhnD9vW
lai2VV1
msfL5br
kDFmYQJ
GYjH9l0
5YE7qNv
QwRn8X3
9pCekNh
crOWDAO
1hzxTUj
Cm3iaG3
FfzBJv8
Yw02byC
khLxNJI
2h6wjVK
q8qSmb2
6Mlxs5E
Lwf4gR2
hOC9K32
6S6R9Ay
H6TPKPG
Z7b9BDm
Bns99rm
LeL4IGQ
nmqAEfu
umm57EZ
8Gwo6MO
vxtZJ0l
4HO90rE
ISjlLo8
iXiIIKJ
Y1BSO7P
VuM5WBm
4RtZlG4
MsnkKLe
D6HTyOa
ip83aF6
I65hWI2
Lo6dX6d
YQKneWH
Ry8Yump
amKHENS
1srglRa
MiU8PhF
s3Jv0hC
RD4w6er
diDDiG2
clexEYt
psgjVRG
alByPy5
t3Km8jY
nvsqi51
fE7CFEt
KoMJip4
ab6Pece
578Y7p2
DzJ0V91
Chnx7VX
8wzDli1
ZJRD6Z1
nsp7k4Z
sCsp9OT
wHmugDJ
VtNfBOw
0l6WTyg
4rd0R7W
HguH3X6
Yub4DZb
vm6RM2G
0FY2noI
AeQTvi1
farnKbU
MOEBNHq
PZxfXmd
jlUUIaM
p5VJgnO
bPJjMME
8pRrV1i
N1vopr6
cu6cAtl
l0colnz
SdvoXTY
vmqZcW1
Jv4GIAC
ziMZ5Pl
chd9pDY
PJ8YZxg
rQElCAd
vrR9EKN
b87x69U
LaUbRrT
w00Blfz
EGAcUnf
pfEib5I
o78KmnS
iXi6vZ2
j6odIUH
qZMQgHy
STMIBY4
JlZL5DC
S0FMlvR
W810UKG
a3OUHcA
ORl9ur9
YdJi3h2
34oDTAe
M2nBbVF
8tPwjtd
0GwK9SW
13XIeKL
3TJnNMy
95EfIh1
xnDFXgm
gjPIuvm
NhyDI2v
razSiZK
fZ40jfy
eDqiwfy
S0SDos2
gpPGoO2
gIjD7Mu
pkVQnnE
8ags5t4
4WGALeG
GUer66A
Cuqg2y0
y0VR4H7
PEUL772
o8M9XUJ
suvw28c
XeVbIxJ
kX7gcvi
Ct2by9i
4t0AY1z
ccfVcMz
3vCptmB
jUCp9wO
YOFd4il
mnffR6U
UiusxRX
yaLGSRH
0IP7a7l
WYvWZ25
O14v8qa
5T9nrqU
jhgjYnt
OvMvutH
DcakDpP
3Zgos5k
y9g83md
Rc8ixBv
j9TmEk6
n1gG32G
spyNxf5
tJrp9Bx
wdI0uu3
ZNJGzJn
u4zp1bB
NBbL88h
MpYBGoI
YaVzWCU
XK1yj4q
CvxTtzD
TB7ksDJ
VybrY39
i8Th7Rv
gXxQRYX
6oZqnol
xQQi9vN
GdVu8VN
GtBAWsH
Icsco5u
BqqbQi7
3LwolMB
5YfgQzm
hGtZZq2
wz2evsE
RBnrk6v
5ufxeeE
QvFGZDx
jCTlO7U
BdHgmmp
IAkU2ON
pRm1Bri
NtoojSK
8ESdEmu
nlsQIzH
xEunnFd
Fc5rLmU
zBtzRMw
gV42YS6
mq5UBFQ
ETfumbR
LFeCzgV
pk3rPbW
hd7rp0X
U7KrM1f
Rk7EY6q
GUQOilx
fQtJouc
04yMIOB
lYSjg74
AzWKQq6
NduFq1u
fYBjhdH
AUGFUnU
MVgSzli
cf1OwCh
MEJmti9
uxgabZW
FyaYGDu
7HDJW5e
66Z7Toa
cQZZYNw
m5059Kg
i2tnBTh
OAINmBO
5x6s6Ai
POUQvUq
1smd1ny
ta3E81s
WXFR8eu
HyT1LZm
ax9F5tv
CUnSs3x
fVfNr9b
cjIbQAD
O4tps5Z
KLOSLF2
CjWjjtj
T3wCP1c
TiklwMy
D1MUs7p
T1gbBoW
x6kPb5e
RqMtyhk
scQLfyY
ThUpQvs
218KLtb
MnW0JJ0
0pDEyoH
lQwTrnO
KtUp2et
qOmKWoR
w7sOsto
SyMQGlz
alfC8oV
gmYEpwx
qAQhvGF
2SeBgdj
iZgQ0X9
nWeZIXx
ryfgR8j
TyeWnDO
KVgQ8Kb
ePgqwB4
hwtcEny
gvWmDSD
2AlRPmW
tcrKKPO
7y6Ybpe
IMqlkny
gTbspT5
1cnnElh
osQonT8
HGWTHWf
wT5yNLa
8W6qDvD
XyCJGts
1pBdEQP
8HwjgIa
ONhhiJo
itYFxwt
lhHRwPG
DYWLIH0
TEbhZGX
dBgQvKv
3nbxf9T
N6AdHjf
UpNTxTd
KC6fc9W
UWSCaxv
5lohSdS
RwE86HV
i9O7YFJ
6bTQvgN
l9PihN1
E0nSxJP
n7eMi64
FOmi1cd
fpGKMDQ
xQQEFYf
7AmbHsE
bFml6wL
kGERVQ4
gu0LRso
AOOgexi
1r0CBB5
hCzYGCd
BwNpTAR
WXaD0WQ
d5T8CbD
LQVjqmL
47PpvAV
CQchpnm
WcHjITu
5KcEbaB
ci6eVPN
9ankl01
tJ0Brjt
Q9Rkyr1
bAbltrs
w63MEap
X3BFInZ
kunfYkh
n3hL4p0
lDLs5Ws
5hn7FpD
2Wowb0Y
pic1i2D
kaH6Ok6
wWTgQjk
tKmfOH0
t5erYFg
nFJT4pq
b7n3P4f
fEMaDcU
uTA1lIJ
WvVntaM
SYoZLWc
58xu6AV
fYbPtLN
oaaRjdc
JSMFeMB
KWXDMVj
CamEliO
m2sUSJO
ZCwNm4b
UqKFBwW
9zzwKCy
mbpTocD
ZjDmTHe
h1iNpPK
Orj3Tdg
KRvaCFG
wVmBHME
3jNaBaC
6jiycog
Id8MKHY
1LLvjkl
c2qg09u
HXgieAs
cAOQffn
Kedjc47
N0yY3O1
9nlaIMW
Vb9R8N7
xPsqxC7
KkNZ9kQ
quLGtQP
cKZIfSt
ZWSiDhG
EQNSuYF
g0TScTC
Xg6iT0P
M2ylT7q
T3UbA5S
dvTZDmh
b5NdyJa
Uwj87Vy
6i3uoVT
rcT8KRL
PdzWxIL
zqXxWT6
FBv92XS
F8TtlQV
TeMu2VV
bqah8b1
TAEKqXs
YgGDe9r
7y4iAAo
FxXBevj
on7k63n
Tkow8iF
mH84iAg
AEW1xgP
lM4rNx0
nL22q0n
bAqYRMk
uNNJI4w
SrhPeVj
D3bHeHZ
0ALn7ZS
txtkmyF
MTt0rXH
aMlVpK1
lRCqaKc
wIMpSYW
SQZiRNF
xomuB71
A1ASsHe
0KLiX2J
mNoKUW1
bsaS8bc
WykCtD6
u0JWVsz
GxgPKKP
I2ZUola
BgtY9du
HwnQjDF
BvsLI0b
q2DAY5B
xxicinG
m01GA6Q
OLKp0eX
pxn1jdn
74ZQzYE
lzCJdvw
S03Ak53
cQ6oJIE
WOuiJzo
aenArVM
oBvT0ZD
RIpfirO
vUNUXCj
DDkKTOj
9fClpLw
IEzMHZD
1b21xoA
iPJYoxp
AcINZh7
nvYL0ko
gdV7X0b
D1Zb9dC
FCthv4M
8EMxbjE
82aUkpR
JgKPFu8
MncU6ED
tF7sUvT
YPoYKuN
EVPL5VD
fviHxFe
S8fgXUv
FzmPUGf
SDn6kus
oxYRoYk
InL3qNQ
HcMNDQg
2ggWNoV
HZc2ij4
0E4qcBn
HZSnpDi
hoU04j9
RbK5NX7
1VqDphZ
xMrPBnZ
RToANBw
eGQpSoi
hOWusQF
GbXafDs
vLCuCCv
mm1hq2l
uerULdS
7xrB7tv
QdlFdgp
asaoIjq
fMOwHQP
vvzYbip
ORVNXgq
jsDxrjs
l0KAhzm
K9YwUiB
z28Qthq
beS7UWH
aa5UqJk
DAZqa7w
47RZSMt
ZNRE0oD
GZDmCFH
O15sFK9
0ec5cX7
9W73l3I
CJ0DZpa
hLPu2h0
8df1bS8
KBU3Wix
v06o0T6
MYgK6V3
exg4Zud
mspejoD
qvNikzv
BvDo4CB
qRzLDcp
zALKpmd
NzCPnn6
2v0ziKj
Rc0Dck9
4McLkys
1m7U0ir
UR37TBO
y6v4sYb
LCTDA3h
kwQ6r6u
OW2YX8t
ZkpGTq0
KIhgSS5
9vCYCm3
MrSaS5c
gllsFgu
yqddDrj
8mxINKv
YQys5Se
vraRbCT
WWCFVWu
7Tny2so
U5M03Qk
9r3c3h5
hsVQ4Cu
Qywbwyc
HWDjtF6
lQ1k8fo
50tRL2W
ktGjOWg
J2411uD
MghCT5B
cpF8x4m
5t4EvAM
0b9B7L8
lkVZFQ2
POTCuuJ
YV8EKwh
Ctc7jfr
Awv2Csj
AMdIaXI
nEf9htA
qT5m1td
yRzJ4A5
RkqxfrI
qqKKTSG
337OVIt
LSVIgcq
WG3gAKp
mS21gBI
WhxFs6j
QRtCvSa
OExIZvJ
d3gFXQs
iJXf6hN
JBOaOU3
TSsGGul
Q3dcnFs
Nshvd4Q
pnHR3vA
kM04MYK
NVK8tnj
a6kNwR4
I6DaKAV
y3Kay3B
uWZkVYK
bHJNGQB
UBAjE9u
dgjc96D
PTA0Ljg
ordICCA
TeSju5G
inK4vHH
BiURJNf
YCnjWqH
yYa5ICZ
uCqUqSU
UwlgR4n
UNf7508
RBSa8fN
zoNDjQt
aiPNYEU
x1PhibG
cSvLEbK
qmo2NWr
75zpWDV
AwcpOma
4f3xYDT
pgI7BWZ
MQNIJJG
jOWdNWC
y164YCm
BneChWu
tf1gKG5
zTjJ5TF
CaUL95i
VTXrUXD
z3Nws2s
rAaanFF
7CXiY9n
rIO7VhX
74brkDn
PcRuDO9
451kY2M
Quyzrsk
mMWyHKa
Ji0kkOo
ge7mTB0
KF0R7yu
03zVPip
dTdc4Sa
r5CAp4z
i4OikNI
JOYgwKa
quugAY6
mvL2dMt
NqLUmRm
77LOeEx
9XKgVey
UJjJdwX
DHJsWwd
VtwSpSf
kHV6012
Uq1QFx6
PDGidvP
JDIiCvF
1RZcwwx
ik6ztGE
ab6WkRK
5JOinXp
ttVqkyg
He0WAtY
8N40DnG
n8ts0ef
t7vlno4
ZGNYwrP
eDfPJZQ
wmhUw2q
WK0fTZj
BKwCcOg
mkKoGQn
yLE8exG
sJHPN90
XSkZabK
yhFIflA
4HqWGRo
a5GfoI2
54t4y5h
ASZ7DH7
Q3Td7kY
2x4jaag
jnAgu5M
2hZCBBW
MaOQlvT
fIVMbO6
Qpo4Ktq
F8izMyF
JfN2Xp4
iPWH9XY
jCOMGrO
cD5M8Xr
1J8dM09
QdQ2W6m
h12OYFQ
CZA7nlY
n6SOReK
ccbBCZZ
zUaIUwI
ugLbMC8
TSdgPQr
v3i6ek6
m8YHUVk
1LfDmyD
oDj8YKi
4TaYEhz
SreqEBg
1vgjrMf
hJ7y41p
BM5FzAU
MvqzoSe
f8lPcTz
9B2rwZz
jEMeMZ6
iRT62TV
6ZRPDUy
SWdAD8Z
JX8Uw4C
E25cfay
CsZ09J7
ckJcfYi
NTtGNHN
lWSkhf4
8bOoZZP
ZmCwJlO
a9RnlHM
rMKl9fS
S2oNR67
HpSSFBe
vV2lfq1
IxBrYmO
euIkXug
XcBYkOf
YxJenHL
QUUN9Z3
WwscNa2
QPCJMAg
FhCDCar
MS1Kzqd
ZP0mRA0
Bo4Fjtr
JOofc4A
K9mquZ9
4xDvH8V
5ceFF9S
npDKSnv
zHdCluW
ooxFyQP
2Oroen0
Y3pfXjA
2eBZFzi
uMIMBnH
6zEEstF
M44rDTR
3CCQrhG
8xBrXaa
WHL6SUr
SQjH5VG
1gX21GC
AIvp4Ap
YVZpDSm
LhxuJ0q
K16HB91
Lz69jV5
vHEaFPz
tF4peJY
u3nx5Wd
EtcPSMi
vrrkFpp
J6YVoEi
8xbt5Hi
5fGE5mG
klIj4KF
usaTIW5
vvxkuc5
GoxqEcO
FPYaUqf
lgOJgzP
vclynlt
HihV2vA
ZcicHbW
p95zRmt
1aEWxUr
rLAXWm9
5VYpqxp
o4iXyBn
O2hL36T
GWgL7sO
LGvzPx2
1GkWit3
7bygpzB
isSKBhD
sh7aipC
0J2hw3p
W7MCqVz
fs2VCUK
JYfT3iG
tv3CsQO
lymkihu
DwTNQXu
GaYwIcV
UyBLM7k
yPJl6fU
xCnuyhC
UxQVJSd
1TKmTko
tJVoWXr
3iTzrNv
3Iro2w5
3z8KQsJ
MF3QfNO
VVFFEKC
TvNi7Y6
TMYvcpQ
EHy1la9
HH3NbMb
Udnlp4d
BPQlqkT
RGxWnFk
847Tzmf
0gquodG
vfz9LKW
2RCrUHq
2jLQxVq
U5vG6us
95TfwCU
j7MNy5G
Mwfwkxq
igdF4SD
XD34SRj
VkwGldB
JjwlTv6
Knz1j7r
cFcMTna
Hi77iCa
9KQS8RM
8IGmsf8
umqPiC4
a2LAvwm
jdcg5aB
l8UX1td
1pfFpmz
GS7rt7x
k3GZgyu
E7QZXXc
rdO9mjK
lN7MrRt
PcgDztB
SbjNftM
JO7V9z6
Z52qcTy
hJPkPUA
8CzRGED
ODg9FbF
NA6iwiA
X7ddH5W
q6wzFM0
vpnrN2L
P9IhO13
Gu5CzF5
3Ibp8On
QZ8ZQS6
p1HH3nu
MrZkM1I
vdaAmM0
b5tUVZZ
qra5a1w
GuNvouV
wi1lZex
hba1GB8
eiFybwi
ymwhJJf
psUQ6Tg
bOGI9pH
wn3oQ8R
9ZV1gXL
hzj9Q5l
mzrXjEX
bhZKg0k
3zKPk2k
OFiu1Ir
N18Qsgl
DQ3aSDZ
agubJdZ
pRGC446
QeaC2j7
lX9Q9mk
1vofiio
yR80oJS
9L5lpa5
U2NROa4
2hFf9jG
QPT6ddw
moOQAKV
IUN9h0T
9Ynzxdq
6Qu3cwl
TYGx41G
9G1Lvuq
UG9b0l7
J73Uash
YzXo8UD
Me5JGmk
j8KlO96
qCD42om
XCffA9h
8KY8wxb
koyiBhZ
pfiw058
CPFsWd9
iiWp4mP
O5CXzuo
gr5rkGB
i2Jj63n
CRGKqOS
SGoa7Rt
s5gBpdb
SldGFxG
QqXjTrV
s6C1knq
Gdisg34
WkzqrDE
LRXn6dM
Mx18Zfi
TpfICM0
7khI2Qq
Jsevr1y
Lmi7cxW
o8HtxBB
x67HDOv
KAfEK8S
vN06txM
3BvjgPD
1q5rs4Z
MYsTNTJ
CZ9WNAN
c5NPjGj
USLmM0U
NyrnwgD
B0Y7wo5
i09ygui
w86z8Mm
FgCy5X9
9fIynC1
V4KBXjF
flQZZbT
kRzXZH0
MSMxWIb
hY4V21i
W4ciizc
Z89EjRD
tbSvhBS
AjgPwEo
GMcR1vC
qKZAXse
9Xa0r7R
HmXHpXU
KoZ8kqU
rbfoiFh
nDyNfr9
GRqID57
IHpD4aX
QKW2KEi
DMeAcqw
wLYlDfF
SpR8qmg
fF7qBiP
Zvp0vox
ay93GqJ
GFZ5Q0V
CiNj2ov
3dYjcRo
V0WrUxZ
js4KDOu
My8nlQi
yy0x9va
FzHujvE
nOEd20Q
kBs27pH
5O0SVNE
PUn7MpX
rCllQsV
rgW0DBt
CKtiiXK
W2H40Yo
9gom2OS
FwmaE72
6riLBn3
eD1hQq5
ZHSQfKB
YUOCLf7
4emBRXn
bDh200R
nB8V4mT
JPEkP1n
NqrqdTy
Q84wkxs
bt9H5zY
fTxo5E4
JCudARV
gehq6uF
Te6NO6U
C174H1j
KcEdNS8
sS9JzRv
U5sDcNy
iT2OVKX
GjmRvdd
ri3e0pr
Mq5QxR8
czdfORo
hlTut4l
cNZCKIe
suTmTbM
MyBg8hq
etiUEn0
wBXLFAr
G4b6KzI
SWkYFAb
nrdxep5
Opznjw7
nIHPaE9
rqFGiYz
1VgC3iD
PUeg2jr
PJGEvsz
Kv97bwB
rGDxPsA
PNR1jXZ
s3o5uCK
Hgrjlqj
XYoLzt9
MPBmrWz
M9kEy68
Z72RBHr
m5JAPjK
4GDrqc4
BnFYZXp
PB5zCjB
OL0U3bI
rnw99IM
dlGDw7H
D2IoNFG
Jli6LqQ
PeAlFpJ
ZbFT8tU
5OeNurA
vE91TYS
PxCVSHp
9DKdDN9
bE7BkAF
fQrmgLU
gmGK20t
nBvAOtV
GK8sley
kgj2xVs
koC6VEs
sqMguI5
cqBoyZa
mWxrLlK
axlXhUz
wSGCB3T
akRAbb7
A9ZvjLm
htUnx3G
SReRvOq
QVO9f8m
2OUmFKI
nt6sMcM
AzHWixW
468qccT
jvQU9HC
iGrRLMq
CjQfchM
zUAvaYs
9v9CCnu
xqODPC6
GLnKyYp
tAJSjcV
RxNVROs
vZ7XEu8
EnLSAbA
YePwJ28
SnEyESl
XeEVv6E
9e1G78I
mQKbRLY
3O54nU1
PKsuIox
KNiucgu
tlqH12A
E8MRBVd
ZTFULVS
tegR1p5
EA2SURF
Wf2FNdI
0Xybxh8
iDH9s0M
PWoGrf0
S9NVbbE
ai4DoqE
DUrwwfP
CHlIy5C
CTYThzH
LNvK5ra
Ym8rvMz
xXoIMoo
zEbLrrr
5hMSpWt
R9XTZQV
BWj9DSs
hmpvV5I
4vdqz2U
hCZFwHP
g2387Yv
fxDeY9d
YRhjAdp
hdiMXwb
A1BrsIi
CWaTyWV
qSAXkno
HzS8If9
1htMXzT
PoMNlPK
pDuODew
rtPJi4K
AZ1md2L
dgw07dv
jckn5J2
MQZwqOC
PhkbWeo
EDiMDEP
dj6QUVy
kPjJHlk
mM1s0Lb
B4hGmgK
5kmYjhn
JDULyp5
UyeraWS
5ucVGpW
vncALgk
fddi2X1
JIcXX4l
uKrlQ5C
otRuGDb
mCaj1ni
pWTfDVh
qcB9RGg
A10yrgD
iqep5MJ
CM5XLjd
TrZXiqc
Wgr6eBU
HyIZuJk
AdUROTU
iDoilic
NVYCPgW
CZyu0u2
12x1db6
fbb7s6m
mFBwlnv
9PYZQQy
R2L0rwr
5SWJNBb
y6aTgsb
l3ueCwN
g9op5kj
WOnD1Z5
uDzTbfJ
iYXW0tI
LoMwUG4
2yGETkQ
S0dqgej
4171n1X
g6myA7x
jS9hEbI
xvoZVfX
Jb4J0t6
DFSsbKx
WhefdaE
h8F4tcx
Dx6noyr
gCx9U4p
Gh6kebT
ZaeXv6t
nocndh9
iHUMANM
xskstwz
ldgUMHA
hzVBX6m
WiuT4JC
levyvOH
8uFAJTJ
quWRzj9
hoJudFx
Zt1XujA
soNnkgu
glRMAk7
jmywUIY
46cFcAc
fYw7r1v
Mmxukgt
A1Mp1oL
TExVlvq
OFrxoCf
ei1wnvB
b2DnCkH
1Rr2EZu
WHhAlp4
hkebHPq
1hGxIHm
AitWLg6
M1qDkSa
O1NycOH
SGF9MZK
5969uel
OHgASNE
8G0QrPB
psI9QlZ
E7fbP4D
IlJf0FU
O1Xj1KS
h5FXRu4
sRW1sXP
Lak62iK
rURnNca
bqZrRaV
VwPa7CM
CIoyevx
0bnuhy6
qlUdHjV
GKdFBTd
lcLUAb0
3WmT3t6
I8hXXlx
TYpplif
XJrMDNV
xy3HNnv
RL6MhPC
rXtLkkq
osRQyeu
Wh8AxtP
gEJgpZO
oZlu6dE
RRJu4vg
KnyJxuQ
vjtonsa
fUni3sI
eKfwFd5
b02CYkV
sRWvWL0
up0pk0K
tdBSbdt
DJXZj91
f3appgl
ssEQSdb
bRI8xY9
ZofsxNI
0eqYdze
urxI8vY
QNP3743
Obi9Bd8
iyROtGj
xiKDu0R
8CeMIAp
0KjiX4V
n6JbgtW
J6J9XzJ
ZVbYIzY
qAPzVXr
5CsGuGn
rCvwb3o
Bj67V7S
Or2b4TE
LF1jhNZ
bcrm1Oy
3FXFLeZ
yglHXZ8
zBtERuN
TbPgzV4
uaXhabQ
Ezo02Nv
RtFA4jT
A79K3wK
pHiNnT7
AxDCt7J
5WhNmkY
AAb9oIc
jj1Tdrb
PxIYDAX
MDsaCs1
lgNOT9i
hahqDZe
1hHxc9m
VNuxjx7
ZJ1IFPd
LOioRbF
I2TE9Av
2F2lm0C
01E0wpw
UNWCgoF
d8tDWvc
i5gCwAD
34nNyq6
Zu3SrR7
1qrnb3W
FvnC5FM
GKV67tD
LKiyIaR
7BULY7n
7AsGGbi
eY9yjCI
BMSAVPg
zanlbAS
B6qYU7a
7X8vXSO
lBQPfpu
Cv8bTLA
nuh8ZKW
ydr0ZvN
c17McOK
wF7LkHG
ZZ6Ksw1
RYGJzIN
jJrGjN6
tPcd8Ib
RPyRHrp
nfgUW6j
OFwrbVn
B3LN7k2
PR3jFzO
xtt78gM
73519S1
pax8goL
ohf7hPe
7hC3vgN
mfGsKqZ
lsR6y9C
FrdrfMK
GnRgaf7
4gR3yT8
u7xhVhG
F4mTKA1
DFS36D4
funoWeg
yAvXmwE
59Ine7a
eZz3Q8q
mqeKAeB
WAk4ZNs
pJZD8s1
OSHfrdz
5ZVy8Cm
OjhC3kB
8FAPFgN
N9H9ebN
PyKmTUW
66cZype
dP9Q1qo
XeFHdGO
ZrVtM32
JQoyWtW
xHLIOaT
cLyyjCS
GZTU0Lh
XYZ9BSH
yLdnave
ld0QPks
M0MEogo
SKnypwe
Opiis2z
lfT2uSP
FseDy5r
ttod5G5
UwqTi3w
i1ed0DT
XPFOvFH
rXmKmZO
ef5PVyc
7FWWcs1
ScS2qQ3
4NMmtLY
9L9eent
q4LQxoM
isbRkUk
3EFWmJ5
5C5lAmX
XptHUPt
lOeHdRr
bU4G4by
OrHGkre
TIWP1qm
vJdcbPb
Y6YFEaw
c0wWOqG
CjZIjRY
FWNQ3g4
jIWRr53
87IK1bQ
md00cRg
yj5gYjA
CCzDwRo
3MdJeTk
IY3ELN0
mU7g4pw
aO3Iolq
zrFstrg
4rQK5NS
dU6uXIl
lVQWbq3
SwT6Ic5
t21QVK3
zFBAVDj
pM0i41D
7nzzlr2
oZrXQev
0yR0aL6
fDk1HOD
6Cc0LhL
K6YS4cd
qjM0GVq
IkrX4pu
PNr2xc6
yxqNfmT
68pd6WX
ci2p15N
Fu0LDsb
tQ9d9o6
pNi7NPx
RADgjzJ
OTPYmpq
H0IBrxq
vrpRj2p
tqwzoAf
y3M6n8Y
cCiEZNQ
7wPe7Xu
fB9XFtJ
wgwdUEK
qF3jrE0
R62ajt3
ukBRGw9
dyOeMQI
Otecd89
o7ZHAgJ
vmA6sP4
9t0ebCm
YbnZqjB
cI5s2xh
n4UGiGn
07AM8Sm
loRTOYa
TiyVwro
ZjuYI2K
TiZOXCD
FoToW3Y
QsZP3zh
wz1TFBf
Hu2WvtQ
buRUQOh
PejK6Nt
0NjhlzJ
D2b7Oql
R0M50ke
L5ocdfg
KqORDt0
HsGmTzR
6zW9NOZ
0sCA6vp
CyI4QMR
PLXLo2f
6rkKusG
xGcjIUQ
KWZ3EBG
lomUBTH
WIBJA6t
zruyfR0
CUnoENT
iNDpGTX
XYMV0Cr
Q2NTfLx
X8SyFV3
3FlpgsV
LEwho3m
w08E7y7
H7TABQ3
CFA0SaC
kcN4Nxd
wRRXAxd
K9DQTBy
KQrjr4x
0y9DUF3
OpShSWg
sknYLzo
yiz1DGJ
PUyqaJQ
T6qlvQe
BIw7QQV
t0m0HCj
Fj1oFNP
efBi30Q
psHAo7c
5P1qfbR
jlqSaAB
UlQ7sHo
9zAZwIf
Gi4yYD2
LbtmD9c
BpEeDjT
jkq8iQW
SwiSC5o
eAZUF0U
6C8nkDX
UcJjJDZ
R4Noqmt
13l3oSO
eXw5wJf
T8YMK5X
0EJ69Hd
NPwzqcd
XRPq3x8
ihFrzre
zDq3rbx
SK8I45a
2TlscOn
8fFlKKS
JVhUjGs
hmWduYF
YMnPIER
Wow2LtB
VH3A3xI
UNIFbtA
PvGlqoT
bVUIqU4
4qHObf7
eAo9e8W
RFGNofO
8F0Dy87
dRtZNby
64Oiinv
yiHhN1X
OSAwk3w
2CR5utK
nZ7njNF
zzRmD89
y2onClW
AKqQgt3
pWLPxgb
FUnFq7x
FrIHzbF
LIckImk
bTLZWgR
Zt9VGA8
a4IJqqq
eZzK7gQ
zndfPHF
zIDnJSk
R2etDdQ
LMIEzNx
Mnbv5cg
HpYbJOi
hvKQwgX
FvrSBV9
xYbsTfv
9wM0hUk
4Nrnv47
BVfbt5V
XYdHBY1
RwfA0IV
5yHFG74
Cgs7Oj2
9Ex9ZvB
q9yvgFx
BSN4vY4
eAZc1Nz
1SsCcty
GzOWdbo
umX8rLz
UhbBdMg
XIHkwhZ
3aAhsXn
iPIXAqD
bX97bpH
nGlLd7H
JbQ9GJy
uC6E48v
q1o8Q79
pALGRVc
T3TJTVc
HfvdJmS
WPX1rqv
KTvxZKT
J6iVudP
cEIqBzg
7crNSSr
icelNPD
aW1JOHh
RfSim8a
k9jMWi7
jB1pLFU
hDlFCVL
dyWaCif
ZTnJX4Q
be6rxUD
8ixef29
AUWbzXt
02GfB5Q
Pdg4oCs
8huRaWr
CgzqPBM
ND4vuyR
4JVa6R7
2Pgcm41
4O1l1qp
qmbyby2
QQCr07L
Guu1zVu
HMVJS2M
Jyqgr54
bEMy175
3uzrVcy
QBAyfgE
GzWxrlq
9SX4WAq
4ALqybW
7r6Mu5C
yB9Nbjn
pPmsS3r
iTBGkvT
mQonSDX
ZkUNEKH
vPAeOYf
iXJwyuu
NOWs3Sx
sg9X67t
8wbtS7F
sgcHNBW
YJm6JEE
v8qXBjj
i7qkXgi
Cv7jVBX
QE0roWk
8LWaMEi
u95uZN9
T9QciTD
z00ubdG
rq8R1Vr
viw8zFL
gDYueee
2ZDF0bE
XzxSla9
qdGPg62
n25Uho3
0Svqih7
YBVNsHS
JF1TYQR
xZFGlpv
xcff9Xm
BmRRKEQ
vnLNqwz
U9co55E
nbhudKs
t7mCuhD
9zNnimY
x9ZvMxb
nxPfXiW
znJ1F3o
K66uYUP
8gW6HsG
vrJbt2A
NZEpXkE
rzZXkCD
nEqCCp7
j2vbbSE
6Lj42QR
aWUxkJf
BUt3rHF
zZ8rkqA
RZOkRG5
FHC2Vqr
QTOXZ5q
qv1g34L
Xz9Ccah
rqNXmnh
kLI9B3B
8NU5kvn
KHihM0Z
joZytKG
JvP7yW2
JjYH0r5
34zQOin
r9L9F8Y
CUVWTip
VNvX3wZ
NM7NQaS
5ZJqgXP
ZGIsPLp
hn0hOy0
VCEGfP3
Inzn9LD
YUdJlGG
6eyGpTu
yAXNVML
Gqf4usQ
Tn8ANH2
djo9ysv
FVBql57
7lbZl76
o2VFDMk
DqJOs5u
skX3W6d
a44lV6P
DFo9Vf7
7gomqzs
yAgdgWS
7jMM37l
wFzV37e
N1xAy4y
uX7RIsJ
CEJaqLY
hPa7pDf
PjBZI7O
sZalWLQ
OaFCqX8
xUmG8GP
waAgkJc
9I1qvQs
Y3m5Mpk
w9UdsOS
pnCB6mi
4KcHYjR
A1Y3uvu
jyGmUjF
R8vJpg9
97Nj9Rs
i0oPkVU
hQTxUZH
b2f34Yb
chDuGgp
Y6ILznq
Bwn4wJM
VnQ8N15
t0sivSM
cWUy3v9
29XTUtK
LsfAKsM
jT93aZu
slj9kkx
B6tHVgh
QveXwhu
N2x5LUZ
JXdfDC4
eERmzFt
vQF4rPV
lwihwlm
aVSTqXY
wLenw0B
P3O5ul6
X1OjlMr
wgxwlFY
HIn1P5t
rLuRR0W
zh8WAS7
EQ7I7wZ
TQz2Hud
Iyr7NES
BFOl5Mf
By5ISZW
nW08n16
6M5cDrH
ZqIfHTg
tStZcHN
n5MaZTY
ZNnMenZ
EF0g2Fe
JLwn29o
f8rybOU
CYaaiiy
S89qomC
8i4LWQ8
uIZdj5k
l5LEsP7
h1tvQUR
jjRFf8K
0qUCFMd
rUC7Cx8
pVJXuVW
bRPU5DF
yRjZxy4
fMDbjDH
RUt29cP
ItC5TFt
S6q1Lhb
6desGGY
VrGYgFJ
xpILS3s
AmfmU8i
OEQevmA
46JBsTk
0bwaRO6
MZ6V2KS
0xvusd9
T4jweV8
7yGcg4e
hsiv1MX
xHTsWBz
HfsoATS
LLVhnbU
i14zFgL
T01hNlK
aiiaENU
ZMi8KcI
nN0Hdi1
IYpIHXV
SnpY3Jv
XUIIpY7
GHk6DUL
heaMJlF
YHMhVWh
YjXiSBk
sVsbmFW
8uxJLUc
F7yS63a
Y0XqPpW
6rII7uD
S1XcUe7
iuUzSHZ
VfqMQsd
rWMehxO
SVdus1r
CCAR8q1
NjRhXXM
c6WBerT
ql0sIZM
0RZnhrN
srLirk0
vw1P5cu
sMcLy2S
yo1swpf
rf6yb7q
uZy3h5M
YQmHCsT
KTybsx8
66Q2XRh
fxmej0S
7rfUElt
QC25fPb
7HRPhjZ
8JP7WE6
ka3Cb1x
YldgDNM
NnHl1nV
OypP4kv
sVs8VtP
rHwr75F
FYsQ9IL
H87U6rF
69pnA92
rZ0dQ7c
OEydCTO
I4Mt2JO
zS8f28N
jkPn7qb
NRcw1cR
XKRBF2Z
XPKyf20
AzAjVTn
RQH0hwg
ijrRhf0
t5DjD5s
cWE8ySs
ahz1eqf
qVoYtM6
S4krFhv
AC555lm
qSRJSAN
px8zyPQ
nm7i55L
J4tMgfB
H9SIRVG
Qr0ZVGB
Q9HDsq5
QB17f6A
daB8QNy
1CCka8z
pXNMRcP
PCz8Yx9
LFwxJ1Y
IzbEQtm
ThkQqTi
8VPlZLb
wgVc5WZ
pJ8AG1X
MwdNC6M
OvMbUZ3
KZ98UdW
bdLXXhA
CBSBgVg
yqJL1wz
A9lByhC
sW0JN8X
MgttFBv
WwzNYDu
y6ESaEZ
ETrEcRJ
OJCTVXw
CqVjKpy
qwOn8Vm
2VmKrIv
ypKYLbu
UAq6rwu
yDi8Gmz
Nvd8jab
s1PYCV2
dDjoIiN
g0pMCQq
j3bmKZn
LL8E7wD
8gqqvjJ
2VhFf7b
3VTPWY7
GETrFu1
yv2YyJm
K4DqZwv
5YC20dh
uOKp3Rp
Uu92F6W
QgoPs6X
6S0U7zA
qloEVTF
zO9cm0y
xnIaTxB
DWeohjf
qsMZHNr
LYxNBWv
iwt89en
WYS1Xq0
lx9CRgV
pkVf0bo
RfZ4lMb
CJnXVIA
1OAij6G
r4ylJlC
ngzRPj1
AHoRA6S
7330H7N
FiJVNPg
SyLsd7n
QWiJv4k
42QPzQD
fMNEOiR
YBtnXyu
kR8GSGt
ukbMMYz
SrT2cUx
wmEavp4
RyUdt5y
QiiyqAY
6o5bB2Q
OT0BN36
0o68iWa
6RLF1Fq
lpjSG9r
z0IBKCA
DZ3keL1
Wz1SfiL
aYzMxs1
g3m1Zyh
vboGMlp
Scu3xzq
8Ktju8H
HRuaPtY
Ylxshn3
TPR5PsD
5lKPisd
Q8Cu6fK
z2glbjT
WDBWbMc
tScECEl
f4I68ZH
jtqOZdB
4AE3ATa
mEZxREe
LDQisZP
RPAcRDe
W5yy3Eg
3qbsPvr
aZAE4rm
NANQ5et
gM6hx2h
ymF3V2y
IWxJtm1
kR6zN8Y
vpONVMJ
AgY8x09
sSSVhka
d0jZe5d
6B4DsMc
G382Dr7
atbV26L
LRLTcrX
SZ12WXQ
sldNFQq
e5CjOIh
YpwgxhU
4iklIQv
AqW9K9L
XdfNllY
WSXlOTr
CQjRwTk
691zdHy
VU94qQc
MSfBix5
D56lmAI
PUUFWga
I5VGlav
MafGEvA
tAR4ONl
iCKU8er
eQh8lyO
yLF8HJE
LJP8kCU
64NaipD
3dkfIrY
li1c3XT
Na1SSJO
WuUoDzH
O29LgvE
Vx79DLd
tpwBWV6
sY2z66U
5Fqeprz
yx7ivnh
PRXq1eU
QKcvJlN
OHPqFFw
Pp60Cxr
t9y7ila
aZ3WI3O
5UmctUA
RzWB8cI
5SCUivy
RORgug3
SLYEOJq
lQFwEFo
RZ0I7SY
r4orZEk
wIZC1d1
uYYpwqG
jx6oRKr
ZwOCbRT
T9vNxly
MfT0ZL8
6SXKWue
gPDNcIK
fN0sEhv
gao6Ls1
aQeYOue
7SCScdf
RBEdI0J
WxJUhoP
Eale3Pf
3lxX2UN
Rh0EXnq
1dmokiZ
4tHiC9X
lrnmlyK
aE1jWK7
oYv34DF
AoQ827c
cOQyLDn
6dKOk1B
21xJczU
JIxB1gx
7CEnJ7i
ZlJPHLI
Lefiosj
uvtsJwG
omGbspn
mlssJP2
zBkDqqN
aJXCo3p
5IK66CN
h9wM2dG
h7aYIIL
BeonouJ
rLjKHU3
lffJJaS
LA1opTS
N8nNO4l
y4N61rv
mand5rB
NnDRgg0
aeisdI9
B4EM2oG
zlSKGxv
BU9lM1V
9E1k7ph
lEFwf8G
haFrw97
fCuuK64
gBQd52S
e7uOusP
fzkpwXg
pEnD8Zw
hVHiviU
ZtV6li9
fonjSAk
V3NKIyk
j5yIEj5
idwR4AR
O3vqe3z
JdOrXp6
vtG1e1G
PhSElV9
D9mCG8O
9Xrp7qL
6TzPram
ScGImXb
3cBW05R
f6kI1ZN
Y1oh7qt
r89pKIT
NLpgKpN
TXyMYE9
C5D9Y3L
ZbDTnsP
pZuzP04
RhLT5ox
0AzfFOf
xpoRcdm
Aj3A8RX
FWmUbgi
5q6Y371
Z3zfJNr
2PWCVJi
xoQnJIC
IGMk6FC
mUYZXSc
dVvkW1y
yG2XHE3
E9GXuBM
VF4DJGS
PApXlPV
nUApFn1
E9RIinW
y7SGTSD
VDT0yxQ
HpoSsC1
44ARsFc
A1uivpL
6Bteljn
MtjN9n6
0bTFFJH
mUhwJRt
WNq4lSH
3bvlh5f
Loymwul
S7cxrqr
1KHXIzS
kqpohfe
1ZXdiBm
M8lTK75
5Xfo2Ah
83nCGc8
fUimklN
oor6BUo
MBqIC0K
vwDD241
uADxKMM
IpWxUCF
pjac40U
t0Lly0y
Q33CiWQ
cVUMDZk
XI69gcV
obRXZUI
eXgpey3
npTGnpk
CoHAGte
aM0IhFt
F0YsNMt
by9mlu8
H9DdK0x
FiBTixq
J9ZGctg
uzIJN42
I55dNL3
l7MXCNJ
lCYD7Dl
MifthIH
03UL8SI
Gowl1Ye
NemJ25v
u2nuBL4
w40yebg
ml5MMo7
X0g4OzQ
rIKHVDS
ulsnKcF
qKS4dq2
tfFVdJ5
1Riv9zZ
kHiRCNz
p3gTiEV
VKHRYlz
4mos2um
M9lS62n
B5mnwNI
6Q70WB8
WyskQKO
2M2Uug2
OhCErsN
G8FXYgG
2e49KHe
m8r3BXp
ZEUfNxP
JVVnmQ2
Qoox2S1
l71rtkr
ZrObsuK
d8Ma7RT
bmhG31f
1w8I38R
nOcTpsW
VrjUiFJ
KzbDxcX
Y6cl7YU
pAi4YDR
SDfuY1Q
dIt2MMt
88Fg3dJ
IHVWtPO
G6aNJYK
igxGOAN
CwyyuFm
rM6fFr8
egANMKH
01cxC0Y
FNWlwyJ
hbHYm6w
SYegUpi
y1A6B00
o06np2i
k7CwLQ1
7Gk5cFw
NYVGSDr
A3GzzvL
oXwJS9J
Ls73Yo6
dN5Zsay
TJOsio1
CFgtkMZ
RMXk0hU
IHgwzaG
W9e26MW
c4YNmZQ
F6tvNw0
1fOInN4
nIhkewh
kjyqlBN
nXBCQpi
MGar7hw
GaoCMqc
SDDaYQj
7IH6xEU
x6lMg3I
gN37I3e
6ScQBhS
wYtgWNm
vmmffmR
GSaYHJS
IrcJ5LU
A3WgNIs
FZ3INKy
cTDPaDO
7LkcVMX
6zUIXC0
ypVKKDx
8cozzbh
lBnlsKd
6XPXPmA
bB1bUzf
xer5KkZ
Rm0N9Nf
loEIHot
YKhHb5l
1ynDXFU
XZlkNz2
M18EDt0
2eT8hnB
rNPLIC2
Uho9orE
N8EQILA
qVZjaYA
2y4twaN
mGwOT4F
cu1N2kb
bcJ62e2
GU2eBPs
fETrDj2
akbgSGS
Z6Me8Zq
8fj6Fpv
dWIao4w
6DF3b5l
U8Horki
1WfhDIq
X9WgSlO
47yVvV8
3xhH1la
M1AIBPl
n9IBfRv
DsLctsT
HZM4JYt
4U2cLdG
TV5SYGa
yCxXteM
f1sDYe9
suLd0x7
cP5vlOf
minv2Ns
5V0mRDP
CP8tPqG
y5FKnLB
kbCBHbV
LWClRsY
nyhvP0D
TqpaWIL
v9BkIWV
r22d6Pt
AZxLTHj
v9jHI0D
su8CTXU
zDjqhgY
lx3vBXm
3a02y31
D2HUkaF
3Tii4zU
Nw5EBjz
Ijq70VC
VZdfY9r
n4fm6TM
aCiJZIQ
VIfdBqd
jcgW2h4
6XPmm6l
uf4KEcU
avMiFba
tvs8Bas
mNaP3p0
7i55pL1
RVPBvzf
8fK9tks
8ZMgL3h
gW2ftYE
cBQ8hH5
RORVRZr
hzDf8dq
3uZhRk4
gRHhs0R
MeI3cBm
JqT5wNt
9zqhpYH
o0Hqt5A
b7AwFgE
r0l3ogu
VupuAEG
HhfnfyX
JFBYNjt
4Oh3dEJ
NZjwRoC
AUoK2AG
NNM8rZ8
OX67ib5
JWH5zAb
IDygWOp
xDdWATx
9Mj8zlB
7pFMZ6i
5c0M1BP
Go8eW7f
BB2CJVS
qi8pGjG
rLZmlH4
0jpvh8w
co1BEsR
YA1yBmO
6BcrMzn
kMunP09
F1Rhfmp
SJ7KxDw
6kIuyHW
qo2DkRZ
MaTkO0W
vly48NU
7EpUFSz
gzFs0NE
bl1JkP4
BdBevlV
MExATkD
Y2oU0vi
gYrX9dn
nMyC7P9
cohjCry
X7PsL3W
rOwgwMB
FMx4iS2
Z8C6HTh
RcmkVLz
pqC0kzP
hhZAZRS
sgtOmzN
t8TcKOd
gi9OoSg
IMobmdf
E6t4e9g
nJqQ8Nf
gevm4FB
T8fJtWt
YdUMsZL
olJUryD
3o91BhC
dAyUS3D
Qec0SBg
IKyhiJf
jEfOIAo
8mKaNFR
BYyuhXe
2Z2fWS6
n9o2Roq
ja9MFam
ziuO60J
RCXD01m
5RTP8Au
AzSSbXi
WbGFHfP
29UPfRN
C8q7TKr
lIMmaAb
JB07XH0
eOkBHGa
pVWUFNE
7LBTb9J
33m5JPv
c6qWOMj
ySS1X81
Or9nqWz
8RDDYry
Ell8RHo
fIOIFKd
EkAtKhn
OxIIJLc
aOaz3bG
cjQnIPI
las6dyL
QmuiBfU
gI8UxHr
09cb38w
Nx0nvPG
LFQfq18
zFW2R98
LTZqpBT
5OmKXWN
GDOtvVA
0Rp4MYB
glovEe8
zmwn8p0
N1E6zJp
CSe1jTB
rNSFoUU
phopnts
CYfYBQU
fpvxKoO
L823d03
oe1sqwv
FECwEN2
fwA7fJ2
vI2GevE
a0zYdzg
QwTtz0a
vRV10nn
kS89eLy
DNzeIJB
Ylylqpe
ory4IlW
WoA0o0G
McIrMkD
JSTg0QV
VHQ0VM2
Fb6ZyGs
TaqKtC8
lzs8q4m
D1akkSM
05q0Wlg
dEH9TJZ
vzob2tY
pZ3hgQP
fkyqWUE
BOXL1pS
ALClWXs
KQCxice
JSxDvO5
GJpAlTY
SQ5iEJK
GfXEiFV
OKm7VGZ
vZgwbvK
IWEJ3lU
riyriWx
lXYLzCl
jj1VtfT
W0uvPG6
aixHQ9T
iF1fhAn
8fAYwEa
madFuvs
sU1GH3X
mE7fsfM
V6caSXf
nMKjnwm
BSIICoJ
qTYyXE7
zh2bw2b
K3x1iF6
vyly5Fm
45OTmR3
da1CyyP
ZVm7hfQ
G93mtZx
mAMGOpv
91pG5To
bGv7zGU
NEZbpNy
taxLDoY
gKlAJKy
YO0QJg6
35QM1O3
S1nnjO1
I5KS2Ex
kkQMxam
FjVqD8R
LrsR38f
1cfvJoe
8b6KlvN
k86NkeJ
HU1Q6Wh
XhxyoME
jfhkfpv
mhqvFWE
vJ2tcdc
edhyrFU
bqu7Oja
D4yoana
nVeZtLN
qo7VdkT
yPQFs3J
NNbsxqf
pkwvZLl
epETefl
SvQHhv8
vEHOiah
d45gURh
4gf06gW
eyREXfT
OcC8FbE
cPLykuh
aKwfZAG
Zi8Vxqz
W5jwyTW
w3TlXtD
o3xyyu7
HKLrMcS
vOjHTPk
uZtwAaP
HGtMf1J
qME16nS
oe25YzI
589633U
BRGe8vB
npZCv0a
AacVdfU
l1Xe8Qs
0ffv5Hf
TDzHVkd
ZXCs6li
uuZycEx
g8R7u4l
XYckY6a
tria0dc
oX9tSV7
QIxbTqC
ajWRxWq
285kZDn
caRlcHb
AWscXvV
fznTpA4
auJEvkD
kFxRZTd
ctEG4sl
eipiUOT
y9pNGYN
HsRKJu1
TZ9h7Vv
fusymwD
RSHIHpK
mpwVCJI
wozMy0j
wZelod3
5A6ztaP
94ySWPr
1wKFKiX
b1MhMZ3
oXSaxLq
JyzWXug
p6QYU0b
5fDSxYY
FTPIQm7
I5jH5OL
cpLTlYX
rlMFMhl
EN57q35
qtPkypY
jGWSQyS
7r1WdUg
7hdW5V4
70ZRXIo
w0ZcvVd
s2kpv4m
8KXrWSg
DhGWVmV
rJKBzeQ
4UoKcDh
WRL5deT
9Q5anFS
HXRidob
pBJZwxV
E6ooaoU
MZSXKFn
84secmH
wUyj2YJ
J0wlzxd
8jhNksN
BFgxamS
avo3Mgq
Lqs67cz
PrNkUDt
XNySGos
fHb8wFy
xoWSXkn
NRCSQtm
FqeO50G
VP8jQUH
iWAwOqv
cPVGUgO
YWp5WBq
a8IelNC
3724JXC
qS3sTYe
TtGwlbM
SC43enD
NgeoWC2
BdEYjAC
tOpYaZz
a1eDBbe
YkTsn8Q
TTOSC0B
vgmLiD7
NK4gNlP
GdBGdu5
WHcGb1i
TNEC7OQ
ef9xQmW
yYkdHi9
3zzkJQ7
zLe11Aa
0VqLZkm
gUUjYFr
JHgOqBc
qcYBlkz
6ZQC1ge
c3io2Zn
8pHggsO
SsJQin1
7ktyB2b
uDib52c
bUtnHpX
PmQLZnT
ejIpul4
KBII1R8
9CsRbtz
RT57IzB
3AxbvnA
Xap6Fb9
1ewO9a4
oNgylQb
dvukbiC
C2tI8WC
juQ4J8h
CXLvop6
FZg7kLI
ioy9H9G
hdTVarc
Kuoo3cT
mzMH8vH
n1oKly3
ZRjAXGq
JeUnQte
JQTKgXc
1CBnpYg
7MdhQjX
S1bQjEZ
oy60WzM
gB0TLis
GlGQnse
jEavDTi
2LRXpy3
WUZaRMW
vTfWtac
wZllRDE
EiGIDx8
kng0UJr
Yxn4AMJ
N0MxwHX
e9mfVKU
lm0K8JZ
pKIe27e
ULBrkAo
qhjlUIk
z4m8t7L
xl7smRP
wfD7tir
owZex2X
W2BSQhL
pmkbslg
SWK3Fim
8ifSfxu
2EgTZrs
1O1Sax9
u5gBBZr
q5kiiBN
N5eFH11
vFgPxOx
LAD1Vg2
L2w58jR
qAsBKQ6
x2rMihz
C0IwiGS
eexTBqs
knyZDiT
f1HXheQ
eLaZlxW
MZ1E9rs
xY91LCB
Z3OGSLZ
ofzTiRq
8x3IFMz
4R4sUs4
umvMZQl
i6ycCKo
EmOqfe2
sZbX6ib
ZGbYZ3t
qNybjoJ
WWtRQ35
KqZwUkt
It740uo
3lurqxj
H4cpWLd
ajzd76P
07PfOWj
5twGh41
LNP1fLB
A7s03i1
b9EYIEg
irpZX3H
kzupAKR
vUqs07D
N18xEfm
7neiR2q
nfaAZoV
9aRyncf
JpB3WbB
YM5POoS
NH9Pr9m
gJzHPy9
yXuPj6m
uV3hyTs
E0pFucw
oF8mP28
Li0AkHI
B39X6J8
hNe33d9
JG5fola
1tP8oqg
u5VGFjW
9MBJ0In
T9CQJwa
Ig8W5LZ
hG7CyqB
5Wbxjo7
m7BxDvV
ulRhal0
zaV3kfX
zDsgN6o
c6h8KmH
3aj0XUP
6zUxe6V
xbp7EkC
RHWjnfP
e2A2Pwm
uMhwPcL
QuUaKsr
xulnqbs
OV6t0Gc
Nc8DAOI
3lP68iN
POMnCCy
Z8LjXhL
SLfHXAL
toi0C5P
9bJotyP
lzenzuq
xIhD3eW
9xpgw1F
KlPJvCI
tbXOjZP
0BVh4UH
OKJIzoW
eLcRfIE
iNUUNqD
JhiNme4
gPy2k4M
px83uwN
J8BEQAv
eOm0geP
5AeFGOO
rMxaymZ
MAL5lPf
068Jkvo
CrdvjTv
kIjkLO3
RK4hC03
Ujy1UPI
zQDvBkw
mujcYGE
wFzYQDQ
dXooV8a
C0oueNw
Ja8pO6L
IPo8O9P
AFkjvZb
61HVQau
WEi5YJb
ceigaWo
IaIffZc
SYrKQj2
p0vx52F
Vp1wzmG
4yLXXXj
CNsowOx
190AVOz
YKsAvgM
HLC43Rn
C8BWUVB
pxC2iut
vUMqhJz
B485XY6
EwNG88j
PWSg3bk
Vw3azAs
PGSu6Xw
Zrvq6mj
UkTjoTj
ZGrdSLC
cVktA8e
Hn4motm
rv4Veor
ugpWwYZ
5VruAMs
k5HJh2p
J3LwRGg
aDB7ISL
Eoz86rQ
hBMOx7w
dV7Jio8
Baj7t3J
ncA81Hh
cmuufEm
7wpBqEr
4lk1wsr
Y0ppLIU
E4fdQyo
UyUNVZk
vzjHmSs
H9kpRiE
iTyDpIw
NscDzbH
GP9s4vU
TDz9b2C
RFCS4eW
YVkMGn6
KJfcBEt
HSJ3fd3
xoi6sYR
wtwLWfd
maO2kVV
fxHMNdl
vXvh93a
7Gb23XM
B4CUqkH
HBTU5Wu
tejfUYZ
ecRUaxL
oj5LCjy
fMVGcua
Ec2x17n
FBDDZ4c
dFDyVii
U8GIC0U
mrA7CIF
acn8XcE
tlxnt3J
mAg8WMY
fZAeeo4
nw0X0NT
NnaMSQu
Uu4ZGK1
4q0MoKa
KyjrnM0
Erlmolg
IzsexCt
UVqeZxF
aPkNDRo
Wz1Jjsl
K2nghJO
3h4ONap
DWAD1zN
aWx5dtW
RDU8n3J
FvQ6mLs
UPLgGcx
lX7P15N
cNB8RNV
qnEnwcu
x1S8Dc9
YW6NZod
HYlzHLP
aUdRApJ
6GzJs4E
bZJGN2G
EhrfHTJ
LWsIlnb
hNX8Scs
U5VLMiU
eag8Crg
d9frnDJ
bWCBkd5
CgqpP3F
r6zrJ6n
AA22117
wJrWOPJ
8KrSCxD
sTStDFz
weYvIYm
RkLRfMw
6AxcqEy
7busYp2
kVjEDIU
MTZ9UZG
3YwfhHV
hGVzTiz
mwoqPJz
qMAk0Dz
uWXhxPT
PG9TdFW
jkCvtQw
2gUKntd
w2JTf0W
7sZywCm
IohkoiI
wH1PzoO
ezyRz2G
NiECOtu
e9UUhK9
BVtQyA3
gYUbn4A
W0i7NtU
KSNGDG0
9eMIPoZ
ppP1h09
lOy3IEU
vNHXUeN
nlN6Eq1
AKkTWke
x4Ibe1U
b2deTTp
cXBotQ1
FUyBCX5
8dHIAtb
IzYivzD
vS9qRa3
lnYdCfd
yrDNPn1
0Gbf1bf
rA3vk7g
g09UIya
V7gosJt
nPE4SZU
faROuVL
NBDTmYc
1yRonN5
vllHgrQ
IW1mrBD
rpS6a8J
ykv7Y7u
wPuxC58
LS8a17p
dBQYFs0
tp6ABqG
euVDRts
VVluLmE
FvyBPat
rl7PXiU
TJxLJqp
8oxXnkI
aGVXdIS
zZkMQd6
sa2lgw1
P1FQ9Fs
J9Mm3qk
GPAVB3e
7uy8Ia0
BSCzUNH
ULXYQAh
x9JQ2GP
Q18r7sn
PipyZ5V
orot7B4
aH7zJsr
RwvseQC
QvIoqRh
8wl0c3j
SBIbmEx
uFMIcWC
kvFS4An
XqSNLSv
C3WrUVW
9SQ3dK6
xVn4Flb
VjS8BbK
iDT3L2g
HpOOqYZ
AWDmXIH
R5uGYMY
qsdi91I
i3A5ecx
c4esYrf
55jNLSM
rleqa4E
zrAazjJ
FZ7swkW
JFngvNt
AxDt9yJ
D4x5eRt
ONVHEdp
OtjVTXk
9MvPfYs
jQc33Oi
RmsThlv
6a9YC1N
21QWv5w
W94C83A
htIlZRO
YqJmtO0
db5V5Ub
AzcUxiP
NAQwsur
2jeJVxu
R9xt1Vp
x3ujmZt
FvZT5iW
AOVRmhT
as63lJv
3xxp4ey
PIKcYSc
b5cDCbq
PlTXC22
g5HmA0t
TouJ1Ed
R1SFVsB
x8iM25J
J77n3x9
Ok6Ict5
1CprvSI
uWj05th
0y7EopC
Ywc3lTY
uzHKpyA
Nt7ylrn
Ue5HvaV
SFjhWIR
9wF1wJr
sjb6LaK
ETVarXY
rKFh145
BapSP6X
hfEvX8M
UxBzPVr
uzj5OKo
uNBsTWB
ejmLzMZ
uIqXydj
EapZ6Fm
MNy7GkM
ZBIc2C9
Qp7Ofnj
g9ZfBGq
kvdAgkg
uVmDQqH
oEc9kga
d2MHNIZ
xxvnrjl
6AMktqr
qV7hDgQ
mCugy6C
ZhNpROg
tRF7ZMx
dvEZpfG
WRxwicf
RetEYPh
OV47mUd
XgmTmj3
cA0Xnq9
keWSpjr
AyhRNb1
5hIwHfo
pF7xxfi
WvSPTlC
y7tIeL9
kO9G9po
N6sWooM
zP9DZmQ
LyDZOJs
4DEUr4P
a0NIAIR
qZOkNUV
tEDdvxi
CC2ic9g
D83ZrPJ
UusUopo
G5ETOtW
r6PBcfC
IqMXu7o
GVqqXD5
cj3XoVB
gwOposb
2xWxDdO
I3Vth46
YvZubzs
yuwmOXD
7ktadIy
mwRmFS0
y9842zm
JmRdNPF
BqKWjAq
ViQp9dS
bGt5nh9
XZJAFqB
3tEyL21
a8b2qmI
EhiRzDS
ppDBAPO
ijRFS3O
kQb5C6j
F2VOmv5
QWQSDMu
HohHz0m
NMflUX1
96MwQfK
B4eVfB6
yDQjEzQ
8p466Dr
vGc0L8w
wci1Wio
kWmZhMo
azkYTvm
g7n4dM4
lTYFh0D
Hykq4ug
c3LHnmi
n2KC7FT
x3d0Qql
5nOJdXA
lA1B6cy
iOPD6r4
JENrwSk
SbqMdGS
OT1ia3N
gSlkxoI
43EfpEC
uBsdSbx
wWXZbp3
B0hlL2V
2GV1T4G
9twtYZ0
dOOjQAP
aD1dFws
fxhU6wQ
VkNM9wc
lPmP55C
aE03bdt
A67RSqH
hGozUqU
ECP3uiU
1byyDcr
9oUdWHk
g2nwqWG
wL0dWjQ
aMZK6Oj
wjnpLZC
u0K3ZVs
6gkvl7h
Qe0rJP1
d5neYAk
axkEX6B
8vHTyWk
VEWCBoZ
NmXbcsQ
rEOpRF5
jRD5Xm1
tLrjAh1
hGoXiRI
6BbWjgh
N4k2olD
Z90307V
XbN10ta
q2virzn
HGibm4r
y2nIJh5
duLkNMd
4JHzrJr
Mf26fYH
W0B5kay
zNOrskI
9bwYg2n
ReeSU9E
xY3sKMz
a72VdCK
OVqFvA0
fXqYlCP
zOCq7VH
XlIXcqj
OILB9GF
w7qc1id
NtCr5CL
gGqrGiR
4asXNfC
P8LVZ3Z
AifCT08
OjTROXu
DXoa3jm
ACsihNq
jAWNa7w
oMMrLiB
XAwuyDO
Mj81AWE
em3ogyQ
4afTXZr
nT4jFnh
Kub6Uew
Mav94RY
eKD275U
RYUF1cD
urawWgW
8BUIQzd
iXBAiVm
HoFYfj9
p84cuAp
ZY915bG
fYGX4Mm
c5VINge
8rbxXgA
WHZzNa6
NL7Bwea
xPK8cN9
lqm86nd
F6iK9Rf
jdsJyLr
8WgyzIP
6FWiQRN
GksdtbJ
acbk7IO
kYbq8Bl
IoqXpW1
FlZscU9
vcMbsGF
Zri0bol
7SzpTvT
SKbKyJc
TjvxrNs
arb5CXd
u0zgKYD
LKAeqSQ
MdCwJJI
K6dIENB
c4KZFBv
CWwBMiV
CYoWc0M
7NVQ4Hk
l6XROq8
Xyr0k7F
3c6ARzM
zqJktLb
Zm9RGv9
1HXlhxl
kWN6UHm
vbsp72f
a86Lh21
4GprjRj
V8su7Qt
Wox6f34
Gdmo32E
JnWDQz1
2j95IOW
lJswIYM
qntv8KW
qkZyn0P
pMzOqVt
ETnaAnl
nIR0IJW
RUzKBEx
J4Tzhry
y07jH3c
bVQieEv
Ju2GuwK
BhHFtyl
EDV1ryv
YkiQdwO
F2lmgtK
Au09MV9
McdvSEU
DyrCUVi
iPDTPLt
PAY5QS6
b9B2Mnn
Vu0tTaM
gyE4NKh
7aWZqzx
Uwjq4vm
XIgbHiv
teWm6OT
ZiUTvYA
xA8Rqfy
cvnbQtB
YgN4UeD
VoOYAKs
5HzlzBk
ZYwqtaY
o86Nxza
ciA9G0e
aurw2YW
xvRs4hb
S3nWaDy
jJtuwUC
wgTgUY4
AUYodwp
YraAx37
hsqFWgZ
oePJY7l
NAsSRHI
atwI7tP
6wRFEAj
trIPry2
kbrr4Zw
dbo5Krg
dcKaCk3
ejsnlPG
nfVW2nY
3KSMP0s
GCAE1RZ
AuHVHIj
RWnpn6V
iAZ2dPg
XtaNzWs
Zh3geu4
ywocFQM
EKjS3mB
xJ2vtNk
UF0CDlO
PakKwUt
rzirprE
7V9srAX
Q0AH7qk
tIImrSC
mCjV4YN
PWKFtdD
h3QjKyJ
Mh58Sf6
uCIOsMD
cTol9bT
VveARDw
ufNx5JS
GN6xyTx
4VGJO8m
qroVT2L
eJrWjUj
620NBQR
umHljoL
RYUKm97
SoZGyUu
G4N3RLQ
4Z4kjJd
Ab4WX83
9gy8cOJ
bni0uxY
hAE8Dak
5vy8SQe
CvshzUG
Cq71vg0
GRLLMM0
DPApZ8w
hOCXEJF
fwHtP49
bHmxNlE
rGMePYE
gDWYcaB
TREkelZ
uzhndbc
TvESHAF
GH6vDdD
j5A3cuR
xUAb6et
IkSBVqY
xqvX32q
z7UV0Ig
jVD7SCV
lSO3nP1
GRp4xWu
i2dFSHp
hbvUfY5
Gg9LEaS
jX0eS9y
dSYo16Q
WFdk3iH
BLMHTbj
no6IJWt
yty0huG
3CtUMmA
TDbB84E
ePopsAQ
bzG5hLo
lxCtPQf
OHJHtWP
dSALiLy
jMcOl4a
GdEnpns
BaNltm4
XLHN78c
pMgIDYG
Xkycdij
BBwQFeX
pP10Ap4
EZ1cgUp
KLjMjh3
tIQf0pX
DoR3MSB
DcLhwnW
bBQnWln
SzKB2jr
KMZpsFm
GAONwba
Wo3vYPe
1Qv4rIr
zXQSGF9
9K1ppYo
XjZY2gs
NJ8iHvB
O6aDolZ
iUI4kLX
POVX1bo
luJxRb4
tQlIjok
3LchEed
YXWStD5
dWerWTF
wg8BNlp
6nmaaDt
mH5QhZd
1YTD5e4
6Pctdsy
DUAsihn
HpuNtRx
tp04HJP
dp7bhQL
QZ0OMhN
nL79fwC
nYBYkpw
3IRIObV
8bR199w
GR7a7xs
nVrIk56
3kayzBK
lv4fOtS
IWgtXw1
fZW8L4X
hq6LxxW
NVR5jQt
jmwvNmZ
8VQCg8j
ZUCHA8W
1c0CwrY
Cuhuo6q
RHyHs2D
jWNwcfd
TXvMfg3
6SfPBBw
04lKzkE
3LXN2nL
HuTEblJ
EcIr1Xj
ZtEzjel
BEVZ7Dv
7h6YSaR
FhfWZRT
hkWmmDc
WbiaUFG
iwV6C2R
eP43WoZ
Xfs6uU0
bxCcbaB
vfK3qDY
fVaC4g8
Nqsu7iy
liw2lcY
3ZjjfS4
k1cZbst
EGCAlb5
92MHF37
SHMNHTI
sK0Covc
tMxx7ih
ZJmkrmG
ZYmo5MP
eDLyvCW
lYpjKNp
V9YzzMW
HNBypTR
Q1RXXlP
QiGdL5L
vKspBpT
el0qDii
Oc4niG7
p19xxmI
yyoWkIR
WcFhZVZ
KVYZRTr
UjQntj3
RAAVqpo
Bjbd21S
A6QgnM4
2u8kh4g
fYZVNh9
JsH9Vut
hJxkGrm
KOVU4vY
fEy6WlK
O6uv0bk
bQ2yD5C
RrFOFk9
7BTORhc
YeY5H80
3fzOtHV
Y8zwLB8
Picc2FU
uhofiME
jrwDegq
LNrEmez
b9tTGbl
gkcPYAs
T1SMIyV
jbMPWXe
3e5Fv0q
O998S3T
qMV6SvF
qKFvEB8
6qWglOn
3kwaNlo
Kmbhioq
5wDUA2v
vBTiJfy
eQ8vQft
tIUUORL
VFu7d0d
mEbRF4B
BQSFZ9D
LTNYPFp
emVXJQ6
BvThl1V
nYG7FdK
5WMVN3I
JihIyqX
SuwocZJ
9FJXhLq
6XmYYlW
DOcRQIk
NefNUvL
r74gHK3
MpkyDB2
vYnapg0
cRwFk0F
aQPc4Dz
kgiP2wf
o75rvNp
TRBZtto
aKtO35f
QdXyX5C
9wkfjDF
8jf5mXA
afM3ioB
XHMKL7r
EPgSzfz
gqxbbNe
ruGiE8e
eqQa5ht
punDCDq
JtBQDCa
YZXhnMF
JnoJ4KG
8mu4yFl
6cngnIv
fcDUR4g
9jErFWX
buFWSwZ
19rpxTb
CituqkV
pfv66B5
mxrIlGH
LYXAFIP
ILVkW7a
jIPcPjh
0uriMfg
7IYRIXj
yX3iFv8
Rp6bCH6
p17vkHM
57sCvy5
qvVWMer
f2XnQZF
5BmlYO1
W7agthB
GHNUzbj
HbuoHTa
3gzJEwO
RdPZNLi
OiezKOU
vYOcYoi
tDB1NA8
yjysRYZ
wDA0mkT
SKOBdLn
DRWCsyp
Hjrl8sK
zm0WCiR
aUtmd8l
rF8t1Q6
llT2m8L
wLtdcT1
mEW9t0d
nB5pYRF
RFYQNny
pOMdVOU
KZSy7aj
ggCeD5F
I258sYv
XuJmZM0
c6ttJb7
TxjBq8k
fF5whLP
iVh4iPP
Kdhm1rl
y2KJ5jX
km54LaZ
0vvVyel
8fRqsyL
mo7Ja3i
2sWXTbT
diIpyT4
uiX2WGh
XSQR2JO
uxBezHQ
hZ6ukhx
5EysSnt
GCRjtjr
kcqy8OX
7ezjcjc
qh2Ka74
ppanSR9
nJIHLmF
VFcD6Zc
Q60Um3y
Fh67D2u
f4X0cD8
LMPIwFe
kRNXvU8
JJRx49f
ND4qqO1
qN2GdEG
jczStwt
fATutiQ
cp0vcrR
zrHv5QL
zEvuWww
5cf1dWa
WXcQQlN
t51QD7P
RzEFHnk
7PpGiiw
Q6zJ2Sm
zLRLtZu
JerCvcN
Ony5JA8
sMspNeU
uYgeRxY
MNhaE4e
znEUzJh
hoW3p8u
yG5GyN7
xgWneoE
bxkwXDs
cm4Zgzc
pBVH2Sb
4smtFIC
lRib9zx
EhrFAlY
WvhCxq2
luD9Y7d
7tMIEez
ICDDViR
Al4k8ne
LG9gAMe
y5K5ndu
E2XsLPM
6DUdMrC
WG37yPL
vclRj3X
JgEdi7T
JODt08A
scqtBmo
i1ZlpCd
Ygwu6sV
jQVokYh
3FdnS1R
emcBFuh
XVppB8L
IvTntY3
vsbK1yq
KSmvYpg
7Q6W2si
fP7PFdW
2jNnMAZ
Wk3NR5Y
v52WJmY
qLxwSIy
Xsy8uPA
1wovMJO
LlEPFn6
OAXnx9f
vPbsOm7
LK0MwXo
lxAIisw
Oqu1yVF
XSD7Gef
aArlwSM
GHfTjnV
eQiTAFb
BoVyTjI
bDdHpLa
1nCo4zn
MO7J21N
NLe3PhX
tZJFCqR
UWY82OP
7SS09bQ
K58TvOX
027ZIHo
3p3eFRA
DJXq9mr
Z35LaZy
ydRvYNI
cTRUAU1
zaWduyK
xcGp6WK
yZ4bs2u
M6PnAfW
bstLrHy
c6ago7t
NIBpcYH
g62oFpo
YYcO3Jp
W26Ou5Z
kiGa2ZJ
mFb5hlS
lezpuZv
SQnffg6
oQ574Nj
8TEkEBH
lvMPg0R
tC4NZKC
gtwDgQd
zEXwDym
ZuE3h3B
INtwrdD
ZwqYM8s
3ZhXRlI
IYPE8vE
Xwhr14s
XNU7Wj5
x4rtJHt
ARcNuMw
nWHjENL
Qdx1FwT
xEeN94b
m70wOrt
oZVbzNL
pqo8KYY
DhJXPlc
nRQseaZ
9Zk46Aq
hpDPUG2
p46RZ8T
TZ8E8NK
xh5bGYZ
riofJBG
MAf5Naf
TTXRbS1
7YA0vdI
wa1tO5k
qtb1Xzg
12KbO86
DIVZXKQ
hQJK3Og
F1ykYWT
Lb8VIqu
sNHT32v
NFe3rS0
6SWJgUH
RF1elLn
l3AfQQi
w7HjFFT
q3qqTJ6
cDFLVhM
vYIuPPC
XtS3KBx
Qt65Vdm
OyVIfYb
TnFEqUS
beSOyBl
VsnEQ1L
vlcHUJF
rpgxgRz
gIu7SZ2
DdN53ni
x9Tir0E
WP6fNuz
COzL26H
CAufNv3
xxfGmzB
ohRwVil
KMkqpRR
vaKG23T
9nAq6ta
Tnd1LFF
9jcxMAV
MwdVnPT
mC0ptlx
9NfuBad

Computer Science
PLUS I
Volume 1 : Concepts
Government of Tamilnadu-. Government of Tamilnadu
First Edition "#" 2005
Chairman Syllabus Committee
Dr. Balagurusamy E, Vice Chancellor, Anna University, Chennai
Co-Ordinator Textbook Writing
Dr. Sankaranarayanan V, Director, Tamil Virtual University, Chennai
Authors
Dr. Elango S, Government Arts College, Nandanam, Chennai
Dr. Jothi A, Former Professor, Presidency College, Chennai
Mr. Malaiarasu P , Government Arts College, Nandanam, Chennai
Dr. Ramachandran V, Anna University, Chennai
Dr. Rhymend Uthariaraj V, Anna University, Chennai
Reviewers
Dr. Gopal T V, Anna University, Chennai
Dr. Krishnamoorthy V, Crescent Engineering College, Chennai
Copy-Editor
Ms. Subha Ravi, Director, M/s Digiterati Consultancy Pvt. Ltd,
Chennai
Cover Design
Mr. Madan, Free Lance Graphics Designer
Price Rs. :
This book has been prepared by the Directorate of School
Education on behalf of the Government of Tamilnadu
This book has been printed on 70 G.S.M. PaperFOREWORD
A computer allows users to store and process information
quickly and automatically. A computer is a programmable machine. It
allows the user to store all sorts of information and then -%$process*". that
information, or data, or carry out actions with the information, such as
calculating numbers or organizing words.
These features of computer make it a valuable tool in the hands
of users. Computers make life easy. Users can focus their attention on
solving more complex problems leaving out the routine activities that
can be computerized. The creative abilities of the users can thus be
used more effectively. The users have to utilize this powerful tool for the
benefit of individuals, organizations, nations and the world.
Computers cannot do things on their own. The users must
understand the ways in which problems can be solved with computers.
This volume contains the basic concepts required for you to become a
user of the computer. This volume
1
2.
3.
4.
Introduces the key components of a computer system
(hardware, software, data)
Familiarizes students with how computers work through an
introduction to number systems
Presents the basic concepts of various logic gates that make a
computer
Gives a broad view of how technology is improving communications
through the use of electronic mail and the Internet.
No previous computer related experience is required to
understand the concepts contained in this volume.
The field of computers is fast changing. It is the understanding
of the basic concepts that will help the users in adjusting to the rapid
changes. Without the conceptual basis, the user will find it very difficult
to take advantage of the advances in the field of computer science.Knowing the basic concepts will help the users quickly
understand new developments on their own. Hence, the students must
focus on understanding the contents of this volume.
The authors, reviewers and editors of this volume have taken
great care in ensuring the accuracy of the contents. The presentation
is lucid with many illustrations.
I wish the budding computer scientists a fruitful experience with
the powerful tool called computer for the rest of their careers.
(E BALAGURUSAMY)
Vice Chancellor, Anna University, Chennai
Chairman Syllabus CommitteeCONTENTS
Chapter 1
1.1
1.2
1.3
1.4
Chapter 2
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
Chapter 3
3.1
3.2
3.3
3.4
3.5
INTRODUCTION TO COMPUTERS 1
History of Computers
Data, Information and Program
Hardware and Software
Types of Computers
Summary
Exercises 1
8
10
15
21
22
NUMBER SYSTEMS 25
Introduction
Bits and Bytes
Decimal Number System
Binary Number System
Hexadecimal Number System
Decimal to Binary Conversion
Conversion of fractional decimal to binary
Conversion of Decimal to Hexadecimal
Octal Representation
Representation of signed numbers
Binary Arithmetic
Boolean Algebra
Exercises 25
26
27
28
29
30
34
35
36
37
42
48
61
COMPUTER ORGANIZATION 64
Basic Components of a Digital Computer
Central Processing Unit
Arithmetic and Logic Unit $+# ALU
Memory Unit
Input and Output Devices
Summary
Exercises 64
68
72
74
78
96
98Chapter 4
4.1
4.2
4.3
4.4
4.5
4.6
Chapter 5
WORKING PRINCIPLE OF DIGITAL LOGIC 101
Logic Gates
Conversion of Boolean Function
Half Adder
Full Adder
The Flip-Flop
Electronic Workbench
Summary
Exercises 101
115
122
124
127
131
151
152
OPERATING SYSTEMS 155
5.1 Introduction
5.2 Major Features of the Operating System
5.3 Most Desirable Characters of the
Operating System
Summary
Exercises
Chapter 6
6.1
6.2
6.3
6.4
6.5
6.6
6.7
6.8
6.9
6.10
6.11
6.12
6.13
155
160
162
168
169
COMPUTER COMMUNICATIONS 171
Introduction
Network
Some Important Reasons for Networking
Applications of Network
Benefits of Network
Types of Network
Network Topology
Basics of Networking
Common Network Services
Co-Ordinating Data Communication
Forms of Data Transmission
Modem
Data Transfer Rate 171
171
171
172
172
173
174
176
177
179
180
181
1826.14
6.15
6.16
6.17
6.18
6.19
6.20
6.21
6.22
Transmission Mode
Internet
Communication Protocol
Who Governs the Internet ?
Future of Internet
Uses of Internet
Getting Connected to Internet
Popular Uses of the Web
Intranet and Extranet
Exercises
182
183
184
184
185
185
187
190
191
191CHAPTER 1
INTRODUCTION TO COMPUTERS
1.1
History of Computers
1.1.1 Introduction
A computer is a tool and partner in every sphere of human
life and activity. Computers are bringing many changes in industry,
government, education, medicine, scientific research, law, social
service and even arts like music, movies and paintings. The areas
of application of computers are confined only by the limitation on
creativity and imagination.
What is a computer? A child might define a computer to be
an instrument capable of producing a combined effect of radio, movie
and television. This definition is close but still does not visualize the
power and capabilities of a computer.
Fig. 1.1 Computer
A computer is an electronic machine, capable of performing
basic operations like addition, subtraction, multiplication, division,
etc. The computer is also capable of storing information, which can
1be used later. It can process millions of instructions in a few seconds
and at the same time with high accuracy. Hence a computer can be
defined as an automatic electronic machine for performing
calculations or controlling operations that are expressible in numerical
or logical terms. Computers are very accurate and save time by
performing the assigned task very fast. They don't get bored.
Humans have always needed to perform arithmetic like
counting and adding. During the pre-historic period, they counted
either on their fingers or by scratching marks on the bones and then
with the help of stone, pebble and beads. The early civilization had
witnessed men develop number systems to keep track of the
astronomical cycles, businesses, etc. The word ./)computing-'" means
+#"an act of calculating./*. After the invention of the manual calculating
tools, the concept of using "#%electronic gadgets%/* for computations were
introduced which gave birth to the computers. The evolution of
computers has passed through a number of stages before reaching
the present state of development. During the early development
period, certain machines had been developed and a brief note of
them is given below.
1.1.2 Early History
2500 BC *!, The Abacus
Fig. 1.2 Abacus
2Abacus is the first known calculating machine used for counting.
It is made of beads strung on cords and is used for simple arithmetic
calculations. The cords correspond to positions of decimal digits. The
beads represent digits. Numbers are represented by beads close to
the crossbar. Abacus was mainly used for addition and subtraction and
later for division and multiplication.
1614 AD +%! Napier's Bones
Fig. 1.3 Napier's Bones
The Napier's Bones was invented by John Napier, a Scottish
mathematician as an aid to multiplication. A set of bones consisted
of nine rods, one for each digit 1 through 9 and a constant rod for the
digit ''*0,*,. A rod is similar to one column of a multiplication table.
1633 AD &/+ The Slide Rule
Fig. 1.4 The Slide Rule
3The Slide Rule was invented by William Oughtred. It is based
on the principle that actual distance from the starting point of the rule is
directly proportional to the logarithm of the numbers printed on the rule.
The slide rule is embodied by the two sets of scales that are joined
together, with a marginal space between them. The suitable alliance of
two scales enabled the slide rule to perform multiplication and division
by a method of addition and subtraction.
1642 AD .$) The Rotating Wheel Calculator
Fig. 1.5 The Rotating Wheel Calculator
The Rotating Wheel Calculator was developed by a French
philosopher, Blaise Pascal, using simple components such as gears
and levers. This is a predecessor to today's electronic calculator. He
was inspired by the computation work of his father's job and devised
the model. He was only 19 years old, when he devised this model.
1822 AD /.# The Difference Engine
Fig. 1.6 The Difference Engine
4The Difference Engine was built by Charles Babbage, British
mathematician and engineer which mechanically calculated
mathematical tables. Babbage is called the father of today's computer.
1890 AD - Hollerith Tabulating Machine
Fig. 1.7 Hollerith Tabulating Machine
A tabulating machine using punched cards was designed by
Herman Hollerith and was called as the Hollerith Tabulating Machine.
This electronic machine is able to read the information on the punched
cards and process it electronically.
1.1.3 Generation of Computers
The evolution of electronic computers over a period of time can
be traced effectively by dividing this period into various generations.
Each generation is characterized by a major technological development
that fundamentally changed the way computers operated. These helped
to develop smaller, cheaper, powerful, efficient and reliable devices.
Now you could read about each generation and the developments that
led to the current devices that we use today.
5First Generation - 1940-1956: Vacuum Tubes
The first generation of computers used vacuum tubes for
circuitry and magnetic drums for memory. They were large in size,
occupied a lot of space and produced enormous heat.
They were very expensive to operate and consumed large
amount of electricity. Sometimes the heat generated caused the
computer to malfunction. First generation computers operated only
on machine language. Input was based on punched cards and paper
tape, and output was displayed on printouts. First generation
computers could solve only one problem at a time.
Fig. 1.8 Vacuum Tube
The Universal Automatic Computer (UNIVAC) and the
Electronic Numerical Integrator And Calculator (ENIAC) are classic
examples of first-generation computing devices.
Second Generation - 1956-1963: Transistors
The second generation of computers witnessed the vacuum
tubes being replaced by transistors. The transistor was far superior
to the vacuum tube, allowing computers to become smaller, faster,
cheaper, energy-efficient and more reliable than their first-generation
counter parts. The transistors also generated considerable heat that
6sometimes caused the computer to malfunction. But it was a vast
improvement over the vacuum tube. Second-generation computers
used punched cards for input and printouts for output.
Fig. 1.9 Transistor
Second-generation computers moved from the use of machine
language to assembly languages, which allowed programmers to
specify instructions in words. High-level programming languages were
also being developed at this time, such as early versions of COBOL
and FORTRAN. The computers stored their instructions in their
memory, which moved from a magnetic drum to magnetic core
technology.
Third Generation - 1964-1971 : Integrated Circuits
The development of the integrated circuit left its mark in the
third generation of computers. Transistors were made smaller in size
and placed on silicon chips, which dramatically increased the speed
and efficiency of computers.
Fig. 1.10 Integrated Circuit
7In this generation, keyboards and monitors were used instead
of punched cards and printouts. The computers were interfaced with
an operating system which allowed to solve many problems at a time.
Fourth Generation - 1971-Present : Microprocessors
The microprocessor brought forth the fourth generation of
computers, as thousands of integrated circuits were built onto a single
silicon chip.
Fig. 1.11 Microprocessor
As these small computers became more powerful, they could
be linked together to form networks, which eventually led to the
development of the Internet.
Fifth Generation - Present and Beyond: Artificial Intelligence
Fifth generation computing devices, based on artificial
intelligence, are still in their developmental stage. Fifth generation
computers will come close to bridging the gap between computing
and thinking.
1.2
Data, Information and Program
Computer is a tool for solving problems. Computers accept
instructions and data, perform arithmetic and logical operations and
8produce information. Hence the instructions and data fed into the
computer are converted into information through processing.
Data
Processing
Information
Fig. 1.12 Data, Processing and Information
Basically data is a collection of facts from which information
may be derived. Data is defined as an un-processed collection of
raw facts in a manner suitable for communication, interpretation or
processing.
Hence data are
Q
Q
Q
Q
Stored facts
Inactive
Technology based
Gathered from various sources.
On the other hand information is a collection of facts from which
conclusions may be drawn. Data that has been interpreted, translated,
or transformed to reveal the underlying meaning. This information can
be represented in textual, numerical, graphic, cartographic, narrative,
or audiovisual forms.
Hence information is
Q
Q
Q
Q
Processed facts
Active
Business based
Transformed from data.
Algorithm is defined as a step-by-step procedure or formula
for solving a problem i.e. a set of instructions or procedures for solving
a problem. It is also defined as a mathematical procedure that can
9usually be explicitly encoded in a set of computer language instructions
that manipulate data.
A computer program (or set of programs) is designed to
systematically solve a problem. For example, a problem to calculate
the length of a straight line joining any two given points.
The programmer must decide the program requirements,
develop logic and write instructions for the computer in a programming
language that the computer can translate into machine language
and execute. Hence, problem solving is an act of defining a problem,
understanding the problem and arriving at workable solutions.
In other words, problem solving is the process of confronting
a novel situation, formulating connection between the given facts,
identifying the goal of the problem and exploring possible methods
for reaching the goal. It requires the programmer to co-ordinate
previous experience and intuition in order to solve the problem.
1.3
Hardware and Software
1.3.1 Introduction
A computer system has two major components, hardware
and software. In practice, the term hardware refers to all the physical
items associated with a computer system. Software is a set of
instructions, which enables the hardware to perform a specific task.
1.3.2 Computer Hardware
A computer is a machine that can be programmed to accept
data (input), and process it into useful information (output). It also
stores data for later reuse (storage). The processing is performed
by the hardware. The computer hardware responsible for computing
are mainly classified as follows:
10Main
Memory
Input Devices
Secondary
Storage
CPU
Output
Devices
Fig. 1.13 Computer Hardware
3!,#4 Input devices allows the user to enter the program and data
and send it to the processing unit. The common input devices
are keyboard, mouse and scanners.
3+.,4 The Processor, more formally known as the central processing
unit (CPU), has the electronic circuitry that manipulates input
data into the information as required. The central processing
unit actually executes computer instructions.
3'*#4 Memory from which the CPU fetches the instructions and data
is called main memory. It is also called as primary memory and
is volatile in nature.
3(%*4 Output devices show the processed data $'& information ,-, the
result of processing. The devices are normally a monitor and
printers.
3-!-4 Storage usually means secondary storage, which stores data
and programs. Here the data and programs are permanently
stored for future use.
The hardware devices attached to the computer are called
peripheral equipment. Peripheral equipment includes all input,
output and secondary storage devices.
111.3.3 Computer Software
Software refers to a program that makes the computer to do
something meaningful. It is the planned, step-by-step instructions
required to turn data into information. Software can be classified
into two categories: System Software and Application Software.
Computer Software
System Software
Application Software
Fig. 1.14 Software Categories
System software consists of general programs written for a
computer. These programs provide the environment to run the
application programs. System software comprises programs, which
interact with the hardware at a very basic level. They are the basic
necessity of a computer system for its proper functioning. System
software serves as the interface between hardware and the user.
The operating system, compilers and utility programs are examples
of system software.
Application Software
System Software
Hardware
Fig. 1.15 System Software
12The most important type of system software is the operating
system. An operating system is an integrated set of specialized
programs that is used to manage the overall operations of a computer.
It acts like an interface between the user, computer hardware and
software. Every computer must have an operating system to run
other programs. DOS (Disk Operating System), Unix, Linux and
Windows are some of the common operating systems.
The compiler software translates the source program (user
written program) into an object program (binary form). Specific
compilers are available for computer programming languages like
FORTRAN, COBOL, C, C++ etc. The utility programs support the
computer for specific tasks like file copying, sorting, linking a object
program, etc.
Source Program
Compiler
Object Program
Fig. 1.16 Compiler
An Application Software consists of programs designed to
solve a user problem. It is used to accomplish specific tasks rather
than just managing a computer system. Application software are
inturn, controlled by system software which manages hardware
devices.
Some typical examples are : railway reservation system, game
programs, word processing software, weather forecasting programs.
Among the application software some are packaged for specific tasks.
The commonly used Application Software packages are word
processor, spread sheet, database management system and
graphics.
13One of the most commonly used software package is word
processing software. Anyone who has used a computer as a word
processor knows that it is far more than a fancy typewriter. The great
advantage of word processing over a typewriter is that you can make
changes without retyping the entire document. The entire writing
process is transformed by this modern word processing software.
This software lets you create, edit, format, store and print text and
graphics. Some of the commonly used word processors are Microsoft
Word, WordStar, WordPerfect, etc.
Spreadsheet software packages allow the user to manipulate
numbers. Repetitive numeric calculations, use of related formulae
and creation of graphics and charts are some of the basic tools.
This capability lets business people try different combinations of
numbers and obtain the results quickly. Lotus1-2-3, Excel, etc. are
some of the famous spreadsheet applications.
A database management system is a collection of programs
that enable to store, modify and extract information from a database.
A database organizes the information internally. Computerized banking
system, Automated Teller Machine, Airlines and Railway reservation
system etc., are some of the database applications.
Type of Software
Functions
Word Processors All personal computers are
loaded with word processing
software which has the same
function as a typewriter for
writing letters, preparing
reports and printing.
Spreadsheet
A table containing text and
figures, which is used to
Calvulations and draw charts
Database
Used for storing, retrieval and
Management
Manipulation of Information
System
14
Examples
Microsoft Word
Word Perfect,
Word Star.
Microsoft Excel,
Lotus 1-2-3.
Microsoft Access,
Oracle.1.4
Types of Computers
1.4.1 Introduction
Classification of the electronic computers may be based on
either their principles of operation or their configuration. By
configuration, we mean the size, speed of doing computation and
storage capacity of a computer.
1.4.2 Classification based on Principles of Operation
Based on the principles of operation, computers are classified
into three types, analog computers, digital computers and hybrid
computers.
Computers
Analog
Digital
Hybrid
Fig. 1.17 Classification of Computers
Analog Computers
Analog Computer is a computing device that works on
continuous range of values. The analog computers give approximate
results since they deal with quantities that vary continuously. It
generally deals with physical variables such as voltage, pressure,
temperature, speed, etc.
Digital Computers
On the other hand a digital computer operates on digital data
such as numbers. It uses binary number system in which there are
only two digits 0 and 1. Each one is called a bit. The digital computer
15is designed using digital circuits in which there are two levels for an
input or output signal. These two levels are known as logic 0 and
logic 1. Digital Computers can give the results with more accuracy
and at a faster rate.
Since many complex problems in engineering and technology
are solved by the application of numerical methods, the electronic
digital computer is very well suited for solving such problems. Hence
digital computers have an increasing use in the field of design,
research and data processing.
Digital computers are made for both general purpose and
special purpose. Special purpose computer is one that is built for a
specific application. General purpose computers are used for any
type of applications. It can store different programs and do the jobs
as per the instructions specified on those programs. Most of the
computers that we see fall in this category.
Hybrid Computers
A hybrid computing system is a combination of desirable
features of analog and digital computers. It is mostly used for
automatic operations of complicated physical processes and
machines. Now-a-days analog-to-digital and digital-to-analog
converters are used for transforming the data into suitable form for
either type of computation.
For example, in hospital's automated intensive care unit,
analog devices might measure the patients temperature, blood
pressure and other vital signs. These measurements which are in
analog might then be converted into numbers and supplied to digital
components in the system. These components are used to monitor
the patient's vital sign and send signals if any abnormal readings
are detected. Hybrid computers are mainly used for specialized tasks.
161.4.3 Classification of Computers based on Configuration
Based on performance, size, cost and capacity, the digital
computers are classified into four different types : Super computers,
Mainframe computers, Mini computers and Micro computers.
Digital Computers
Super
Computers
Mini
Computers
Mainframe
Computers
Micro
Computers
Fig. 1.18 Classification of Digital Computers
Super Computers
The mightiest computers but at the same time, the most
expensive ones are known as super computers. Super computers
process billions of instructions per second. In other words, super
computers are the computers normally used to solve intensive
numerical computations. Examples of such applications are stock
analysis, special effects for movies, weather forecasting and even
sophisticated artworks.
Mainframe Computers
Mainframe computers are capable of processing data at very
high speeds )'$ hundreds of million instructions per second. They are
large in size. These systems are also expensive. They are used to
process large amount of data quickly. Some of the obvious customers
are banks, airlines and railway reservation systems, aerospace
companies doing complex aircraft design, etc.
17Mini Computers
The mini computers were developed with the objective of bringing
out low cost computers. They are lower to mainframe computers, in
terms of speed and storage capacity. Some of the hardware features
available in mainframes were not included in the mini computer
hardware in order to reduce the cost. Some features which were
handled by hardware in mainframe computers were done by software
in mini computers. Hence the performance of mini computer is less
than that of the mainframe. However, the mini computer market has
diminished somewhat as buyers have moved towards less expensive
but increasingly powerful personal computers.
Micro Computers
The invention of microprocessor (single chip CPU) gave birth
to the micro computers. They are several times cheaper than mini
computers.
Micro Computers
Workstations
Laptop
Computers
Personal
Computers
Palm PCs
Fig. 1.19 Classification of Micro Computers
The micro computers are further classified into workstation,
personal computers, laptop computers and still smaller computers.
18Although the equipment may vary from the simplest computer
to the most powerful, the major functional units of the computer
system remain the same : input, processing, storage and output.
Workstations
Workstations are also desktop machines mainly used for
intensive graphical applications. They have more processor speed
than that of personal computers.
Fig. 1.20 Workstation
Workstations use sophisticated display screens featuring high-
resolution colour graphics. Workstations are used for executing
numeric and graphic intensive applications such as Computer Aided
Design (CAD), simulation of complex systems and visualizing the
results of simulation.
Personal Computers
Fig. 1.21 Personal Computer
19Today the personal computers are the most popular computer
systems simply called PCs. These desktop computers are also known
as home computers. They are usually easier to use and more affordable
than workstations. They are self-contained desktop computers intended
for an individual user. Most often used for word processing and small
database applications.
Laptop Computers
Fig. 1.22 Laptop Computer
Laptop computers are portable computers that fit in a briefcase.
Laptop computers, also called notebook computers, are
wonderfully portable and functional, and popular with travelers who
need a computer that can go with them.
Getting Smaller Still
Fig. 1.23 Personal Digital Assistants
Pen-based computers use a pen like stylus and accept
handwritten input directly on a screen. Pen-based computers are
also called Personal Digital Assistants (PDA). Special engineering
and hardware design techniques are adopted to make the portable,
smaller and light weight computers.
20Summary
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
Q
A computer is an electronic machine, capable of performing basic
operations like addition, subtraction, multiplication, division, etc.
Abacus is the first known calculating machine used for counting.
The Rotating Wheel Calculator was developed by Blaise Pascal,
which is a predecessor to today's electronic calculator.
Charles Babbage is called as the father of today's computer.
The first generation of computers used vacuum tubes for circuitry
and magnetic drums for memory.
The second generation of computers witnessed the vacuum
tubes being replaced by transistors.
The third generation computer used the integrated circuits.
The microprocessor brought forth the fourth generation of
computers, as thousands of integrated circuits were built onto
a single silicon chip.
Data is a collection of facts from which information may be
derived.
Information is a collection of facts from which conclusions may
be drawn.
Algorithm is defined as a step-by-step procedure or formula for
solving a problem
A computer program (or set of programs) is designed to
systematically solve a problem.
A computer system has two major components, hardware and
software.
The processing is performed by the hardware.
Software refers to a program that makes the computer to do
something meaningful and classified as System Software and
Application Software
System software consists of general programs written for a
computer.
An Application Software consists of programs designed to solve
a user problem.
21Q
Q
Q
Q
Q
Q
Q
Q
Analog Computer is a computing device that works on continuous
range of values.
A digital computer operates on digital data such as numbers.
A hybrid computing system is a combination of desirable
features of analog and digital computers.
Super computers process billions of instructions per second.
Mainframes are capable of processing data at very high speeds
+%' hundreds of million instructions per second.
The mini computers were developed with the objective of
bringing out low cost computers.
The invention of microprocessor (single chip CPU) gave birth
to the micro computers.
The micro computers are further classified into workstation,
personal computers, laptop computers and still smaller
computers.
Exercises
I. Fill in the blanks
1)
2)
3)
4)
5)
6)
7)
8)
9)
_________ is considered to be the father of today's computer.
__________ invented the Slide Rule.
The first generation of computers used _____________for
circuitry and ________ for memory.
Integrated circuits were used in ____________ generation of
computers.
___________ refers to the physical items associated with a
computer system.
The hardware devices attached to the computer are called
__________.
__________ refers to programs that make the computer to do
some thing.
Software can be classified into ___________ and __________
software.
An ____________is an integrated set of specialized programs
that is used to manage the overall operations of a computer.
2210) The ________ translates the whole source program into an object
program.
11) A ________ allows users to quickly and efficiently store, organize,
retrieve, communicate and manage large amounts of information.
12) ________ computers are useful in solving differential equation
and integration.
13) The digital computers are classified into __________,
________, __________ and __________.
14) ________ is the planned step-by-step instruction required to
turn data into information.
15) _______ is the raw material that is given to a computer for
processing.
16) A ________ computer accepts handwritten input on a screen.
17) Raw data is processed by the computer into _________.
18) PC refers to ___________.
19) _________ software allows to create, edit, format, store and
print text and graphics.
20) The word computing means ___________.
II. State whether the following are true or false
1)
2)
The concept of using ,%%electronic brains&,) gave birth to computers.
The most powerful personal computers are known as super
computers.
3) Blaise Pascal developed the tabulating machine using punched
cards.
4) Herman Hollerith designed the difference engine.
5) Compilers translate higher level language into machine
language.
6) Word processing is a type of task-oriented software.
7) Fifth generation computing devices is based on artificial
intelligence.
8) The input devices accept data and send them to the processor.
9) A hybrid computing system is a combination of desirable
features of analog and digital computers.
10) The personal computers are sometime called the home
computers.
23III.
Answer the following.
1)
2)
What is a computer?
What is the name of the machine developed by Charles
Babbage?
3) What are peripheral devices?
4) Define (.'Data+&!.
5) Define %%,Information.)$.
6) What do you mean by an algorithm?
7) What is a word processor software?
8) What is an operating System?
9) What is an analog computing system?
10) What is a lap-top computer?
IV. Answer the following in detail.
1)
2)
3)
4)
Discuss the various computer generations along with the key
characteristics of the computer of each generation.
What is the relationship between software and hardware?
Write in detail about computer software and their categories.
Discuss the important features and uses of micro, mini,
mainframe and super computers.
24CHAPTER 2
NUMBER SYSTEMS
2.1 Introduction
There are several kinds of data such as, numeric, text, date,
graphics, image, audio and video that need to be processed by a
computer. The text data usually consist of standard alphabetic,
numeric, and special characters. The graphics data consist of still
pictures such as drawings and photographs. Any type of sound,
including music and voice, is considered as audio data. Video data
consist of motion pictures. The data has to be converted into a
format that the computer understands. Data can be classified into
two forms, analog data and digital data. Analog data can have any
value within a defined range and it is continuous. Sound waves,
telephone signals, temperatures and all other signals that are not
broken into bits are examples of analog data. Digital data can be
represented by a series of binary numbers and it is discrete.
The Arithmetic and Logic Unit (ALU) of the computer performs
arithmetic and logical operations on data. Computer arithmetic is
commonly performed on two different types of numbers, integer and
floating point. As the hardware required for arithmetic is much simpler
for integers than floating point numbers, these two types have entirely
different representations. An integer is a whole number and the
floating-point number has a fractional part. To understand about
how computers store data in the memory and how they handle them,
one must know about bits and bytes and the number systems.
Bits and bytes are common computer jargons. Both the main
memory (Random Access Memory or RAM) and the hard disk
capacities are measured in terms of bytes. The hard disk and
memory capacity of a computer and other specifications are
described in terms of bits and bytes. For instance, a computer may
be described as having a 32-bit Pentium processor with 128
Megabytes of RAM and hard disk capacity of 40 Gigabytes.
252.2 Bits and Bytes
A numbering system is a way of representing numbers. The
most commonly used numbering system is the decimal system.
Computer systems can perform computations and transmit data
thousands of times faster in binary form than they can use decimal
representations. It is important for every one studying computers to
know how the binary system and hexadecimal system work.
A bit is small piece of data that is derived from the words
%,(binary digit(!). Bits have only two possible values, 0 and 1. A binary
number contains a sequence of 0s and 1s like 10111. A collection of
8 bits is called as a byte. With 8 bits in a byte, we can represent 256
values ranging from 0 to 255 as shown below:
0
1
2
3
= 0000 0000
= 0000 0001
= 0000 0010
= 0000 0011
.............
.............
.............
254 = 1111 1110
255 = 1111 1111
Bytes are used to represent characters in a text. Different
types of coding schemes are used to represent the character set
and numbers. The most commonly used coding scheme is the
American Standard Code for Information Interchange (ASCII). Each
binary value between 0 and 127 is used to represent a specific
character. The ASCII value for a blank character (blank space) is 32
and the ASCII value of numeric 0 is 48. The range of ASCII values
for lower case alphabets is from 97 to 122 and the range of ASCII
values for the upper case alphabets is 65 to 90.
26Computer memory is normally represented in terms of Kilobytes
or Megabytes. In metric system, one Kilo represents 1000, that is,
10 3 . In binary system, one Kilobyte represents 1024 bytes, that is,
2 10 . The following table shows the representation of various memory
sizes.
Name Abbreviation Size (Bytes)
Kilo
Mega
Giga
Tera
Peta
Exa
Zetta
Yotta K
M
G
T
P
E
Z
Y 2^10 *
2^20
2^30
2^40
2^50
2^60
2^70
2^80
*
Read as 2 power10.
In a 2GB (Gigabytes) storage device (hard disk), totally
21,47,483,648 bytes can be stored. Nowadays, databases having
size in Terabytes are reported; Zetta and Yotta size databases are
yet to come.
2.3 Decimal Number System
In our daily life, we use a system based on digits to represent
numbers. The system that uses the decimal numbers or digit symbols
0 to 9 is called as the decimal number system. This system is said
to have a base, or radix, of ten. Sequence of digit symbols are used
to represent numbers greater than 9. When a number is written as
a sequence of decimal digits, its value can be interpreted using the
positional value of each digit in the number. The positional number
system is a system of writing numbers where the value of a digit
depends not only on the digit, but also on its placement within a
number. In the positional number system, each decimal digit is
weighted relative to its position in the number. This means that
each digit in the number is multiplied by ten raised to a power
27corresponding to that digit's position. Thus the value of the decimal
sequence 948 is:
948 10 = 9 X 10 2 + 4 X 10 1 + 8 X 10 0
Fractional values are represented in the same manner, but
the exponents are negative for digits on the right side of the decimal
point. Thus the value of the fractional decimal sequence 948.23 is:
948.23 10 = 9 X 10 2 + 4 X 10 1 + 8 X 10 0 + 2 X 10 -1 + 3 X 10 -2
In general, for the decimal representation of
X = { ....x 2 x 1 x 0 . x -1 x -2 x -3 .... },
the value of X is
X = S i x i 10 i
2.4
where i = ....2, 1, 0, -1, -2, ....
Binary Number System
Ten different digits 0 -!/ 9 are used to represent numbers in the
decimal system. There are only two digits in the binary system,
namely, 0 and 1. The numbers in the binary system are represented
to the base two and the positional multipliers are the powers of two.
The leftmost bit in the binary number is called as the most significant
bit (MSB) and it has the largest positional weight. The rightmost bit
is the least significant bit (LSB) and has the smallest positional weight.
The binary sequence 10111 2 has the decimal equivalent:
10111 2 = 1 X 2 4 + 0 X 2 3 + 1 X 2 2 + 1 X 2 1 + 1 X 2 0
= 16 + 0 + 4 + 2 + 1
= 23 10
28The decimal equivalent of the fractional binary sequence can be
estimated in the same manner. The exponents are negative powers of
two for digits on the right side of the binary point. The binary equivalent
of the decimal point is the binary point. Thus the decimal value of the
fractional binary sequence 0.1011 2 is:
0.1011 2 = 1 X 2 -1 + 0 X 2 -2 + 1 X 2 -3 + 1 X 2 -4
= 0.5 + 0 + 0.125 + 0.0625
= 0.6875 10
2.5 Hexadecimal Number System
Hexadecimal representation of numbers is more efficient in
digital applications because it occupies less memory space for storing
large numbers. A hexadecimal number is represented using base
16. Hexadecimal or Hex numbers are used as a shorthand form of
binary sequence. This system is used to represent data in a more
compact manner. In the hexadecimal number system, the binary
digits are grouped into sets of 4 and each possible combination of 4
binary digits is given a symbol as follows:
0000 = 0
0001 = 1
0010 = 2
0011 = 3
0100 = 4
0101 = 5
0110 = 6
0111 = 7
1000 = 8
1001 = 9
1010 = A
1011 = B
1100 = C
1101 = D
1110 = E
1111 = F
Since 16 symbols are used, 0 to F, the notation is called
hexadecimal. The first ten symbols are the same as in the decimal
system, 0 to 9 and the remaining six symbols are taken from the
first six letters of the alphabet sequence, A to F. The hexadecimal
sequence 2C 16 has the decimal equivalent:
2C 16 = 2 X 16 1 + C X 16 0
= 32 + 12
= 44 10
29The hexadecimal representation is more compact than binary
representation. It is very easy to convert between binary and
hexadecimal systems. Each hexadecimal digit will correspond to
four binary digits because 2 4 = 16. The hexadecimal equivalent of
the binary sequence 110010011101 2 is:
1100 1001 1101 = C9D 16
C
9
D
2.6
Decimal to Binary Conversion
To convert a binary number to a decimal number, it is required
to multiply each binary digit by the appropriate power of 2 and add
the results. There are two approaches for converting a decimal
number into binary format.
2.6.1 Repeated Division by 2
Any decimal number divided by 2 will leave a remainder of 0
or 1. Repeated division by 2 will leave a string of 0s and 1s that
become the binary equivalent of the decimal number. Suppose it is
required to convert the decimal number M into binary form, dividing
M by 2 in the decimal system, we will obtain a quotient M 1 and a
remainder r 1, where r 1 can have a value of either 0 or 1.
ie.,
M = 2 * M 1 + r 1
r 1 = 0 or 1
Next divide the quotient M 1 by 2. The new quotient will be M 2 and
the new remainder r 2 .
ie.,
so that
M 1 = 2 * M 2 + r 2
r 2 = 0 or 1
M = 2 (2 * M 2 + r 2 ) + r 1
= 2 2 M 2 + r 2 * 2 1 + r 1 * 2 0
Next divide the quotient M 2 by 2. The new quotient will be M 3 and
the new remainder r 3 .
30i.e., M 2 = 2 * M 3 + r 3
so that
M = 2 (2 * (2 * M 3 + r 3 ) + r 2 ) + r 1
= 2 2 (2 * M 3 + r 3 ) + r 2 * 2 1 + r 1 * 2 0
= 2 3 M 3 + r 3 * 2 2 + r 2 * 2 1 + r 1 * 2 0
The above process is repeated until the quotient becomes 0,
then
M = 1 * 2 k + r k * 2 k-1 + .... + r 3 * 2 2 + r 2 * 2 1 + r 1 * 2 0
Example:
Convert 23 10 into its equivalent binary number.
23/2
11/2
5/2
2/2
1/2
Quotient
11
5
2
1
0
Remainder
1 (LSB)
1
1
0
1 (MSB)
To write the binary equivalent of the decimal number, read the
remainders from the bottom upward as:
23 10 = 10111 2
The number of bits in the binary number is the exponent of the
smallest power of 2 that is larger than the decimal number. Consider
a decimal number 23. Find the exponent of the smallest power of 2
that is larger than 23.
16 < 23 < 32
2 4 < 23 < 2 5
Hence, the number 23 has 5 bits as 10111. Consider another
example.
31Find the number of bits in the binary representation of the decimal
number 36 without actually converting into its binary equivalent.
The next immediate large number than 36 that can be
represented in powers of 2 is 64.
32 < 36 < 64
2 5 < 36 < 2 6
Hence, the number 36 should have 6 bits in its binary
representation.
2.6.2 Sum of Powers of 2
A decimal number can be converted into a binary number by
adding up the powers of 2 and then adding bits as needed to obtain
the total value of the number. For example, to convert 36 10 to binary:
a. Find the largest power of 2 that is smaller than or equal to 36
36 10 > 32 10
b. Set the 32's bit to 1 and subtract 32 from the original number.
36 !#$ 32 = 4
c. 16 is greater than the remaining total. Therefore, set the 16's bit
to 0
d. 8 is greater than the remaining total. Hence, set the 8's bit to 0
e. As the remaining value is itself in powers of 2, set 4's bit to 1
and subtract 4
4 (&/ 4 = 0
Conversion is complete when there is nothing left to subtract.
Any remaining bits should be set to 0. Hence
36 = 100100 2
32The conversion steps can be given as follows:
32 16
1
32 16
1 0
32 16
1 0
8 4 2 1
36 $,, 32 = 4
8
0
8
0
4 2 1
1
4 2 1
1 0 0
4 ,+* 4 = 0
36 10 = 100100 2
Example:
Convert 91 10 to binary using the sum of powers of 2 method.
The largest power of 2 that is smaller than or equal to 91 is 64.
64 32 16 8 4 2 1
1
91-64 = 27
64 32 16 8 4 2 1
1 0 1
91-(64+16) = 11
(Since 32 > 27, set the 32's bit 0 and 16 < 27. set the 16's bit 1)
64 32 16 8 4 2 1
1
0
1 1
91-(64+16+8) = 3
64 32 16 8 4 2 1
1
0
1 1 0 1
91-(64+16+8+2) = 1
64 32 16 8 4 2 1
1
Hence
0
1 1 0 1 1
91-(64+16+8+2+1) = 0
91 10 = 1011011 2
332.7
Conversion of fractional decimal to binary
The decimal fractions like 1/2, 1/4, 1/8 etc., can be converted into
exact binary fractions. Sum of powers method can be applied to these
fractions.
0.5 10 = 1 * 2 -1 = 0.1 2
0.25 10 = 0 * 2 -1 + 1 * 2 -2 = 0.01 2
0.125 10 = 0 * 2 -1 + 0 * 2 -2 + 1 * 2 -3 = 0.001 2
The fraction 5/8 = 4/8 + 1/8 = 1/2 + 1/8 has the binary equivalent:
5/8 = 1 * 2 -1 + 0 * 2 -2 + 1 * 2 -3
= 0.101 2
Exact conversion is not possible for the decimal fractions that
cannot be represented in powers of 2. For example, 0.2 10 cannot be
exactly represented by a sum of negative powers of 2. A method of
repeated multiplication by 2 has to be used to convert such kind of
decimal fractions.
The steps involved in the method of repeated multiplication by 2:
#.
Multiply the decimal fraction by 2 and note the integer part.
The integer part is either 0 or 1.
'+
Discard the integer part of the previous product. Multiply the
fractional part of the previous product by 2. Repeat the first step
until the fraction repeats or terminates.
The resulting integer part forms a string of 0s and 1s that
become the binary equivalent of the decimal fraction.
34Example:
0.2 * 2 = 0.4
0.4 * 2 = 0.8
0.8 * 2 = 1.6
0.6 * 2 = 1.2
Integer part
0
0
1
1
0.2 * 2 = 0.4
0
(Fraction repeats, the product is the same as in the first step)
Read the integer parts from top to bottom to obtain the equivalent
fractional binary number. Hence 0.2 10 = 0.00110011... 2
2.8
Conversion of Decimal to Hexadecimal
Decimal numbers#,' conversion to hexadecimal is similar to binary
conversion. Decimal numbers can be converted into hexadecimal
format by the sum of weighted hex digits method and by repeated
division by 16. The sum of weighted hex digits method is suitable
for small decimal numbers of maximum 3 digits. The method of
repeated division by 16 is preferable for the conversion of larger
numbers.
The exponent of the smallest power of 16 that is greater than
the given decimal number will indicate the number of hexadecimal
digits that will be present in the converted hexadecimal number. For
example, the decimal number 948, when converted into hexadecimal
number has 3 hexadecimal digits.
(16 3 = 4096) > 948 > (16 2 = 256)
Hence, the hexadecimal representation of 948 has 3 hex digits.
The conversion process is as follows:
16 2
3
16 1 16 0
948 "," (3 * 256) = 180
35Hence,
16 2
3 16 1 16 0
B
948 -/* (3 * 256 + 11 * 16) = 4
16 2
3 16 1 16 0
B 4
948 ,'# (3 * 256 + 11 * 16 + 4) = 0
948 10 = 3B4 16
The steps involved in the repeated division by 16 to obtain the
hexadecimal equivalent are as follows:
)'
Divide the decimal number by 16 and note the remainder.
Express the remainder as a hex digit.
)*
Repeat the process until the quotient is zero
Example:
Process quotient
2.9
remainder
948 / 16 = 59 4 (LSB)
59 / 16 = 3
3 / 16 = 0
948 10 = 3B4 16 11 (B)
3 (MSB)
Octal Representation
An octal number is represented using base 8. Octal
representation is just a simple extension of binary and decimal
representations but using only the digits 0 to7. To convert an octal
number to a decimal number, it is required to multiply each octal
digit by the appropriate power of 8 and add the results.
36Example
What is the decimal value of the octal number 711 8 ?
7 * 8 2 + 1 * 8 1 + 1 * 8 0 = 457 10
The steps involved in the repeated division by 8 to obtain the
octal equivalent are as follows:
!$
Divide the decimal number by 8 and note the remainder.
Express the remainder as an octal digit.
)'
Repeat the process until the quotient is zero
What is the octal representation of the decimal number 64 10 ?
64/8
8/8
1/8
Quotient
8
1
0
Remainder
0 (LSB)
0
1 (MSB)
Hence 64 10 = 100 8
2.10 Representation of signed numbers
If computers represent non-negative integers (unsigned) only,
the binary representation is straightforward, as we had seen earlier.
Computers have also to handle negative integers (signed). The
normal convention that is followed to distinguish between a signed
and unsigned number is to treat the most significant (leftmost) bit in
the binary sequence as a sign bit. If the leftmost bit is 0, the number
is positive, and if the leftmost bit is 1, the number is negative.
372.10.1 Sign+magnitude representation
The simplest form of representing a negative integer is the
sign+magnitude representation. In a sequence of n bits, the leftmost
bit is used for sign and the remaining n-1 bits are used to hold the
magnitude of the integer. Thus in a sequence of 4 bits,
0100 = +4
1100 = -4
As there are several drawbacks in this representation, this
method has not been adopted to represent signed integers. There
are two representations for 0 in this approach.
0000 = +0 10
1000 = -0 10
Hence it is difficult to test for 0, which is an operation, performed
frequently in computers. Another drawback is that, the addition and
subtraction require a consideration of both the sign of the numbers
and their relative magnitude, in order to carry out the required
operation. This would actually complicate the hardware design of
the arithmetic unit of the computer. The most efficient way of
representing a signed integer is a 2's-complement representation.
In 2's complement method, there is only one representation of 0.
2.10.2. 2's-complement representation
This method does not change the sign of the number by simply
changing a single bit (MSB) in its representation. The 2's-complement
method used with -ve numbers only is as follows:
a.
b.
Invert all the bits in the binary sequence (ie., change every 0
to1 and every 1 to 0 ie.,1's complement)
Add 1 to the result
This method works well only when the number of bits used by the
system is known in the representation of the number. Care should be
38taken to pad (fill with zeros) the original value out to the full representation
width before applying this algorithm.
Example:
In a computer that uses 8-bit representation to store a number, the
wrong and right approaches to represent $,#23 are as follows:
Wrong approach:
The binary equivalent of 23 is 10111.
Invert all the bits => 01000
Add 1 to the result => 01001
Pad with zeros to make 8-bit pattern => 00001001 => +9
Right approach:
The binary equivalent of 23 is 10111
Pad with zeros to make 8-bit pattern => 00010111
Invert all the bits => 11101000
Add 1 to the result => 11101001 => -23
2.10.3 Manual method to represent signed integers in 2's
complement form
This is an easier approach to represent signed integers. This is for -ve
numbers only.
Step 1: Copy the bits from right to left, through and including the first 1.
Step 2: Copy the inverse of the remaining bits.
Example 1:
To represent '!-4 in a 4-bit representation:
The binary equivalent of the integer 4 is 0100
39As per step1, copy the bits from right to left, through and including the
first 1 => 100
As per step2, copy the inverse of the remaining bits => 1 100 => -4
Example 2:
To represent (*#23 in a 8-bit representation:
The binary equivalent of 23 is 00010111
As per step 1:
1
As per step 2: 11101001 => -23
2.10.4 Interpretation of unsigned and signed integers
Signed number versus unsigned number is a matter of
interpretation. A single binary sequence can represent two different
values. For example, consider a binary sequence 11100110 2 .
The decimal equivalent of the above sequence when
considered as an unsigned integer is:
11100110 2 = 230 10
The decimal equivalent of the sequence when considered as
a signed integer in 2's complement form is:
11100110 2 = -26 10 (after 2's complement and add negative sign).
40When comparing two binary numbers for finding which number
is greater, the comparison depends on whether the numbers are
considered as signed or unsigned numbers.
Example:
X = 1001
Y = 0011
Is ( X > Y) /* Is this true or false? */
It depends on whether X and Y are considered as signed or unsigned.
If X and Y are unsigned:
X is greater than Y
If X and Y are signed:
X is less than Y.
2.10.5 Range of unsigned and signed integers
In a 4-bit system, the range of unsigned integers is from 0 to
15, that is, 0000 to 1111 in binary form. Each bit can have one of two
values 0 or 1. Therefore, the total number of patterns of 4 bits will
be 2 X 2 X 2 X 2 = 16. In an n-bit system, the total number of
patterns will be 2 n. . Hence, if n bits are used to represent an unsigned
integer value, the range is from 0 to 2 n -1, that is, there are 2 n different
values.
In case of a signed integer, the most significant (left most) bit
is used to represent a sign. Hence, half of the 2 n patterns are used
for positive values and the other half for negative values. The range
of positive values is from 0 to 2 n-1 -1 and the range of negative values
is from '%&1 to #$'2 n-1 . In a 4-bit system, the range of signed integers is
from &,+8 to +7.
412.11 Binary Arithmetic
Digital arithmetic usually means binary arithmetic. Binary
arithmetic can be performed using both signed and unsigned binary
numbers.
2.11.1 Binary Addition %&' Unsigned numbers
When two digits are added, if the result is larger than what can be
contained in one digit, a carry digit is generated. For example, if we
add 5 and 9, the result will be 14. Since the result cannot fit into a
single digit, a carry is generated into a second digit place. When two
bits are added it will produce a sum bit and a carry bit. The carry bit
may be zero.
Example:
0 + 0 = 0 0
0 + 1 = 0 1
carry bit
sum bit
1 + 1 = 1 0
carry bit
sum bit
The sum bit is the least significant bit (LSB) of the sum of two
1-bit binary numbers and the carry bit holds the value of carry (0 or
1) resulting from the addition of two binary numbers.
42Example 1:
Calculate the sum of the numbers, 1100 and 1011:
carry bit
1 1 0 0
1 0 1 1
#/!)(")$"/'%)%%
1 0 1 1 1
.,/!#+&,.$"#&-(
sum bits
Example 2:
Calculate 10111 + 10110
Carry bits
1 1 1
1 0 1 1 1
1 0 1 1 0
-//%/.-!".'(#!$/&!.&*
1 0 1 1 0 1
)$'/./"%%!)+/-+."#'/)
In unsigned binary addition, the two operands are called
augend and addend. An augend is the number in an addition
operation to which another number is added. An addend is the
number in an addition operation that is added to another.
2.11.2 Binary addition /)! signed numbers
Signed addition is done in the same way as unsigned addition.
The only difference is that, both operands must have the same
number of magnitude bits and each must have a sign bit. As we
have already seen, in a signed number, the most significant bit (MSB)
is a sign bit while the rest of the bits are magnitude bits. When the
number is negative, the sign bit is 1 and when the number is positive,
the sign bit is 0.
43Example 1:
Add +2 10 and +5 10. Write the operands and the sum as 4-bit signed
binary
numbers.
+2 0 0 1 0
+5 0 1 0 1
*(&*-$ ,''*-,)&!%&)!--
+7
0 1 1 1
##.%)% -/..*-+++.'),!-
magnitude bits
sign bit
If the result of the operation is positive, we get a positive number in
ordinary binary notation.
Example 2: (Use of 2's complement in signed binary addition)
Add )"#7 10 + 5 10 using 4-bit system.
In 2'complement form, -7 is represented as follows:
In binary form, 7 is represented as: 0 1 1 1
Invert the bits (1 to 0 and 0 to 1) 1 0 0 0
Add 1
1
Hence, -7 in 2's complement form is
1 0 0 1 (-7)
+ 0 1 0 1 (5)
)&/*&$'(&&$/*"&/'/
1 1 1 0 (-2)
%"+'!)',"+%*-&/$'-
44If the result of the operation is negative, we get a negative number
in 2's complement form. In some cases, there is a carry bit beyond the
end of the word size and this is ignored.
Example 3:
Add -4 10 + 4 10 . Use 4-bit system.
1 1 0 0 (-4 in 2's complement form)
0 1 0 0 (+4)
(-,%*!+%)"+/!'!#-!
1 0 0 0 0 = 0
$$%,.!&#-,.$!-"%)+
In the above example, the carry bit goes beyond the end of
the word and this can be ignored. In this case both operands are
having different signs. There will be no error in the result. On any
addition, the result may be larger than can be held in the word size
being used and this would result in overflow.
The overflow condition is based on the rule:
If two numbers are added and if they are either positive or
negative, then overflow occurs if and only if the result has the opposite
sign.
Example 4:
Add (-7 10 ) + (-5 10 ) using the word size 4.
1 0 0 1 (-7 in 2's complement form)
1 0 1 1
%%'%&*$-!+(&$+!(''
1 0 1 0 0
/$!-/.!(#),,,(!*,- (-5 in 2's complement form)
45
(The result is wrong)In the above example both operands are negative. But the MSB
of the result is 0 that is the result is positive (opposite sign) and hence
overflow occurs and the result is wrong.
2.11.3 Binary Subtraction
Subtrahend and minuend are the two operands in an unsigned
binary subtraction. The minuend is the number in a subtraction
operation from which another number is subtracted. The subtrahend
is the number that is subtracted from another number. Simple binary
subtraction operations are as follows:
0 $'* 0
1 ,") 0
1 "%$ 1
10 "$" 1
=
=
=
=
0
1
0
1
When subtracting 1 from 0, borrow 1 from the next most significant
bit (MSB). When borrowing from the next most significant bit, if it is 1,
replace it with 0. If the next most significant bit is 0, you must borrow
from a more significant bit that contains 1 and replace it with 0 and all
0s up to that point become 1s.
Example 1:
Subtract 1101 ($, 1010
borrow
0 1
1 1 0 1
- 1 0 1 0
!!,&($)"/,%.$.*
0 0 1 1
!#!"."+'.&/"//,
(minuend)
(subtrahend)
46When subtracting the 2 nd least significant bit (1 in the subtrahend)
from 0 (in the minuend), a 1 is borrowed from the more significant bit
(3 rd bit from right in the minuend) and hence 10 +/, 1 = 1. The 3 rd least
significant bit is made as 0.
Example 2:
Subtract 1000 '%, 101
0 1 1
1 0 0 0
- 1 0 1
"%%(!)&$'
001 1
after borrowing, the minuend will become
0 1 1 10
1 0 1 (subtrahend)
difference as per the basic operations for subtraction
To subtract one number (subtrahend) from another (minuend),
take the 2's complement of the subtrahend and add it to the minuend.
Example 3:
Subtract (+2) '+! (+7) using 4-bit system
0 0 1 0 (+2)
0 1 1 1 (+7)
1 0 0 1 ( -7 in 2's complement form)
0 0 1 0 (2)
+ 1 0 0 1 (-7)
'-&!/,&,,'+#+'".%-
1 0 1 1 (-5)
*.#.-#'$'&""&)&,!,
47Example 4:
Subtract (-6) /&) (+4) using 4 bit system
Minuend
-6
2's complement of the Subtrahend -4
1 0 1 0
1 1 0 0
#$$%."--'+.,--)/+$
1 0 1 1 0
-(&'..,"&!!+)+&$/,
Both numbers are represented as negative numbers. While
adding them, the result will be : 10110. As the word size is 4, the
carry bit goes beyond the end of the word and the result is positive
as the MSB is 0. This case leads to overflow and hence the result is
wrong. The overflow rule works in subtraction also.
2.12 Boolean algebra
Boolean algebra is a mathematical discipline that is used for
designing digital circuits in a digital computer. It describes the relation
between inputs and outputs of a digital circuit. The name Boolean
algebra has been given in honor of an English mathematician George
Boole who proposed the basic principles of this algebra. As with any
algebra, Boolean algebra makes use of variables and operations
(functions). A Boolean variable is a variable having only two possible
values such as, true or false, or as, 1 or 0. The basic logical
operations are AND, OR and NOT, which are symbolically
represented by dot, plus sign, and by over bar / single apostrophe.
Example:
A AND B = A . B
A OR = A + B
B
NOT A
48
= A--!
(or A)A Boolean expression is a combination of Boolean variables,
Boolean Constants and the above logical operators. All possible
operations in Boolean algebra can be created from these basic logical
operators. There are no negative or fractional numbers in Boolean
algebra.
The operation AND yields true (binary value 1) if and only if both of
its operands are true. The operation OR yields true if either or both of
its operands are true. The unary operation NOT inverts the value of its
operand. The basic logical operations can be defined in a form known
as Truth Table, which is a list of all possible input values and the output
response for each input combination.
2.12.1 Boolean operators (functions)
AND operator
The AND operator is defined in Boolean algebra by the use of the
dot (.) operator. It is similar to multiplication in ordinary algebra. The
AND operator combines two or more input variables so that the output
is true only if all the inputs are true. The truth table for a 2-input AND
operator is shown as follows:
A
0
0
1
1
B
0
1
0
1
Y
0
0
0
1
The above 2-input AND operation is expressed as: Y = A . B
OR operator
The plus sign is used to indicate the OR operator. The OR operator
combines two or more input variables so that the output is true if at
least one input is true. The truth table for a 2-input OR operator is
shown as follows:
49A
0
0
1
1
B
0
1
0
1
Y
0
1
1
1
The above 2-input OR operation is expressed as: Y = A + B
NOT operator
The NOT operator has one input and one output. The input is
either true or false, and the output is always the opposite, that is, the
NOT operator inverts the input. The truth table for a NOT operator
where A is the input variable and Y is the output is shown below:
A
0
1
Y
1
0
The NOT operator is represented algebraically by the Boolean
expression: Y = A
Example: Consider the Boolean equation:
D = A + ( B . C )
D is equal to 1 (true) if A is 1 or if ( B . C ) is 1, that is, B = 0 and C =
1. Otherwise D is equal to 0 (false).
The basic logic functions AND, OR, and NOT can also be
combined to make other logic operators.
50NAND operator
The NAND is the combination of NOT and AND. The NAND is
generated by inverting the output of an AND operator. The algebraic
expression of the NAND function is:
Y = A . B
The NAND function truth table is shown below:
A
0
0
1
1
B
0
1
0
1
Y
1
1
1
0
A NAND B = NOT (A AND B)
NOR operator
The NOR is the combination of NOT and OR. The NOR is
generated by inverting the output of an OR operator. The algebraic
expression of the NOR function is:
Y = A + B
The NOR function truth table is shown below:
A
0
0
1
1
B
0
1
0
1
Y
1
0
0
0
A NOR B = NOT (A OR B)
512.12.2 Laws of Boolean algebra
Boolean algebra helps to simplify Boolean expressions in
order to minimize the number of logic gates in a digital circuit. You
will study about logic gates in the forthcoming chapter. This chapter
focuses on the theorems of Boolean algebra for manipulating the
Boolean expressions in order to simplify them.
Boolean Identities
Laws of Complementation
The term complement simply means to change 1s to 0s and 0s to 1s.
Theorem 1 : If A = 0, then A = 1
Theorem 2 : If A = 1, then A = 0
Theorem 3 : The complement to complement of A is A itself.
A = A
Basic properties of AND operator
Theorem 4
:
A . 1 = A
If A equals 0 and the other input is 1, the output is 0.
If A equals 1 and the other input is 1, the output is 1.
Thus the output is always equal to the A input.
Theorem 5
:
A . 0 = 0
As one input is always 0, irrespective of A, the output is always 0.
52Theorem 6
:
A . A = A
The output is always equal to the A input.
Theorem 7
:
A . A = 0
Regardless of the value of A, the output is 0.
Basic properties of OR operator
Theorem 8
:
A + 1 = 1
If A equals 0 and the other input is 1, the output is 1.
If A equals 1 and the other input is 1, the output is 1.
Thus the output is always equal to 1 regardless of what value A
takes on.
Theorem 9
:
A + 0 = A
The output assumes the value of A.
Theorem 10 :
A + A = A
The output is always equal to the A input.
Theorem 11 :
A + A = 1
Regardless of the value of A, the output is 1.
2.12.3 Simplification of Boolean expressions
Before seeing the important theorems used in the
simplification of Boolean expressions, some Boolean mathematical
concepts need to be understood.
53Literal
A literal is the appearance of a variable or its complement in a
Boolean expression.
Product Term
A product term in a Boolean expression is a term where one or
more literals are connected by AND operators. A single literal is also a
product term.
Example:
AB, AC, A C, and E are the product terms.
Minterm
A minterm is a product term, which includes all possible variables
either complemented or uncomplemented. In a Boolean expression
of 3 variables, x, y, and z, the terms xyz, x yz, and x y z are minterms.
But xy is not a minterm. Minterm is also called as a standard product
term.
Sum term
A sum term in a Boolean expression is a term where one or more
literals are connected by OR operators.
Example: A + B + D
Maxterm
A maxterm is a sum term in a Boolean expression, which
includes all possible variables in true or complement form. In a
Boolean expression of 3 variables, x, y, and z, the terms x + y + z,
and x + y + z are the maxterms. Maxterm is also called as standard
sum term.
54Sum-of-products (SOP)
A sum of products expression is a type of Boolean expression
where one or more product terms are connected by OR operators.
Example: A + A B + A B C
In an expression of 3 variables, A, B, and C, the expression
ABC + A B C + A B C is also called as a canonical sum or sum of
standard product terms or sum of minterms.
Product-of-sums (POS)
Product of sums is a type of Boolean expression where several
sum terms are connected by AND operators.
Example: (A + B) (A + B) (A + B)
A canonical product or product of standard sum terms is a
product of sums expression where all the terms are maxterms. The
above example is a canonical product in a Boolean expression of
two variables A and B.
Theorem 12: Commutative Law
A mathematical operation is commutative if it can be applied to
its operands in any order without affecting the result.
Addition and multiplication operations are commutative.
Example:
A + B = B + A
AB = BA
55Subtraction is not commutative:
A - B +(. B - A
There is no subtraction operation in Boolean algebra.
Theorem 13: Associative Law
A mathematical operation is associative if its operands can be
grouped in any order without affecting the result. In other words, the
order in which one does the OR operation does not affect the result.
(A + B) + C = A + (B+C) = (A + C) + B
Similarly, the order in which one does the AND operation does
not affect the result.
(AB)C = A(BC) = (AC)B
Theorem 14: Distributive Law
The distributive property allows us to distribute an AND across
several OR functions.
Example:
A(B+C) = AB + AC
The following distributive law is worth noting because it differs
from what we would find in ordinary algebra.
A + (B . C) = (A + B) . (A + C)
The simplest way to prove the above theorem is to produce a
truth table for both the right hand side (RHS) and the left hand side
(LHS) expressions and show that they are equal.
56A
0
0
0
0
1
1
1
1
B
0
0
1
1
0
0
1
1
C
0
1
0
1
0
1
0
1
BC
0
0
0
1
0
0
0
1
LHS
0
0
0
1
1
1
1
1
A+B A+C
0
0
0
1
1
0
1
1
1
1
1
1
1
1
1
1
RHS
0
0
0
1
1
1
1
1
Minimum Sum of Products
A minimum sum of products expression is one of those Sum of
Products expressions for a Boolean expression that has the fewest
number of terms.
Consider the following Boolean Expression:
A B C + A B C + A B C + A B C + A B C
Using Associativity Law
= (A B C + A B C) + (A B C + A B C) + A B C
= A B(C+C) + A B(C+C)+ABC
Using Theorem 11
= A B (1) + A B (1) + ABC
Using Theorem 4
= A B + A B + ABC
57The above expression is in the minimum sum of products form.
The given Boolean expression can be rewritten as follows using
theorem 10.
A B C + A B C + A B C + A B C + A B C + A B C (A B C + A B C = A B C)
= (A B C + A B C) + (A B C + A B C) + (A B C + A B C)
= A B (C + C) + A B (C + C) + A C(B + B)
= A B + A B + A C
The same Boolean expression can be simplified into many
minimum sum of products form.
Examples:
Simplify the following Boolean Expression
A B C + A B C
Let x = A B and y = C
The above Boolean expression becomes
x y + x y
= x(y + y)
= x = A B
Prove that A + A B = A + B
According to Distributive Law
A + A B = (A + A)(A + B) = 1 ', (A + B) = A + B
58Simplify the following Boolean Expression
A B C + A B C + A B C + A B C
= A C(B + B) + A B C + A B C
= A C + A B C + A B C
= A(C + BC) + A B C
= A(C + B)(C + C) + A B C
= A(C + B) + A B C
= A C + A B + A B C (one minimal form)
In the given Boolean Expression, if the second and third terms
are grouped, it will give
A B C + (A B C + A B C) + A B C
= A B C + A B(C + C) + A B C
= A B C + A B + A B C
= B C(A + A) + A B
= B C + A B
(most minimal form)
2.12.4 DeMorgan's Theorems
Theorem 15:
Theorem 16:
A + B = A B
AB = A + B
59The above identities are the most powerful identities used in
Boolean algebra. By constructing the truth tables, the above identities
can be proved easily.
Example:
Given Boolean function f(A,B,C,D) = D A B + A B + D A C, Find the
complement of the Boolean function
f (A,B,C,D) = D A B + A B + D A C
Apply DeMorgan's Law (theorem 15)
= (D A B) (A B) (D A C)
Apply DeMorgan's Law (theorem 16)
= (D + A + B)(A + B)(D + A + C)
In the above problem, the given Boolean function is in the sum
of products form and its complement is in the product of sums form.
The DeMorgan's theorem says that any logical binary
expression remains unchanged if we,
#/
+&
$)
-)
change all varibales to their complements
change all AND operations to OR operations
change all OR operations to AND operations
take the complement of the entire expression
A practical operational way to look at DeMorgan's theorem
is that the inversion of an expression may be broken at anypoint and
the operation at that point replaced by its oppostie ( i.e., AND replaced
by OR or vice versa).
60The fundamentals of numbering systems, including examples
showing how numbering systems work, converting values between
one numbering system and another, and performing simple types of
binary arithmetic have been covered in this chapter. Boolean algebra
has been introduced and Boolean identities and the laws of Boolean
algebra are explained with examples. The identities and the theorems
are used in the simplification of Boolean expressions. The pictorial
representation of the Boolean operators, that is, logic gates and the
design of logic circuits are discussed in Chapter 4.
EXERCISES
I. Fill in the blanks
1. The term bit stands for '#.*$$*,&*'#&-.
#*.-)-$%'*(,-("
2. The radix of an octal system is -.$+(/&*#+$).!- and for the
hexadecimal system is ,#/#'/'"%-,$"!+
3. The range of unsigned integers in an n-bit system is from #&!&!/,')
.)%''%to ,+/+%-*+/&/#)!*.
4. The synonyms LSB and MSB stand for +#/+!(+,.++./)&, ,%(#',/).&.-
and (/.**(!-/(/,-*.
5. In binary addition, the operands are called as ,"')-$('"$&*),) and
&+(+%)+&-*%,-#..
6. In binary subtraction, the operands are called as +&/*.$--*.(')!#
and )&.()*($'&%,)#&.
7. The binary representation of the decimal number 5864 is '-+-'!(+-
and the hexadecimal representation of the same number will be
"*,)*,#*)!""#!,.
8. The 2's complement of 0 is )&",/$"-!$+/+#*.
619. The arithmetic operations in a digital computer are performed using
the radix /,++%,'.&!'.))/, &",.&+"'))#+/%-
10. One byte equals *%),'%)&$.-*%&* number of bits.
11. One million bytes are referred to as MB and one billion bytes are
referred to as $#+/!(#)'##)-)-
12. The exponent of the smallest power of 2 that is larger than 68 is *#)
+/(//-*%*$)'and hence the number 68 has -,*!$"/-+&/%.,- binary digits
in its binary equivalent.
II. Review questions
1.
Convert the following decimal numbers into their equivalent
binary, octal and hexadecimal numbers.
a. 512
b. 1729
c. 1001
d. 777
e. 160
2. Write $-(27 10 as an 8-bit 2's complement number.
3. Add the signed numbers +15 10 and +36 10. Write the operands
and the sum as 8-bit binary numbers.
4. Write the largest positive and negative numbers for an 8-bit
signed number in decimal and 2's complement notation.
5. Do the following signed binary arithmetic operations.
a. 10 10 + 15 10
b. $('12 10 + 5 10
c.
14 10 - 12 10
d. ( +(-2 10 ) - (-6 10 )
6.
Convert the following binary numbers to decimal numbers
a. 1011 2
b.
101110 2
62
c.
1010011 27.
Convert the following binary numbers into hexadecimal numbers
a. 101 2
8.
c.
b.
1A8 16
c.
b.
5E9 16
c.
CAFE 16
b. 101110 - 1011
Convert the following decimal numbers to binary using sum of
powers of 2 method
a. 41 10 b. 77 10
12.
39EB 16
Do the following binary arithmetic.
a. 11011001 + 1011101
11.
111101000010 2
Convert the following hexadecimal numbers to decimal numbers
a. B6 16
10.
11010 2
Convert the following hexadecimal numbers to binary numbers
a. F2 16
9.
b.
c. 95 10
Using the theorems stated in Boolean algebra, prove the
following
a.
A + AB = A
b.
(A + B)(A + C) = A + BC
13. Simplify the following Boolean expressions
a. A B C + A B C + A B C
b. A B C + A B C + A B C + A B C
14.
Using DeMorgan's theorems, simplify the following Boolean
expressions
a.
A C + B+C
b.
((AC) + B) + C
15. Draw the truth table of the Boolean Expression
(A + B + C)
63CHAPTER 3
COMPUTER ORGANIZATION
3.1 Basic Components of a Digital Computer
3.1.1 Introduction
Computers are often compared to human beings since both
have the ability to accept data, store, work with it, retrieve and provide
information. The main difference is that human beings have the
ability to perform all of these actions independently. Human beings
also think and control their own activities. The computer, however,
requires a program (a predefined set of instructions) to perform an
assigned task. Human beings receive information in different forms,
such as eyes, ears, nose, mouth, and even sensory nerves. The
brain receives or accepts this information, works with it in some
manner, and then stores in the brain for future use. If information at
the time requires immediate attention, brain directs to respond with
actions. Likewise the Central Processing Unit (CPU) is called the
brain of the computer. It reads and executes program instructions,
performs calculations and makes decisions.
3.1.2 Components of a Digital Computer
A computer system is the integration of physical entities called
hardware and non-physical entities called software. The hardware
components include input devices, processor, storage devices and
output devices. The software items are programs and operating aids
(systems) so that the computer can process data.
3.1.3 Functional Units of a Computer System
Computer system is a tool for solving problems. The hardware
should be designed to operate as fast as possible. The software
(system software) should be designed to minimize the amount of idle
64computer time and yet provide flexibility by means of controlling the
operations. Basically any computer is supposed to carry out the
following functions.
-
-
-
-
Accept the data and program as input
Store the data and program and retrieve as and when required.
Process the data as per instructions given by the program
and convert it into useful information
Communicate the information as output
Based on the functionalities of the computer, the hardware
components can be classified into four main units, namely
-
-
-
-
Input Unit
Output Unit
Central Processing Unit
Memory Unit
These units are interconnected by minute electrical wires to
permit communication between them. This allows the computer to
function as a system. The block diagram is shown below.
Fig. 3.1 : Functional Units of a Computer System
65Input Unit
A computer uses input devices to accept the data and
program. Input devices allow communication between the user and
the computer. In modern computers keyboard, mouse, light pen,
touch screen etc, are some of the input devices.
Output Unit
Similar to input devices, output devices have an interface
between the computer and the user. These devices take machine
coded output results from the processor and convert them into a
form that can be used by human beings. In modern computers,
monitors (display screens) and printers are the commonly used output
devices
Central Processing Unit
Fig. 3.2. Central Processing Unit
CPU is the brain of any computer system. It is just like the human
brain that takes all major decisions, makes all sorts of calculations and
directs different parts of the computer function by activating and
controlling the operation. It consists of arithmetic and logic units, control
unit and internal memory (registers). The control unit of the CPU co-
ordinates the action of the entire system. Programs (software) provide
the CPU, a set of instruction to follow and perform a specific task.
Between any two components of the computer system, there is a
pathway called a bus which allows for the data transfer between them.
66Control unit controls all the hardware operations, ie, those of
input units, output units, memory unit and the processor. The arithmetic
and logic units in computers are capable of performing addition,
subtraction, division and multiplication as well as some logical
operations. The instructions and data are stored in the main memory
so that the processor can directly fetch and execute them.
Memory Unit
In the main memory, the computer stores the program and
data that are currently being used. In other words since the computers
use the stored program concept, it is necessary to store the program
and data in the main memory before processing.
The main memory holds data and program only temporarily.
Hence there is a need for storage devices to provide backup storage.
They are called secondary storage devices or auxiliary memory
devices. Secondary storage devices can hold more storage than
main memory and is much less expensive.
3.1.4 Stored Program Concept
All modern computers use the stored program concept. This
concept is known as the Von ()" Neumann concept due to the research
paper published by the famous mathematician John Von Neuman.
The essentials of the stored program concept are
-
-
-
-
the program and data are stored in a primary memory (main
memory)
once a program is in memory, the computer can execute it
automatically without manual intervention.
the control unit fetches and executes the instructions in
sequence one by one.
an instruction can modify the contents of any location inThe
stored program concept is the basic operating principle for
every computer.
673.2 Central Processing Unit
3.2.1 Functions of a Central Processing Unit
The CPU is the brain of the computer system. It performs
arithmetic operations as well as controls the input, output and storage
units. The functions of the CPU are mainly classified into two
categories :
-
-
Co )-+ ordinate all computer operations
Perform arithmetic and logical operations on data
The CPU has three major components.
-
-
-
Arithmetic and Logic Unit
Control Unit
Registers (internal memory)
The arithmetic and logic unit (ALU) is the part of CPU where
actual computations take place. It consists of circuits which perform
arithmetic operations over data received from memory and are
capable of comparing two numbers.
The control unit directs and controls the activities of the
computer system. It interprets the instructions fetched from the main
memory of the computer, sends the control signals to the devices
involved in the execution of the instructions.
While performing these operations the ALU takes data from
the temporary storage area inside the CPU named registers. They
are high-speed memories which hold data for immediate processing
and results of the processing.
68Fig. 3.3 : Functions of a CPU
3.2.2 Working with Central Processing Unit
The CPU is similar to a calculator, but much more powerful.
The main function of the CPU is to perform arithmetic and logical
operations on data taken from main memory. The CPU is controlled
by a list of software instructions. Software instructions are initially
stored in secondary memory storage device such as a hard disk,
floppy disk, CD-ROM, or magnetic tape. These instructions are then
loaded onto the computer's main memory.
When a program is executed, instructions flow from the main
memory to the CPU through the bus. The instructions are then
decoded by a processing unit called the instruction decoder that
interprets and implements the instructions. The ALU performs specific
operations such as addition, multiplication, and conditional tests on
the data in its registers, sending the resulting data back to the main
memory or storing it in another register for further use.
69To understand the working principles of CPU, let us go through
the various tasks involved in executing a simple program. This
program performs arithmetic addition on two numbers. The algorithm
of this program is given by
(i)
(ii)
(iii)
(iv)
input the value of a
input the value of b
sum = a + b
output the value of sum
This program accepts two values from the keyboard, sums it
and displays the sum on the monitor. The steps are summarized as
follows :
1. The control unit recognizes that the program (set of instructions)
has been loaded into the main memory. Then it begins to execute
the program instructions one by one in a sequential manner.
2. The control unit signals the input device (say keyboard) to accept
the input for the variable !".a*)).
3. The user enters the value of #)&a-.% on the keyboard.
4. The control unit recognizes and enables to route the data (value
of a) to the pre-defined memory location (address of "%(a'/-).
5. The steps 2 to 4 will be repeated for the second input .*%b%&$. The
value of "%-b*&" is stored in the memory location (address of %&*b$'$).
6. The next instruction is an arithmetic instruction. Before executing
the arithmetic instruction, the control unit enables to send a copy
of the values stored in address of $)$a*.) and address of &/%b.&+ to the
internal registers of the ALU and signals the ALU to perform the
sum operation.
7. The ALU performs the addition. After the computation, the control
unit enables to send the copy of the result back to the memory
(address of +$&sum'/#).
708. Finally, the result is displayed on the monitor. The control unit enables
to send the copy of the values of the address of #(.sum/#$ to the monitor
(buffer) and signals it. The monitor displays the result.
9. Now this program execution is complete.
The data flow and the control flow of CPU during the execution
of this program is given as,
Fig. 3.4 : Working Principles of a CPU
713.3 Arithmetic and Logic Unit
- ALU
The ALU is the computer's calculator. It executes arithmetic
and logical operations. The arithmetic operations include addition,
subtraction, multiplication and division. The logical operation
compares numbers, letters and special characters. The ALU also
performs logic functions such as AND, OR and NOT.
The ALU functions are directly controlled by the control unit. The
control unit determines when the services of the ALU are needed, and
it provides the data to be operated. The control unit also determines
what is to be done with the results.
3.3.1 Arithmetic Operations
Arithmetic operations include addition, subtraction,
multiplication, and division. While performing these operations, the
ALU makes use of the registers. Data to be arithmetically manipulated
are copied from main memory and placed in registers for processing.
Upon completion of the arithmetic operation, the result can be
transferred from the register to the main memory. In addition to
registers, the arithmetic unit uses one or more adders that actually
perform arithmatic operations on the binary digits.
The arithmetic operation in adding two numbers can be
demonstrated through following steps :
Step 1 : The numbers (5 and 8) to be added up are put into two
separate memory locations.
Step 2 : The control unit fetches the two numbers from their memory
locations into the data registers.
Step 3 : The arithmetic unit looking at the operator (+) uses the
accumulator and adds the two numbers.
Step 4 : The ALU stores the result (13) in memory buffer register.
Step 5 : Then the control unit stores the result into a user desired
memory location, say !.!sum")'.
72Fig. 3.5 Arithmetic Logic Unit
3.3.2 Logical Operations
The importance of the logic unit is to make logical operations.
These operations include logically comparing two data items and
take different actions based on the results of the comparison.
3.3.3 Functional Description
Some of the basic functions performed by the ALU are - add,
subtract, logical AND, logical OR, shift left and shift right on two's
complement binary numbers. The inputs to be calculated are stored
in the input register (AREG) and the input / output register (ACCUM)
for add, AND and OR functions. The shift left and shift right functions
operate on the value in the ACCUM
73Fig. 3.6 : Functional Description of ALU
The above figure illustrates the functional level block diagram
of the ALU. The control unit controls the operations of the ALU by
giving appropriate control signals to select a specific function and
then enable the operation after the data are fed into the registers.
The enable bit is made 1 after the data to be operated are transferred
from main memory.
3.4 Memory Unit
Memory units are the storage areas in a computer. The term
,-(memory/'& usually refers to the main memory of the computer,
whereas, the word !,,storage,"* is used for the memory that exists on
disks, CDs, floppies or tapes. The main memory is usually called a
physical memory which refers to the ($%chip%#, (Integrated Circuit) capable
of holding data and instruction.
74Fig. 3.7 Memory Unit
There are different types of memory. They are Random Access
Memory (RAM), Read Only Memory (ROM), Programmable Read-
Only Memory (PROM), Erasable Programmable Read-Only Memory
(EPROM), Electrically Erasable Programmable Read-Only Memory
(EEPROM).
Random Access Memory - RAM
RAM is the most common type of memory found in the modern
computers. This is really the main store and is the place where the
program gets stored. When the CPU runs a program, it fetches the
program instructions from the RAM and carries them out. If the CPU
needs to store the results of the calculations it can store them in
RAM. When we switch off a computer, whatever is stored in the
RAM gets erased. It is a volatile form of memory.
Read Only Memory - ROM
In ROM, the information is burnt (pre-recorded) into the ROM
chip at manufacturing time. Once data has been written into a ROM
chip, it cannot be erased but you can read it. When we switch off the
computer, the contents of the ROM are not erased but remain stored
permanently. ROM is a non-volatile memory. ROM stores critical
programs such as the program that boots the computer.
75Programmable Read Only Memory - PROM
PROM is a memory on which data can be written only once.
A variation of the PROM chip is that it is not burnt at the manufacturing
time but can be programmed using PROM programmer or a PROM
burner. PROM is also a non-volatile memory.
Erasable Programmable Read Only Memory - EPROM
In EPROM, the information can be erased and reprogrammed
using a special PROM '%$ programmer. EPROM is non-volatile
memory. A EPROM differs from a PROM in that a PROM can be
written to only once and cannot be erased. But an ultraviolet light is
used to erase the contents of the EPROM.
Electrically Erasable Programmable Read Only Memory
- EEPROM
EEPROM is a recently developed type of memory. This is
equivalent to EPROM, but does not require ultraviolet light to erase
its content. It can be erased by exposing it to an electrical charge. It
is also non-volatile in nature. EEPROM is not as fast as RAM or
other types of ROM. A flash memory is a special type of EEPROM
that can be erased and reprogrammed.
The main memory must store many data items and have some
way of retriving them when they are needed. The memory can be
compared to the boxes at a post office. Each box-holder has a box
with a unique number which is called its address. This address serves
to identify the box. The memory has a number of locations in its
store. Each location in a memory has a unique number called its
memory address. This serves to identify it for storage and retrival.
Operations on memories are called reads and writes, defined
from the perspective of a processor or other device that uses a
memory: a write instruction transfers information from other device to
76memory and a read instruction transfers information from the memory
to other devices. A memory that performs both reads and writes is often
called a RAM, random access memory. Other types of memories
commonly used in systems are read-only memory.
Data Representation
The smallest unit of information is a single digit called a ,$-bit!+,
(binary digit), which can be either 0 or 1. The capacity of a memory
system is represented by a unit called a byte, which is 8 bits of
information. Memory sizes in modern systems range from 4MB
(megabytes) in small personal computers up to several billion bytes
(gigabytes, or GB) in large high-performance systems.
The performance of a memory system is defined by two
different measures, the access time and the memory cycle time.
Access time, also known as response time or latency, refers to how
quickly the memory can respond to a read or write request. Memory
cycle time refers to the minimum period between two successive
requests.
The following terminology is used while discussing hierarchical
memories:
3!$,4 The registers (internal memory) are used to hold the instruction
and data for the execution of the processor. Eventually the
top of the hierarchy goes to the registers.
3/!)4 The memory closest to the processor is known as a cache. It
is a high speed memory that is much faster than the main
memory.
3.'/4 The next is the main memory which is also known as the
primary memory.
3+.$4 The low end of the hierarchy is the secondary memory.
77The secondary memory is the memory that supplements the
main memory. This is a long term non-volatile memory. It is external
to the system nucleus and it can store a large amount of programs
and data. The CPU does not fetch instructions of a program directly
from the secondary memory. The program should be brought into
the main memory from the secondary memory before being executed.
The secondary memory is cheaper compared to the main
memory and hence a computer generally has limited amount of main
memory and large amount of secondary memory.
3.5 Input and Output Devices
The main function of a computer system is to process data.
The data to be processed by the computer must be input to the
system and the result must be output back to the external world.
3.5.1 Input Devices
An input device is used to feed data into a computer. For
example, a keyboard is an input device. It is also defined as a device
that provides communication between the user and the computer.
Input devices are capable of converting data into a form which can
be recognized by computer. A computer can have several input
devices.
Keyboard
The most common input device is the keyboard. Keyboard
consists of a set of typewriter like keys that enable you to enter data
into a computer. They have alphabetic keys to enter letters, numeric
keys to enter numbers, punctuation keys to enter comma, period,
semicolon, etc., and special keys to perform some specific functions.
The keyboard detects the key pressed and generates the
corresponding ASCII codes which can be recognized by the
computer.
78Fig. 3.8 Keyboard
Mouse
Mouse is an input device that controls the movement of the
cursor on the display screen. Mouse is a small device, you can roll
along a flat surface. In a mouse , a small ball is kept inside and
touches the pad through a hole at the bottom of the mouse. When
the mouse is moved, the ball rolls. This movement of the ball is
converted into signals and sent to the computer. You will need to
click the button at the top of the mouse to select an option. Mouse
pad is a pad over which you can move a mouse. Mouse is very
popular in modern computers.
Fig. 3.9 Mouse
79Scanner
Scanner is an input device that allows information such as
an image or text to be input into a computer. It can read image or
text printed on a paper and translate the information into a form that
the computer can use. That is, it is used to convert images (photos)
and text into a stream of data. They are useful for publishing and
multi-media applications.
Fig. 3.10 Scanner
Bar Code Reader
The barcode readers are used in places like supermarket,
bookshops, etc. A bar code is a pattern printed in lines of different
thickness. The bar-code reader scans the information on the bar-
codes and transmits to the computer for further processing. The
system gives fast and error-free entry of information into the
computer.
Fig.3.11 Bar Code and Reader
80Digital Camera
The digital camera is an input device mainly used to capture
images. The digital camera takes a still photograph, stores it and
sends it as digital input to the computer. It is a modern and popular
input device.
Fig. 3.12 Digital Camera
Touch Sensitive Screen
Touch Sensitive Screen is a type of display screen that has a
touch-sensitive panel. It is a pointing device that enables the user to
interact with the computer by touching the screen. You can use your
fingers to directly touch the objects on the screen. The touch screen
senses the touch on the object (area pre-defined) and communicate
the object selection to the computer.
Fig. 3.13 Touch Sensitive Screen
81Magnetic Ink Character Recognition (MICR)
Fig. 3.14 MICR Cheque
MICR is widely used by banks to process cheques. Human
readable numbers are printed on documents such as cheque using
a special magnetic ink. The cheque can be read using a special
input unit, which can recognize magnetic ink characters. This method
eliminates the manual errors. It also saves time, ensures security
and accuracy of data.
Optical Character Recognition (OCR)
Fig. 3.15 OCR Sheet
The OCR technique permits the direct reading of any printed
character like MICR but no special ink is required. With OCR, a user
can scan a page from a book. The computer will recognize the
characters in the page as letters and punctuation marks, and stores.
This can be edited using a word processor.
82Optical Mark Reading and Recognition (OMR)
Fig. 3.16 OMR Reader
In this method special pre-printed forms are designed with
boxes which can be marked with a dark pencil or ink. Such documents
are read by a reader, which transcribes the marks into electrical pulses
which are transmitted to the computer. They are widely used in
applications like objective type answer papers evaluation in which
large number of candidates appear, time sheets of factory employees
etc.
Light Pen
A light pen is a pointing device shaped like a pen and is
connected to a monitor. The tip of the light pen contains a light-
sensitive element which, when placed against the screen, detects
Fig. 3.17 Light Pen
83the light from the screen enabling the computer to identify the location
of the pen on the screen. Light pens have the advantage of '+,drawing(*(
directly onto the screen, but this can become uncomfortable, and
they are not accurate.
Magnetic Reader
Magnetic reader is an input device which reads a magnetic
strip on a card. It is handy and data can be stored and retrieved. It
also provides quick identification of the card's owner.
All the credit cards, ATM cards (banks), petro cards, etc. stores
data in a magnetic strip which can be read easily by the magnetic
reader.
Fig. 3.18 Magnetic Reader
Smart Cards
This input device stores data in a microprocessor embedded
in the card. This allows information, which can be updated, to be
stored on the card. These data can be read and given as input to the
computer for further processing. Most of the identification cards use
this method to store and retrieve the vital information.
Fig. 3.19 Smart Card Reader
84Notes Taker
Notes taker is a device that captures natural handwriting on any
surface onto a computer. Using an electronic pen, the notes taker
displays the user's handwritten notes, memos or drawings on the
computer, and stores the image for future use.
Fig. 3.20 Notes Taker
Microphone
Microphone serves as a voice input device. It captures the
voice data and input to the computer. Using the microphone along
with speech recognition software can offer a completely new
approach to input information into your computer.
Speech recognition programs, although not yet completely
exact, have made great strides in accuracy as well as ease of use.
The voice-in or speech recognition approach can almost fully replace
the keyboard and mouse. Speech recognition can now open the
computer world to those who may have been restricted due to a
physical handicap. It can also be a boon for those who have never
learned to type.
Fig. 3.21 Microphone
853.5.2 Output Devices
Output is anything that comes out of a computer. An output
device is capable of presenting information from a computer. There
are many output devices attached with the computers. But the
monitors and printers are commonly used output devices.
Monitors
Monitor is a commonly used output device, sometimes called
as display screen. It provides a visual display of data. Monitors are
connected with the computer and are similar in appearance to a
television set.
Fig. 3.22 Monitor
Initially there were only monochrome monitors. But gradually,
we have monitors that display colour. Monitors display images and
text. The smallest dot that can be displayed is called a pixel (picture
element) The resolution of the screen improves as the number of
pixels is increased. Most of the monitors have a 4 : 3 width to height
ratio. This is called -.*aspect ratio!,..
The number of pixels that can be displayed vertically and
horizontally gives the resolution of the monitor. The resolution of the
monitor determines the quality of the display. Some popular
resolutions are 640 x 480 pixels, 800 x 600 pixels and 1024 x 768
pixels. A resolution of 1024 x 768 pixels will produce sharper image
than 640 x 480 pixels.
86Printers
Printer is an output device that prints text or images on paper
or other media (like transparencies). By printing you create what is
known as a +()hard copy)/+. There are different kinds of printers, which
vary in their speed and print quality. The two main types of printers
are impact printers and non-impact printers.
Printers
Impact
Line
printer
Non-impact
Serial
printer
(Dot matrix
printer)
Thermal
(fax) printer
Laser
printer
Inkjet
printer
Fig. 3.23 Types of Printers
Impact printers include all printers that print by striking an ink
ribbon. Impact printers use a print head containing a number of metal
pins which strike an inked ribbon placed between the print head and
the paper. Line printers, dotmatrix printers are some of the impact
printers.
Characteristics of Impact Printers
,! In impact printers, there is physical contact with the paper to
produce an image.
.( Due to being robust and low cost, they are useful for bulk
printing.
87'. Impact printers are ideal for printing multiple copies (that is,
carbon copies) because they can easily print through many
layers of paper.
)% Due to its striking activity, impact printers are very noisy.
-/ Since they are mechanical in nature, they tend to be slow.
/+ Impact printers do not support transparencies.
Non-impact printers are much quieter than impact printers as
their printing heads do not strike the paper. Non-impact printers
include laser printers, inkjet printers and thermal printers.
Characteristics of Non-Impact Printers
#- Non-impact printers are faster than impact printers because
they have fewer moving parts.
&' They are quiet than impact printers because there is no
striking mechanism involved.
-' They posses the ability to change typefaces automatically.
." These printers produce high-quality graphics
%/ These printers usually support the transparencies
"( These printers cannot print multipart forms because no impact
is being made on the paper.
Line Printer
Line printers are high-speed printers capable of printing an
entire line at a time. A line printer can print 150 lines to 3000 lines
per minute. The limitations of line printer are they can print only one
font, they cannot print graphics, the print quality is low and they are
noisy to operate. But it can print large volume of text data very fast
compared to the other printers. It is also used to print on multipart
stationaries to prepare copies of a document.
88Fig. 3.24 Line Printer
Dot Matrix Printer
The most popular serial printer is the dot matrix printer. It prints
one line of 8 or 14 points at a time, with print head moving across a
line. They are similar to typewriters. They are normally slow. The printing
speed is around 300 characters per second. It uses multipart
stationaries to prepare copies of a document.
Fig. 3.25 Dot Matrix Printer
89Thermal Printer
Thermal printers are printers that produce images by pushing
electrically heated pins against special heat-sensitive paper. They
are inexpensive and used widely in fax machines and calculators.
Fig. 3.26 Thermal Printer
Thermal printer paper tends to darken over time due to
exposure to sunlight and heat. So the printed matters on the paper
fade after a week or two. It also produces a poor quality print.
Laser Printers
Laser printers use a laser beam and dry powdered ink to
produce a fine dot matrix pattern. It can produce very good quality of
graphic images. One of the chief characteristics of laser printers is
their resolution %,( how many dots per inch (dpi) they lay down. The
available resolutions range from 300 dpi at the low end to around
1200 dpi at the high end.
Fig. 3.27 Laser Printer
90Inkjet Printers
Inkjet printers use colour cartridges which combine magenta,
yellow and cyan inks to create colour tones. A black cartridge is also
used for crisp monochrome output. Inkjet printers work by spraying
ionizing ink at a sheet of paper. Magnetized plates in the ink's path
direct the ink onto the paper in the described shape.
Fig. 3.28 Inkjet Printer
Speakers
The computer can also give produce voice output(audio data).
Speaker serves as a voice output device. Using speakers along with
speech synthesizer software, the computer can provide voice output.
Voice output has become very common in many places like airlines,
banks, automatic telephone enquiry system etc. Users can also hear
music/songs using the voice output system.
Fig. 3.29 Speakers
91Plotters
Apart from the output devices like printers, plotters are also
used to produce graphical output. Although printer output is very
convenient for many purposes, the user needs to present the
information graphically in order to understand its significance.
3.5.3 Storage Devices
The computer may need to store data, programs etc. in a
computer readable medium . This is called the secondary storage.
Secondary storage is also called backup storage. Secondary stor-
age can be used to transmit data to another computer either imme-
diately or a latter time. This provides a mechanism for storing a
large amount of data for a long period of time. Some of the com-
monly used storage devices are hard disks, magnetic tapes, floppy
disks and CD-ROM.
To understand the physical mechanism of secondary storage
devices one must have knowledge of magnetism, electronics and
electro mechanical systems. The average time required to reach a
storage location and obtain its contents is called its access time. In
electromechanical devices with moving parts such as disks and
tapes, the access time consists of a seek time required to position
the read write head to a location and transfer time required to transfer
the data to or from the device.
Hard Disk
Hard disk is a magnetic disk on which you can store computer
data. The hard disk is a direct-access storage medium. This means
you can store and retrieve data randomly.
Disk storage systems are essentially based on magnetic
properties. The magnetic disk consists of high speed rotating
surfaces coated with a magnetic recording medium. The rotating
surface of the disk is a round flat plate. When writing data, a write
92head magnetizes the particles on the disk surface as either north or
south poles. When reading data, a read head converts the magnetic
polarisations on the disk surface to a sequence of pulses. The read
and write heads are generally combined into a single head unit. There
may be more than one read/write head.
Data is arranged as a series of concentric rings. Each ring
(called a track) is subdivided into a number of sectors, each sector
holding a specific number of data elements (bytes or characters).
Fig. 3.30 A track subdivided into sectors
The smallest unit that can be written to or read from the disk
is a sector. Once a read or write request has been received by the
disk unit, there is a delay involved until the required sector reaches
the read/write head. This is known as rotational latency, and on
average is one half of the period of revolution.
The storage capacity of the disk is determined as (number
of tracks * number of sectors * bytes per sector * number of
read/write heads) Thus,the data is stored as magnetized spots
arranged in concentric circles (tracks) on the disk. Each track is
divided into sectors. The arrangement of tracks and sectors on a
disk is known as its -,'format//..
93High data rates demand that the disk rotates at a high speed
(about 3,600 rpm). As the disk rotates read/write heads move to the
correct track and fetch the desired data.
Fig. 3.31 Hard Disk Drive
The storage capacity of a hard disk can be Gigabytes (GB),
i.e. thousands of Megabytes of information.
Magnetic Tape
A recording medium consisting of a thin tape with a coating of
a fine magnetic strip, used for recording digital data. The tape itself is
a strip of plastic coated with a magnetic recording medium.
Fig. 3.32 Magenatic Tape Reader
Bits are recorded as magnetic spots on the tape along several
tracks. Usually, seven or nine bits are recorded simultaneously to
form a character together with a parity bit. Read /write heads are
mounted one in each track so that data can be recorded and read
as a sequence of characters.
94Data is stored in frames across the width of the tape. The frames
are grouped into blocks or records which are separated from other
blocks by gaps. Magnetic tape is a serial access medium, similar to
an audio cassette, and so data cannot be randomly located. This
characteristic has prompted its use in the regular backing up of hard
disks.
Floppy Disk
Fig. 3.33 Floppy Disk
The floppy drive uses a thin circular disk for data storage. It is
a soft magnetic disk. It is a thin magnetic-coated disk contained in a
flexible or semi-rigid protective jacket. The disk rotates at 360rpm. A
read/write head makes physical contact with the disk surface. Data
is recorded as a series of tracks subdivided into sectors.
The floppy disks are usually 3.5" in size. However, older floppy
disks may be in use; these would be 5.25" in size or even 8" in size.
A 3.5" floppy disk can hold 1.44 MB of data. Once data is stored on
a floppy disk it can be %/%write protected+(! by clicking a tab on the disk.
This prevents any new data being stored or any old data being erased.
Disk drives for floppy disks are called floppy drives. Floppy disks are
slower to access than hard disks and have less storage capacity. It
is less expensive and are portable. It can be accessed randomly.
95Optical Disk
Optical disks are a storage medium from which data is read
and to which it is written by lasers. The optical disk is a random
access storage medium; information can be easily read from any
point on the disk. CD-ROM stands for Compact Disk - Read Only
Memory.
Fig. 3.34 Compact Disk
It is now possible to have CD-ROMs where tracks of
information can be written onto them by the user. These are called
read/write CD-ROMs and these are becoming a popular and cheap
method for storage.
Summary
* Computers are often compared to human beings since both
have the ability to accept data, store, work with it, retrieve
and provide information.
* A computer system is the integration of physical entities called
hardware and non-physical entities called software.
* The hardware components include input devices, processor,
storage devices and output devices.
96* The software items are programs and operating aids so that
the computer can process data.
* A computer uses input devices to accept the data and
program.
* In modern computers, monitors and printers are the commonly
used output devices.
* CPU is the brain of any computer system. It consists of
arithmetic and logic units, control unit and internal memory
(registers).
* Control unit controls all the hardware operations, ie, those of
input units, output units, memory unit and the processor.
* The arithmetic and logic units in computers are capable of
performing addition, subtraction, division and multiplication
as well as some logical operations.
* In the main memory, the computer stores the program and
data that are currently being used.
* All modern computers use the stored program concept. This
concept is due to John Von Neuman.
* The smallest unit of information is a single digit called a (''bit#"%
(binary digit), which can be either 0 or 1.
* The secondary memory is the memory that supplements the
main memory. This is a long term non-volatile memory.
* The most common input device is the keyboard.
97* Mouse is an input device that controls the movement of the
cursor on the display screen.
* Monitor is a commonly used output device.
* Some of the commonly used storage devices are hard disks,
magnetic tapes, floppy disks and CD-ROM.
Exercises
I. Fill in the blanks
1) A computer system is the interpretation of physical entities called
_________ and non-physical entities called_________
2) The computer uses_________ devices to accept data and
program.
3) CPU stands for _________
4) ALU stands for _________
5) RAM stands for _________
6) ROM stands for _________
7) The stored program concept is conceived by _________
8) Main memory is also known as _________ memory.
9) The performance of the memory system is defined by _________
time and _________ time.
10) _________ supplements the main memory.
11) _________ is popular input device for GUI application.
12) _________ is a input device mainly used to capture images.
13)Monitor is a commonly used output unit, sometimes called as
_________
14)The smallest dot that can be displayed on the monitor is called a
_________
15)Printers can be classified into _________ and _________ printers.
II. State whether the following are True or False
1) The operating system is a software.
2) Keyboard is an output device.
3) Touch sensitive screen is an input device.
984) Main memory is a non-volatile memory.
5) ALU performs arithmetic and logical operations.
6) Registers are a part of secondary storage.
7) Bar code reader is an output device.
8) Light pen is an input device.
9) Inkjet printers are impact printers.
10) CD !() ROM stands for Compact Disk '-* Read Only Memory.
III. Answer the following
1) How are the human being and the computers are related?
2) What are the components of the digital computer?
3) What are the functional units of a computer system?
4) Write the essentials of the stored program concept.
5) Write the main functions of the central processing unit.
6) What are the different types of main memory?
7) Define memory read and memory write operations.
8) What do you mean by memory access time?
9) What is the advantage of EEPROM over EPROM?
10) When do we use ROM?
11) What is an input device?
12) List few commonly used input devices.
13) What is an output device?
14) List few commonly used output devices.
15) What is a storage device?
16) List few commonly used storage devices.
17) What is the role of ALU?
18) What is a control unit?
19)What are registers?
20)What is a bus?
IV. Answer the following in detail.
1) Describe in detail the various units of the Central Processing Unit.
2) Explain the working principle of CPU with an example.
3) Briefly explain various types of memory.
994) List a few commonly used input / output devices and explain them
briefly.
V. Project
1) List out the sequence of activities in executing the following program
steps.
(i)
(ii)
(iii)
(iv)
input the value of a
input the value of b
multiply c = a * b
output the value c
2) Describe a configuration for a personal computer system by
identifying the input, output, processing and storage devices and
their specifications.
100CHAPTER 4
WORKING PRINCIPLE OF DIGITAL LOGIC
4.1 Logic Gates
A logic gate is an elementary building block of a digital circuit.
It is a circuit with one output and one or more inputs. At any given
moment, logic gate takes one of the two binary conditions low (0) or
high (1), represented by different voltage levels.
A voltage level will represent each of the two logic values. For
example +5V might represent a logic 1 and 0V might represent a
logic 0.
Input Signal
Output Signal
1
0
Input
1
Logic
Gate
1
Output
0
0
Time
Fig. 4.1 Logic Gate
This diagram which represents a logic gate accept input signals
(two or more) and produces an output signal based on the type of the
gate. The input signal takes values $,+1#!' or *%+0"$*. The output signal also
gives in the value //)1,*! or ,)(0$$!.
There are three fundamental logic gates namely, AND, OR and
NOT. Also we have other logic gates like NAND, NOR, XOR and XNOR.
Out of these NAND and NOR gates are called the universal gates,
because the fundamental logic gates can be realized Through them.
The circuit symbol and the truth table of these logic gates are explained
here.
101AND Gate
The AND gate is so named because, if 0 is called /+(false("% and 1
is called ",!true,$'( the gate acts in the same way as the logical "!,AND,)'
operator. The output is '!&true/,( only when both inputs are (/!true'#+, otherwise,
the output is ')&false&!/. In other words the output will be 1 if and only if both
inputs are 1; otherwise the output is 0. The output of the AND gate is
represented by a variable say C, where A and B are two and if input
boolean variables. In boolean algebra, a variable can take either of the
values *)#0",) or )."1,*". The logical symbol of the AND gate is
A
C = AB
B
Fig. 4.2 Logic symbol of AND Gate
One way to symbolize the action of an AND gate is by writing
the boolean function.
C = A AND B
In boolean algebra the multiplication sign stands for the AND
operation. Therefore, the output of the AND gate is
C = A . B
simply
or
C = AB
Read this as #("C equals A AND B(/%. Since there are two input
variables here, the truth table has four entries, because there are four
possible inputs : 00, 01, 10 and 11.
For instance, if both inputs are 0,
102C = A . B
= 0 . 0
= 0
The truth table for AND Gate is
Input
A
0
0
1
1
B
0
1
0
1
Output
C
0
0
0
1
Table 4.1 Truth Table for AND Gate
OR Gate
The OR gate gets its name from the fact that it behaves like
the logical inclusive ''%OR/-.. The output is *+(true(!/ if either or both of the
inputs are '*)true!#,. If both inputs are *#*false,#., then the output is $!+false&/*.
In otherwords the output will be 1 if and only if one or both inputs are
1; otherwise, the output is 0. The logical symbol of the OR gate is
Fig. 4.3 Logic symbol of OR Gate
The OR gate output is
C = A OR B
We use the + sign to denote the OR function. Therefore,
C = A + B
103Read this as "'!C equals A OR B&-%.
For instance, if both the inputs are 1
C = A + B = 1 + 1 = 1
The truth table for OR gate is
Input
Output
A B C
0 0 0
0 1 1
1 0 1
1 1 1
Table 4.2 Truth Table for OR Gate
NOT Gate
The NOT gate, called a logical inverter, has only one input. It
reverses the logical state. In other words the output C is always the
complement of the input. The logical symbol of the NOT gate is
A
C = A
Fig. 4.3 Logic symbol of NOT Gate
The boolean function of the NOT gate is
C = NOT A
In boolean algebra, the overbar stands for NOT operation. Therefore,
C = A
104Read this as ,./C equals NOT A+&/ or *$!C equals the complement of A#%#.
If A is 0,
C = 0 = 1
On the otherhand, if A is 1,
C = 1 = 0
The truth table for NOT gate is
Table 4.3 Truth Table for NOT Gate
NOR Gate
The NOR gate circuit is an OR gate followed by an inverter.
Its output is '&%true!(# if both inputs are $#*false//" Otherwise, the output is
)"/false".,. In other words, the only way to get &**1&%( as output is to have
both inputs ,'+0-!'. Otherwise the output is 0. The logic circuit of the
NOR gate is
A
A + B
C = A + B
B
Fig. 4.5 Logic Circuit of NOR Gate
A
C
B
Fig. 4.6 Logic symbol of NOR Gate
105The output of NOR gate is
C = ( A + B )
Read this as /'$C equals NOT of A OR B,/# or &*&C equals the
complement of A OR B!)%.
For example if both the inputs are 0,
C = ( 0 + 0 ) = 0 = 1
The truth table for NOR gate is
Input
Output
A B C
0 0 1
0 1 0
1 0 0
1 1 0
Table 4.4 Truth Table for NOR Gate
Bubbled AND Gate
The Logic Circuit of Bubbled AND Gate
A
A
C = A . B
B
B
Fig. 4.7 Logic Circuit of Bubbled AND Gate
106In the above circuit, invertors on the input lines of the AND gate
gives the output as
C = A . B
This circuit can be redrawn as the bubbles on the inputs, where
the bubbles represent inversion.
A
C
B
Fig. 4.8 Logic Symbol of Bubbled AND Gate
We refer this as bubbled AND gate. Let us analyse this logic
circuit for all input possibilities.
If A = 0 and B = 0 C = ( 0 . 0 ) = 1 . 1 = 1
If A = 0 and B = 1 C = ( 0 . 1 ) = 1 . 0 = 0
If A = 1 and B = 0 C = ( 1 . 0 ) = 0 . 1 = 0
If A = 1 and B = 1 C = ( 1 . 1 ) = 0 . 0 = 0
Here the truth table is
Output
Input
A
0
0
1
1
B
0
1
0
1
C
1
0
0
0
Table 4.5 Truth Table for Bubbled AND Gate
107You can see that, a bubbled AND gate produces the same
output as a NOR gate. So, you can replace each NOR gate by a
bubbled AND gate. In other words the circuits are interchangeable.
Therefore
( A + B ) = A . B
which establishes the De Morgan's first theorem.
NAND Gate
The NAND gate operates as an AND gate followed by a NOT
gate. It acts in the manner of the logical operation "*-AND!#, followed by
inversion. The output is $(-false-%* if both inputs are ,)!true(&(, otherwise,
the output is &,/true*(.. In otherwords the output of the NAND gate is 0 if
and only if both the inputs are 1, otherwise the output is 1. The logic
circuit of NAND gate is
A
(A . B)
C = (A . B)
B
Fig. 4.9 Logic Circuit of NAND Gate
The logical symbol of NAND gate is
A
C
B
Fig. 4.10 Logic Symbol of NAND Gate
The output of the NAND gate is
C = ( A . B )
Read this as ,&(C equals NOT of A AND B)-) or ..*C equals the
complement of A AND B#&,.
For example if both the inputs are 1
C = ( 1 . 1 ) = 1 = 0
108The truth table for NAND gate is
Output
Input
A
0
0
1
1
B
0
1
0
1
C
1
1
1
0
Table 4.6 Truth Table for NAND Gate
Bubbled OR Gate
The logic circuit of bubbled OR gate is
A
A
C = A + B
B
B
Fig. 4.11 Logic Circuit of Bubbled OR Gate
The output of this circuit can be written as
C = A + B
The above circuit can be redrawn as the bubbles on the input,
where the bubbles represents the inversion.
A
C
B
Fig. 4.12 Logic Symbol of Bubbled OR Gate
109We refer this as bubbled OR gate. The truth table for the bubbled
OR is
Output
Input
A
0
0
1
1
B
0
1
0
1
C
1
1
1
0
Table 4.7 Truth Table for Bubbled OR Gate
If we compare the truth tables of the bubbled OR gate with
NAND gate, they are identical. So the circuits are interchangeable.
Therefore
( A . B ) = A + B
which establishes the De Morgan's second theorem.
XOR Gate
The XOR (exclusive-OR) gate acts in the same way as the
logical .!+either/or.$%( The output is %"!true%!- if either, but not both, of the
inputs are $&)true.#/) The output is ($&false(,# if both inputs are ("(false"%- or if
both inputs are %*%true.'%) Another way of looking at this circuit is to
observe that the output is 1 if the inputs are different, but 0 if the
inputs are the same. The logic circuit of XOR gate is
A
A
A . B
B
C= A.B + A.B
A
A . B
B
B
Fig. 4.13 Logic Circuit of XOR Gate
110The output of the XOR gate is
C = A B + A B
T he truth table for XOR gate is
Output
Input
A
0
0
1
1
B
0
1
0
1
C
0
1
1
0
Table 4.8 Truth Table for XOR Gate
In boolean algebra, exclusive-OR operator is + or .)*encircled plus&%*.
Hence,
C = A + B
The logical symbol of XOR gate is
A
C
B
Fig. 4.14 Logic Symbol of XOR Gate
XNOR Gate
The XNOR (exclusive-NOR) gate is a combination XOR gate
followed by an inverter. Its output is *)(true++. if the inputs are the same,
and $+"false)#& if the inputs are different. In simple words, the output is 1
if the input are the same, otherwise the output is 0. The logic circuit
of XNOR gate is
111Fig. 4.15 Logic Circuit of XNOR Gate
The output of the XNOR is NOT of XOR
C
= A + B
= A.B + A.B
= AB + A B
(Using De Morgan's Theorem)
In boolean algebra, or #*'included dot*## stands for the XNOR.
Therefore,
C = A B
The logical symbol is
Fig. 4.16 Logic Symbol of XNOR Gate
The truth table for XNOR gate is
Output
Input
A
0
0
1
1
B
0
1
0
1
C
1
0
0
1
Table 4.9 Truth Table for XNOR Gate
112Using combinations of logic gates, complex operations can
be performed. In theory, there is no limit to the number of gates that
can be arranged together in a single device. But in practice, there is
a limit to the number of gates that can be packed into a given physical
space. Arrays of logic gates are found in digital integrated circuits.
The logic gates and their corresponding truth tables are
summarized in the following table.
Logical Gates
AND
OR
Symbol
Truth Table
A
0
0
1
1
A
0
0
1
1
A
0
1
NOT
NAND
NOR
XOR
XNOR
B
0
1
0
1
B
0
1
0
1
A
0
0
1
1
A
0
0
1
1
A
0
0
1
1
A
0
0
1
1
Table 4.10 summary of Logic Gates
113
A B
0
0
0
1
A+B
0
1
1
1
A
1
0
B
0
1
0
1
B
0
1
0
1
B
0
1
0
1
B
0
1
0
1
AB
1
1
1
0
A+B
1
0
0
0
A+B
0
1
1
0
A B
1
0
0
1Universality of NAND and NOR gates
We know that all boolean functions can be expressed in terms
of the fundamental gates namely AND, OR and NOT. In fact, these
fundamental gates can be expressed in terms of either NAND gates
or NOR gates. NAND gates can be used to implement the
fundamental logic gates NOT, AND and OR. Here A and B denote
the logical states (Input).
Fig. 4.17 Universality of NAND Gates
NOR gates can also be used to implement NOT, OR and AND gates.
0
B
B
B
Fig. 4.18 Universality of NOR Gates
1144.2 Conversion of Boolean Function
To build more complicated boolean functions, we use the AND,
OR, and NOT operators and combine them together. Also, it is
possible to convert back and forth between the three representations
of a boolean function (equation, truth table, and logic circuit). The
following examples show how this is done.
Converting a Boolean Equation to a Truth Table
Truth table lists all the values of the boolean function for each
set of values of the variables. Now we will obtain a truth table for the
following boolean function
D = (A '' B) + C
Clearly, D is a function of three input variables A, B, and C.
Hence the truth table will have 2 3 = 8 entries, from 000 to 111. Before
determining the output D in the table, we will compute the various
intermediate terms like A %# B and C as shown in the table below.
For instance, if A = 0, B = 0 and C = 0
then
D = ( A . B ) + C
= ( 0 . 0 ) + 0
= 0 + 0
= 0 + 1
= 1
Here we use the hierarchy of operations of the boolean
operators NOT, AND and OR over the parenthesis.
115The truth table for the boolean function is
Input
Intermediate
Output
A B C A -)+ B C D
0 0 0 0 1 1
0 0 1 0 0 0
0 1 0 0 1 1
0 1 1 0 0 0
1 0 0 0 1 1
1 0 1 0 0 0
1 1 0 1 1 1
1 1 1 1 0 1
Converting a Boolean Equation to a Logic Circuit
The boolean function is realized as a logic circuit by suitably
arranging the logic gates to give the desired output for a given set of
input. Any boolean function may be realized using the three logical
operations NOT, AND and OR. Using gates we can realize boolean
function.
Now we will draw the logic circuit for the boolean function.
E = A + ( B $# C ) + D
This boolean function has four inputs A, B, C, D and an output
E. The output E is obtained by ORing the individual terms given in
the right side of the boolean function. That is, by ORing the terms
A, ( B &! C ) and D.
116The first term A , which is the complement of the given input
A, is realized by
A
A
The second term is (B .' C) . Here the complement of C is
AND with B. The logic circuit is realized by
The third term, which is the complement of D is realized by
D
D
The output D is realized by ORing the output of the three
terms. Hence the logic circuit of the boolean equation is
117Converting a Logic Circuit to a Boolean Function
As a reversal operation, the realization of the logic circuit can
be expressed as a boolean function. Let us formulate an expression
for the output in terms of the inputs for the given the logic circuit
To solve this, we simply start from left and work towards the
right, identifying and labeling each of the signals that we encounter
until we arrive at the expression for the output. The labeling of all the
signals is shown in the figure below. Let us label the input signals as
A, B, C and the output as D.
Hence the boolean function corresponding to the logic circuit can
be written as
D = A +'. B + B -*- C
118Converting a Truth Table to a Boolean Function
There are many ways to do this conversion. A simplest way is
to write the boolean function as an OR of minterms. A minterm is
simply the ANDing of all variables, and assigning bars (NOT) to
variables whose values are 0.
For example, assuming the inputs to a 4-variable boolean
function as A, B, C, and D the minterm corresponding to the input
1010 is : A (%. B ('+ C *(* D. Notice that this minterm is simply the AND
of all four variables, with B and D complemented. The reason that B
and D are complemented is because for this input, B = D = 0. As
another example, for the input 1110, only D = 0, and so the
corresponding minterm is A $*, B "(( C $," D.
For example let us write a boolean function for the following
truth table
A
0
0
0
0
1
1
1
1
Input
B
0
0
1
1
0
0
1
1
C
0
1
0
1
0
1
0
1
Output
D
1
0
1
0
1
0
1
0
To do this problem, we first circle all of the rows in the truth
table which have an output D = 1. Then for each cirlced row, we
write the corresponding minterm. This is illustrated in the table below.
119Input
Output
A B C D Minterms
0 0 0 1 A ./+ B +() C
0 0 1 0 0 1 0 1 0 1 1 0 1 0 0 1 1 0 1 0 1 1 0 1 1 1 1 0
A #*( B !'" C
A -.- B $&+ C
A .'# B (*$ C
Finally, the boolean expression for D is obtained by ORing all
of the minterms as follows:
D = ( A ,+ B +$ C ) + ( A &' B ,$ C ) + ( A .. B /- C ) + ( A (" B '' C )
Design of Logic Circuit
There are many steps in designing a logic circuit. First, the
problem is stated (in words). Second, from the word description, the
inputs and outputs are identified, and a block diagram is drawn. Third,
a truth table is formulated which shows the output of the system for
every possible input. Fourth, the truth table is converted to a boolean
function. Fifth, the boolean function is converted to a logic circuit
diagram. Finally, the logic circuit is built and tested.
Let us consider the design aspects of a 2-input /single output
system which operates as follows: The output is 1 if and only if
precisely one of the inputs is 1; otherwise, the output is 0.
120Step 1: Statement of the problem . Given above.
Step 2: Identify inputs and outputs. It is clear from the statement
of the problem that we need two inputs, say A and B, and one output,
say C. A block diagram for this system is
A
C
B
Step 3: Formulate truth table. The truth table for this problem is
given below. Notice that the output is 1 if only one of the inputs is
1. otherwise the output is )%/0'*,.
Output
Input
A
0
0
1
1
B
C
0
0
1
1
0
Input 1
1 A
0
B
0
0
Output
C
Minterm
0
Step 4: Convert the truth table to a 0 boolean 1 function.
1 Identify A B
the minterms for the rows in the truth table which have an
1
0
1
A B
output "''1/-)
1
1
0
By ORing the minterms, we obtain the boolean function corresponding to
the truth table as
D = ( A /'$ B ) + ( A #). B )
121Step 5: Realization of the Boolean function into a Logic Circuit
Diagram.
The logic circuit diagram corresponding to this boolean func-
tion is given below.
A
B
B
-.,
D = A *)* B + A (/' B
A
B
'(%
4.3 Half Adder
The circuit that performs addition within the Arithmetic and
Logic Unit of the CPU are called adders. A unit that adds two binary
digits is called a half adder and the one that adds together three
binary digits is called a full adder.
A half adder sums two binary digits to give a sum and a carry.
This simple addition consists of four possible operations.
0 + 0 = 0
0 + 1 = 1
1 + 0 = 1
1 + 1 = 10
The first three operations produce a single digit sum, while
the fourth one produces two digit sum. The higher significant bit in
this operation is called a carry. So the carry of the first three operations
are -")0,/*, where the fourth one produces a carry /!!1&'-.
122The boolean realization of binary addition is shown in the truth table.
Here A and B are inputs to give a sum S and a carry C.
Input
A
0
0
1
1
Sum
B S
0
1
0
1 0
1
1
0
0
Minterms
Of S
Carry
C
-
A.B
A.B
0
0
0
0 1
Minterms
of C
A.B
The boolean functions corresponding to the sum and carry are
S = A . B + A . B
C = A . B
Which can be realized using logic circuit as,
Fig. 4.19 Logic Circuit of Half Adder
123which is further simplified as
In a half adder, an AND gate is added in parallel to the XOR
gate to generate the carry and sum respectively. The &&+sum)/+ column
of the truth table represents the output of the XOR gate and the
'-!carry$'* column represents the output of the AND gate.
4.4 Full Adder
A half adder logic circuit is a very important component of
computing systems. As this circuit cannot accept a carry bit from a
previous addition, it is not enough to fully peform additions for binary
number greater than 1. In order to achieve this a full adder is required.
A full adder sums three input bits. It consists of three inputs
and two outputs. Two of the inputs represent the two significant bits
to be added and the third one represents the carry from the previous
significant position.
Here A, B referred as the inputs, C1 as carry input from the previous
stage, C2 as carry output and S as sum.
124Input
A B
C 1 C 2 Output
S
0
0
0
0
1
1
1
1 0
0
0
1
0
1
1
1 0
1
1
0
1
0
0
1
0
0
1
1
0
0
1
1
0
1
0
1
0
1
0
1
Table 4.12 Truth Table for Full Adder
The carry bit C 2 is 1 if both A and B are 1, or exactly one of A
and B is 1 and the input carry, C 1 is 1. The sum bit S is 1 if there exist
odd number of %&!1's of the three inputs. S is the XOR of the three
inputs. Hence, the full adder can be realized as shown below.
By ORing the minterms of the full adder truth table, the sum
and carry can be written as
S = A B C 1 + A B C 1 + A B C 1 + A B C 1
C 2 = A B C 1 + A B C 1 + A B C 1 + A B C 1
Consider
(A$-) B) ("" C 1 =
( A B + A B ) )&! C 1
= ( A B + A B ) C 1 + ( A B + A B ) C 1
= ( (A B) (A B) ) C 1 + ( A B + A B ) C 1
= ( (A + B) (A + B) ) C 1 + ( A B + A B ) C 1
125Also
Hence
To realize the full adder we need two 2-input XOR, two 2-
input AND gates and a 2-input OR gate.
Hence the full adder can be realized as.
C 2
Fig. 4.20 Logic Circuit of Full Adder
126Notice that the full adder can be constructed from two half
adders and an OR gate.
If the logic circuit outputs are based on the inputs presented
at that time, then they are called combinational circuit. The half adder
and full adder circuits are the examples for the combinational circuits.
On the other hand, if the logic circuit outputs are based on, not only
the inputs presented at that time, but also the previous state output,
then they are called sequential circuits.
There are two main types of sequential circuits. A synchronous
sequential circuit is a system whose output can be defined from its
inputs at discrete instant of time. The output of the asynchronous
sequential circuit depends upon the order in which its input signals
change at any instance of time. The flip-flop circuit is an example of
sequential circuit.
4.5 The Flip-Flop
A flip flop is a circuit which is capable of remembering the
value which is given as input. Hence it can be used as a basic memory
element in a memory device. These circuits are capable of storing
one bit of information.
Basic flip-flops
A flip-flop circuit can be constructed using either two NOR
gates or two NAND gates.
A common example of a circuit employing sequential logic is
the flip-flop, also called a bi-stable gate. A simple flip-flop has two
stable states. The flip-flop maintains its states indefinitely until an
input pulse called a trigger is received. If a trigger is received, the
flip-flop outputs change their states according to defined rules, and
remain in those states until another trigger is received.
127Flip #%! Flop Circuit using NOR Gates
By cross-coupling two NOR gates, the basic operation of a
flip-flop could be demonstrated. In this circuit the outputs are fed
back again to inputs.
S
Q
Q
R
Fig. 4.21 Flip Flop Circuit using NOR Gates
The flip-flop circuit has two outputs, one for the normal value Q
and another for the complement value Q. It also has two inputs S (set)
and R (reset). Here, the previous output states are fed back to determine
the current state of the output.
The NOR basic flip-flop circuit operates with inputs normally at
++.0((, unless the state of the flip-flop has to be changed.
As a starting point, we assume S = 1 and R = 0. This makes
Q = 0. This Q = 0 is again given along with R = 0 to make Q = 1.
ie. when S = 1 and R = 0 make Q = 1 and Q = 0.
When the input S returns to +"+0&/(, the output remains the same,
because the output Q remain as .#.1(/% and Q as /#)0("".
ie. when S = 0 and R = 0 make Q = 1 and Q = 0 after S = 1 and
R = 0.
128In a similar manner the reset input changes the output Q = 0 and
Q = 1.
We assume S = 0 and R = 1. This make Q = 0. This Q = 0 is
again given along with S = 0 to make Q = 1.
ie. when S = 0 and R = 1 make Q = 0 and Q = 1.
When the reset input returns to 0, the outputs do not change,
because the output Q remains as )"'0!,, and Q as ('.1'&&.
ie. when S = 0 and R = 0 make Q = 0 and Q = 1 after S = 0 and
R = 1.
This can be tabulated as
S R Q Q
1 0 1 0
0 0 1 0
0 1 0 1
0 0 0 1
(after S =1 and R = 0)
(after S =0 and R = 1)
When #!.1-.. is applied to both S and R, the outputs Q and Q
become 0. These facts violate the output Q and Q are the
complements of each other. In normal operations this condition must
be avoided.
Thus a basic flip-flop has two useful states. When Q = 1 and
Q = 0, it is called as set state. When Q = 0 and Q = 1, it is called as
reset state.
129Flip -,! Flop Circuit using NAND Gates
In a similar manner one can realize the basic flip-flop by cross
coupling two NAND gates.
S
Q
Q
R
Fig. 4.22 Flip Flop Circuit using NAND Gates
The corresponding truth table is given as
S R Q Q
1 0 0 1
1 1 0 1
0 1 1 0
1 1 1 0
(after S =1 and R = 0)
(after S =0 and R = 1)
The NAND basic flip-flop circuit operates with inputs normally
at ++'1'*! unless the state of the flip-flop has to be changed. A momentary
'**0)*+ to the input S gives Q = 1 and Q = 0. This makes the flip-flop to
set state. After the input S returns to 1, a momentary /+.0#*% to the input
R gives Q = 0 and Q = 1. This makes the flip-flop to reset state.
When both the inputs become 0, ie., S = 0 and R = 0, both
the outputs become 1. This condition must be avoided in the normal
operation.
130There are several kinds of flip-flop circuits, with designators
such as D, T, J-K, and R-S. Flip-flop circuits are interconnected to
form the logic gates that comprise digital integrated circuits (ICs)
such as memory chips and microprocessors.
4.6
Electronic Workbench
4.6.1 Introduction
Electronic workbench is a simulation tool for electronic circuits.
It allows to design and analyze circuits without using actual
instruments. The workbench's click-and-drag operation make editing
a circuit fast and easy. It is a windows compatible tool and follows
the normal conventions of windows. The completed circuit can be
simulated within the workbench by the use of simulated test and
measurement equipment which are wired into the circuit.
The circuit diagrams and the output of the simulated circuits
can be printed or exported to other tools such as word processors
for inclusion in other documents. The electronic workbench can be
used for analogue, digital or mixed mode circuits. MultiSim is a
electronic workbench which is used for design and analysis of circuits.
It offers a single, easy-to-use graphical interface for the design needs.
It also provides the advanced functionality you need to design from
specifications.
4.6.2 Objectives and Expectations
(!
#.
*#
4.6.3
Even though the Multisim is designed with much functionality, we
use the tool to help us get familiar with the basic digital features.
To learn how to build and test some simple digital logic gates using
Multisim.
To know how to build and simulate simple combinational logic
circuits using the logic converter.
Building a Simple Digital logic Gate
1. Start MultiSim from the Programs group in the Start menu. The
main screen is as shown in the fig. 4.23
131-
Fig. 4.23 MultiSim Main Screen
2. Assign a name to your file by following the steps given below.
Choose File > Save As, under the File Name box to save the
new workspace as circuit1. Press OK. The filename will then
appear in the lower left hand corner of the workspace as shown in
the fig. 4.24.
132Fig. 4.24 File Menu
3. Click on the Place menu, then click on the Component,which
shows the list of components in the component library. A ghost im-
age of the component appears on the circuit window showing exactly
where the component is placed. One can use the appropriate data-
base, group and component drop-down list to select the desired com-
ponent.
133Fig. 4.25 Place Menu
Fig. 4.26 Component Window
1344. Click on any one of the logic gates available in the ,/(select a
component*,$ dialog box and drag it to place it in the workspace.
Double click on the logic gate to change the properties of it
and label the gate.
To get help, just click on the logic gate using the left mouse
button and choose help.
U1
AND2
Fig. 4.27 Selecting a Component
4.6.4 Building a Simple Combinational Logic Circuit
Here the general steps to build a circuit by dragging the
components like gates, wires, etc. are discussed.
135Placing Components
Components like logic gates are placed in the workspace by
i)
ii)
Selecting component from Place menu.
Right clicking on the workspace and select place components
or Ctrl+W.
Selecting Components
Click on the component to highlight it .Once highlighted the
options in the #..Circuit !&! menu will apply to that component.
To select several components drag a box around them. All
selected components will be highlighted.
Copying Components
To copy a component select it and then choose ",*Copy#%+ from
the %,-Edit$.( menu (or <cntrl> C). Then select paste (or <cntrl> V).
Copies of the component will appear in the middle of the drawing
area. They can then be moved to their required positions.
Modifying components
i) Select the components and then choose the available options
from the /'/CIRCUIT",* menu.
ii) Double click on the component. A window will be opened
which gives the parameters for the component which can be
customized. Change the values as required and then click on
,/!Accept$",.
Moving Components
To move components on the drawing select it and drag it to a
new position and drop it. Any wires connected to it will be dragged
with it.
136Deleting Components
Select components and then select /+*Delete%+' or %$+Cut&-' from the
"##EDIT.-) menu or press delete. You will be asked to confirm the delete.
Building the circuit
Placing interconnecting wires
Click on the end of the leg of the component. Drag the wire
directly to the leg of the next component and then drop it. The wire
will then route itself neatly.
Printing the Circuit
Select -,'Print-&# from the File Menu and then select the item(s)
to print from the dialogue box that is opened.
Saving the Circuit
To save a new circuit or rename an old one , select '")Save As.,"
from the File Menu and complete the details in the dialogue box that
opens. To save an existing circuit select *+,Save+!/ from the *,*File%#( Menu
.
Opening an Existing Circuit
Select ++"Open&!. from the File Menu and then enter the filename
in the dialogue box that opens.
Consider a logical circuit by connecting two NOT gates with
an AND gate. Place the NOT gate and AND gate on the workspace
by selecting the respective components from the .."select a component,+'
dialog box. Copy NOT gate. Drag the leg of the components and
wire them as shown in fig. 4.28.
137Fig. 4.28 Construction of a Logic Circuit
4.6.5 The Logic Converter
MultiSim provides a tool called the logic converter from the
instrument bin. With the logic converter, one can carry out several
conversions of a logic circuit representation:
1.
2.
3.
4.
5.
6.
Logic Circuit
Truth Table
Truth Table
Boolean Expression
Boolean Expression
Boolean Expression
&)
/.
',
!(
.$
#&
Truth Table
Boolean Expression
Simplified Boolean Expression
Truth Table
Logic Circuit
NAND-gate only logic circuit
One can connect it to a digital circuit to derive the truth table or
Boolean expression the circuit represents. One can also use it to
produce a logic circuit from a truth table or boolean expression.
To open the logic converter, click on the simulate menu,
instruments and then logic converter as shown in fig. 4.29.
138Fig. 4.29 Logic Convertor
The fig. 4.30 shows the logic converter that you have placed
in the workspace. The little circles in the bottom are the inputs and
output terminals. There are 8 input terminals and 1 output terminal
available for use. That means if you want to use the logic converter
to carry out the conversions, an individual circuit is limited to 8 inputs
and 1 output.
Fig. 4.30 Logic Convertor on the Workspace
To use the logic converter, double-click on the logic
converter icon. Your workspace should now look like the fig. 4.31.
1398 Input Terminals
(A to H)
1 Output Terminal
Boolean expression goes here
Fig. 4.31 View of Logic Convertor
Notice that the 8 input terminals are labeled as A to H and
the output terminal is labeled as #$#Out%(,.
140The converting options available in the logic converter are as
follows:
Descriptions:
$+. Convert Logic Circuit to Truth Table
%(. Convert Truth Table to Boolean
Expression
#-$ Convert Truth Table to Simplified
Boolean Expression
$). Convert Boolean Expression to
Truth Table
#.. Convert Boolean Expression to
Logic Circuit
"$% Convert Boolean Expression to
NAND-gate only logic circuit
4.6.6
Converting a logic circuit To a truth table
1. Construct the circuit by drawing the components (logic circuit).
1412. Connect the inputs of your circuit to the input terminals on the
logic converter and single output of the circuit to the output terminal
on the logic converter as shown below.
1423. Click the logic circuit %$$ truth table button. You should get the
truth table for the logic circuit in the logic converter.
4.6.7
Converting a Truth Table to a Boolean Expression
Once you have a truth table, the logic converter can transform
it into a boolean function in the form of an algebraic expression.
143To create a Truth table :
$/
.)
""
+-
Drag a logic converter to the workspace and open it.
Click the number of inputs you want, from A to H at the top of
the logic converter.
The inputs are present in standard binary count format. In
this case select A, B and C.
The values in the output column are set to ".!?$,%. Click the output
values once to change as ++.0(&* and twice to change as (%$1&*%.
Click the )/*Truth Table to Boolean Expression%*% button.
144The boolean expression will be displayed at the bottom of
the logic converter. In this case:-
A'B'C$(- + A'BC,*! + A'BC + AB'C
Note the primes, representing inversion. A*+. means NOT A,
or A.
4.6.8 Converting a Truth Table to a Simplified Boolean
Expression
Some expressions can be recalculated in a simpler form. To try to
simplify the expression, click the ".+simplify.!- button
using the previous truth table. In this case, the expression can be
simplified to A'C$/# + A'B +AB'C
1454.6.9
Converting a Boolean Expression to Truth Table
Once you have a boolean expression, the logic converter can
transform it into a truth table. Click the %'.Boolean Expression to Truth
Table($) button
after entering the Boolean
expression A-$/ + BC + B./) in the logic converter.
The truth table will be displayed in the logic converter as shown
below.
1464.6.10
Converting a Boolean Expression to a Circuit
To do this, enter the boolean expression, A'B+B'C+ABC and
click the ##"Boolean to Circuit''+ button
The resulting circuit will appear in the workspace.
4.6.11 Converting Boolean Expression to NAND-gate only logic
circuit
To realize the logic circuit using NAND-gates for the same
boolean expression A'B+B'C+ABC, click
The resulting circuit will appear on the workspace.
1474.6.12
Creating a Circuit from a Truth Table
This is the most useful conversion for a circuit designer.
Normally, you will have translated the client's specification into a
truth table, and have then to produce a logic gate circuit to do the
job.This requires two conversions using the logic converter. We will
practice using a different problem.
'(-
&)#
Create a truth table.
Click the !'#simplify%+) button to convert the truth table to the
simplest Boolean expression (A'BC'// + AB'C)
.
148&/*
Click the &$-Boolean to Circuit%"- button
.
The resulting circuit will appear, selected, on the workspace.
If you want to move it, point to one component and drag the circuit.
149The following table summarizes all possible scenarios that one can
encounter:
From
Truth Table
To
Boolean
Expressions
Options
Simplified Boolean
Expressions
Logic Circuit
NAND-gate
logic circuit
Boolean
Expressions
only
Truth Table
Logic Circuit
NAND-gate only
logic circuit
Simplified Boolean
Expressions
Logic Circuit
Truth Table
Boolean
Expressions
Simplified Boolean
Expressions
T able 4.13 : Quick Guide to convert a Digital Circuit using the
Logic Converter
150Summary
-+' A logic gate is an elementary building block of a digital circuit.
&"- There are three fundamental logic gates namely, AND, OR
and NOT.
(), we have other logic gates like NAND, NOR, XOR and XNOR.
%.& NAND and NOR gates are called the universal gates.
.&$ The circuit that performs addition within the Arithmetic and
Logic Unit of the CPU are called adders.
("& A unit that adds two binary digits is called a half adder.
!(- one that adds together three binary digits is called a full adder.
'%, A flip flop is a circuit which is capable of remembering the
value which is given as input.
!"/ Electronic workbench is a simulation tool for electronic circuits.
&&( MultiSim is a electronic workbench which is used for design
and analysis of circuits.
151Exercises
I. Fill in the blanks
1. In AND gate the output is __________ when both the inputs
are *+#true!($.
2. In OR gate the output is __________if both the inputs are&!$false",).
3. A__________ is an elementary building block of a digital circuit.
4. The NAND gate operates as an AND gate followed by a
__________gate.
5. The __________gate circuit is an OR gate followed by an
inverter.
6. __________and __________gates are called universal gates.
7. __________, __________and __________gates are called the
fundamental gates.
8. A unit that adds two binary digits is called a __________
9. A full adder can be constructed from two __________and a
__________gate.
10. A simple flip flop has __________stable states.
II. State whether the following are True or False
1.
2.
3.
4.
5.
6.
Logic gate has two or more outputs.
Logic circuits have two or more outputs.
AND is an universal gate.
XOR is a fundamental gate.
NAND gate can be used to realize OR gate.
NOR gate can be used to realize OR gate.
7. Full adder can be realized using two half adders and an OR gate.
8. XOR gate is used to build half adder.
9. XOR gate circuit is an OR gate following by an inventor
10. Flip-flop is used as a storage.
III. Answer in one or two lines:
1.
2.
3.
4.
What is a logic gate?
List the fundamental logical gates?
Why NAND and NOR gates are called as universal gates?
How AND gate can be realized using NOR gate?
1525.
6.
7.
8.
9.
How OR gate can be realized using NAND gate?
Give the truth table of XOR gates for two inputs.
What is a half adder?
What is a full adder?
What is a combinational circuit?
10. What is a sequential circuit?
IV. Answer the following
1. Determine the truth table for the following Boolean functions
E = A + ( B . C ) + D
2. Convert the following truth tables to a Boolean equations.
3. Convert the following logic circuit to a boolean equation.
1534. Realize the boolean function to a logic circuit
E = A B + B C + A B C
5. Explain the steps involved in designing a logic circuit.
6. What are the different types of logic gates? Explain with the help
of truth tables and give an example for each gate.
Project
1. Using the logic converter, test the basic logic gates by constructing
their truth table.
2. Using the logic converter, build and test the following logic circuits
and record your simulation results in a truth table.
3. Build a logic circuit for the boolean function A'C.+&+A'C+AC#*'+AC
using the logic converter.
4. Build a logic circuit for the following truth table and bring out its
equivalent Boolean expression using logic converter. Also
simplify the Boolean expression.
A
0
0
0
0
1
1
1
1
Input
B
0
0
1
1
0
0
1
1
C
0
1
0
1
0
1
0
1
154
Output
D
0
1
1
0
0
1
0
1Chapter 5
OPERATING SYSTEM
5.1 Introduction
When a computer is devoid of any software it is just like dead
bodies. The computer software and hardware have been intrinsically linked
with each other. One of them cannot do anything useful by itself without
help from the other. There are two types of software, one is the System
Software and the other is the Application Software. System Software looks
after the functions of the computer. This is just like involuntary actions con-
trolling involuntary muscles such as digestive system of the animal. Sys-
tem software makes efficient use of the computing resources and nor-
mally provides a uniform base for different apllications. It is there to oper-
ate, control and extend the processing capabilities of computers. Applica-
tion software helps the user to do his/her work. This is similar to the volun-
tary actions controling voluntary muscles like hand etc. Moving a hand is a
voluntary action. The Operating System comes under the System Soft-
ware category. The actual work is undertaken only by the hardware. In
order to do useful work on a computer, one has to access the hardware,
but one can access the hardware directly, only in the first generation com-
puters. In the subsequent generations of computers direct access is de-
nied. The architecture of the computers at the machine level is primitive
and very hard to program. What is the reason for the denial of the access?
If the access is not denied, unless the user is hard working, one of the two
alternatives can happen.
1) The user may be forced to conclude that computer is not for him/
her.
2) The user may damage the computer hardware.
This leads us to a natural question. Who will access the computer
hardware directly if the user is denied such permission? The answer is the
Operating System. The Operating system provides so many facilities with
which a user comfortably uses their computers. This resembles the life of
modern man, who cannot tolerate power cut even for five minutes.
155Apart from being complicated, trying to deal with I/O(Input/Output)
opeations can prove truly frustrating. The average user wants to have a
simple high-level abstraction to deal with. If you see an object, a lot of
Impulses are triggned on inside your brain. At the end you are shown an
image of the object. If an average person is asked to explain the activities
that happen inside the brain, he/she will not dare to even open his eyes.
The brain provides a convenient highly sophisticated abstraction. It merely
provides the image of an object without letting people know about the
activities that happen inside the brain. In this case eye is an interface
between the object and the part of the brain that processes visual data. In
a similar fashion the Operating System hides from a person know the com-
plexity of the hardware and allows the user to use the name of the files for
reading and writing. The Operating System adds extended capabilities to
a machine with which it is easier to program than the underlying hardware.
The Operating System manages the resource. Modern computers are highly
complex machines. They get more complex day by day. So it is very diffi-
cult to manage such a complex system but the Operating System man-
ages the complex system in an efficient way. It provides special routines
called device drivers to support the specific behaviour of individual device.
In this view the primary task of the Operating System is to keep track of
who is using which resource, to grant resource requests, to account for
usage and to mediate conflicting requests from different programs and
users. The Operating System is to provide an orderly and controlled allo-
cation of resources among the various programs competing for them. The
Operating System is the intermediary between the user and computer
hardware. When the Operating System was first introduced, the primary
goal of the Operating System was mainly to optimize resources. The sec-
ondary goal was to make the computer environment, user-friendly. Now
providing the user-friendly environment is the main aim of the operating
system.
The Operating System acts as the manager of resources such as
CPU time, memory space, file storage, I/O devices. Since there may be
many conflicting requests, Operating System allocates resources in an
optimal manner. That is, Operating System allocates resources in such a
manner so as to achieve the maximum best possible result.
156The Operating System also provides the means for the proper use
of hardware, software and data in the operation of the computer system.
The Operating System is like a supervisor in a company providing an ex-
cellent environment in which the other people can perform useful work.
Operating System assumes yet another responsibility, that of serv-
ing as a control program. A control program controls the execution of user
programs to prevent errors and improper use of the computer. It is espe-
cially concerned with the operation and control I/O devices.
It is hard to define Operating System. There are several definitions
for Operating System. One of the definitions is that Operating System is
one program running at all times on the computer. The another, somewhat
more widely accepted definition is that an Operating System is an inter-
face between the user and hardware.
The Operating System's goals are to:
1)
2)
3)
execute user programs in a user-friendly atmosphere.
make the computer system convenient to use.
optimize computer hardware.
Any Operating system should be easy to use. Now-a-days people
are hard pressed for time, so they cannot undergo any training for making
use of the Operating System. The idea of using facilities available in the
Operating System should be intuitive. The Operating System should allow
developing application programs easier. Otherwise people cannot con-
centrate on the application development; instead, they have to spend lot
of time in concentrating on the peculiarities of the Operating System. The
Operating System should be portable. That is, the Operating System should
run in almost all hardware platforms.
If there is a new version of the Operating System, it should not
confuse the people who used the earlier version and also it should run
software that ran successfully in earlier versions. The Operating System
should provide data security; it should not allow one user to write on the
157file/files of the other user and thus spoiling the contents of the owner of the
file/files.
The Operating System should provide data confidentiality. That is,
the Operating System should not allow unauthorised people to access the
data of the other people. If this is possible then the scientific and techno-
logical institutions and banks will have a nightmarish existence. The ven-
dor who provided the Operating System should undertake the service fa-
cility also. The vendor should be accessed easily. Otherwise that Operat-
ing System will attain notoriety.
The Operating System should work in a network as well as distrib-
uted environment. The Operating System should make system adminis-
tration more efficient.
The Operating system should provide the help facility. There are
people who do not like to get help from the other people; this will prick their
self-esteem. Instead they may try to get help from the system. The help
facility should mainly concentrate on people like them. There should be
different levels of help to satisfy the needs of different levels of users.
According to John Von Neumann architecture application, program
and data should reside in main memory. In those days programs dealt
mainly with scientific problems. For solving these types of problems, soft-
ware libraries are created. These libraries complicated the normal user of
that time. Therefore, the computer operator job is created. But this pre-
vented the programmer to remove the errors (debug) immediately. Pro-
grammers had to wait for nearly six hours for debugging their programs.
A brief History of the Operating System.
In the beginning, programs were run one at a time. In order to use
CPU more efficiently, jobs of similar nature were grouped and made to run
in batches. But after program execution, the computer operator manually
restarted the next program. To avoid the delay due to manual operation,
Automatic Job Sequencing mechanism was introduced.
158This is called Resident Monitor and this may be the first elementary
Operating System. If scientific applications had been used in a computer, the
CPU (Central Processing Unit) was busy with the program, but if business
problems had been handled, I/O system was busy and the CPU was kept
idle.
In order to make the CPU busy, the I/O operations were done in an
inexpensive computer, the contents of card reader was transferred in a mag-
netic tape and which in turn was placed in the computer that performed the
business operation. In those days data were stored in cards, called punched
cards. Another attempt was made to keep the CPU busy for most of the time.
A buffer (Refer chapter 6) was (and still is) allowed to store Input, when the
CPU needed the data, buffer sent the data immediately. The next input might
be ready in the buffer before the CPU processed the earlier data. When the
processing was completed, the CPU sent the output to the buffer. When the
data were ready, an interrupt mechanism interrupted the CPU. The CPU
having taken the necessary actions and resumed its original work.
At the same time, Direct Memory Access (DMA) mechanism was also
created, which allowed transferring data to and from memory without the in-
tervention of the CPU. Spooling (is a way of dealing with dedicated I/O de-
vices in the multiprogramming system.) allowed (and still allows) reading a
set of jobs in disk system from the card reader. When printing work had to be
undertaken, the print image was copied into the disk system and when condi-
tions were favourable the print image was sent to the printer.
Spooling is superior to the buffer, because in spooling I/O operations
can be overlapped with the working of other jobs but that is not possible with
the buffer. While executing one job, the OS, reads next job from card reader
into a storage area on the disk and outputs printout of previous job from disk
to the printer. Spooling allowed the CPU to choose a particular job for execu-
tion leading to the concept called the Job Scheduling. The job scheduling
led to the concept known as the Multiprogramming. In multiprogramming,
memory is divided into many partitions. Multiprogramming allows many pro-
grammers to load their programs in the different partitions. Each programmer
is made to believe his/her program is the only program running. Multipro-
gramming was followed by Time-sharing concept. Here the CPU allocated
a fixed time for each program. In the next cycle, the program that had been
considered earlier was taken once again. This process continued until all
the programs were executed.
1595.2
Major Features of the Operating System
5.2.1
Types
As per the number of users, there are two types of the Operating
Systems. They are
1.Single user Operating System.
2. Multi-user Operating System.
Single user Operating System : At a time, only one user can operate the
system. MS Disk Operating System is an example of single user Operat-
ing System.
Multi-user Operating System : More than one user can operate the same
system simultaneously. The multi-user Operating System is based on the
concept of time-sharing. Unix is an example of multi-user Operating Sys-
tem.
5.2.2 Input/Output
Application software does not allocate or de-allocate the stor-
age area on the disk for different files belonging to various users. If the
application software is allowed to allocate or de-allocate, two or more
users may try to write on the same sector of disk, resulting in confu-
sion. Even a single user may try to write in some sector, which may
contain valuable information. In order to avoid such an awkward situa-
tion, only the Operating System is empowered to make such an allo-
cation or de-allocation. This arrangement safeguards the loss of data.
Such safeguading of data is called Data Security.
From the above discussion, one may come to the conclusion
that the Operating System alone should be empowered to instruct the
hardware to write data from memory onto a Pre-specified location on
the disk. In fact Input/Output operation code of the Operating System
constitute a sizeable code of the Operating System.
The application program is not allowed to read data from the
disk. Otherwise any user can access any type of sensitive information.
There may not be any secrecy.
160For example, banks will have precarious existence. An application
program can do all the operations with the exception of input/output
operations. When the application program is translated into the ma-
chine code, the request for reading or writing will not be translated
into the machine code, instead a system call is given. (A set of ex-
tended instructions providing an interface between the Operating
System and the user programs, is called a System Call.) The Oper-
ating System will then generate suitable input/output command to
the hardware to replace this system call. You cannot fool the system
by writing the I/O code in machine language. User code will not be
entertained for input/output at any circumstance. This arrangement
not only helps in protecting the data integrity, but also, it saves the
user from writing a lot of code to execute I/O operations. Thus it
saves from reinventing the wheel. It is enough, if the programmer
concentrated in logical behaviour of the program. The Operating Sys-
tem does the spadework for the arrival of application program and the
Operating System which is in the back ground, when needed comes
into forefront and does its work gracefully after that it relegates itself to
the background.
5.2.3
Printer
Ideally we can expect computers to create truly paperless soci-
ety. Appropriate n etworking and Infrastructure must be provided for this.
As of today computers consume a lot of papers. Usage of printers is ram-
pant. How does the Operating System help for printing? The Operating
System makes the programmer's life much easier as far as the printing
work is concerned. Even a small document takes a few minutes to com-
plete the printing work. Now for printing a document, the Operating Sys-
tem first makes a temporary copy of the file and then hands over the con-
trol back to the application. Spooling is a way of dealing with dedicated I/O
devices in a multiprogramming system. To print a file, a process first gen-
erates the entire file to be printed and puts in the spooling directory. (Di-
rectory is a container for storing files on other sub-directories).
Then the special process having permission to use printer's
special file is allowed to print the files in the directory. If two users print
two documents, in the absence of overlapping of the
two documents.
161This is similar to overlapping of the signals from two radio
stations. This unwanted behaviour is completely eliminated by spool-
ing. Each document's print image will be written on to the disk at two
different locations of the spool file. While printing, the printer is not
allowed to print the original document; instead it is allowed to print
the contents of spooler program.
Multiprocessor systems have more than one CPU in close communi-
cation with the others. In a tightly coupled system the processors
share memory and a clock; communication usually takes place
through the shared memory.
5.3 Most Desirable characters of the Operating System
5.3.1 User Interface
The Operating System should concentrate on the user inter-
face. The only way that you can see this world is through your eyes.
Similarly the only way that you can interact with a computer is through
the user interface. People may be attracted to the computer in the be-
ginning. If the interface is not user-friendly, only persistent people may
continue with their work with the computer. The other people slowly
move away from the computer with the intention of not returning to the
computer forever. One can judge, from the immense popularity of the
GUI (Graphical User Interface) based interface, the importance of well
designed well thought interface. The GUI is window based. The vivid
colours attract children. Novices are attracted by the help pop up mes-
sages. Icons give iterative usage of the particular application.
Now Linux is also available as windows based Operating
System. The user interface of the Operating System should be ap-
pealing to the senses. The human brain is good in pattern recogni-
tion. Human brain learns through association. All these factors should
be taken into account, when user interface is improved. In addition
to the above, the following points should also be considered when
User Interface is designed.
1621) Interface should be designed in such a manner as to master the
interface. As already stated, people are hard pressed for time.
2) The speed of response should play a vital role in designing the
user interface. The speed of response is nothing but the time taken
to execute a particular task.
3) The user interface should reduce the number of errors committed
by the user. With little practice, the user should be in a position to
avoid errors.
4) The user interface should be pleasing to the senses. Vivid colours,
enchanting music may achieve this.
5) The user interface should enable the people to retain this expertise
for a longer time.
6) The ultimate aim of any product is to satisfy the customer. The
user interface should also satisfy the customer.
Interface developers should also take the following consid-
erations into account. Interfaces mainly should satisfy the end
users. The other users such as programmers may work even in
an unfriendly environment. The interface should not heavily
burden the memory of users. Menus, minimal typing work will be
an added advantage of the Operating System.
5.3.2 Memory Management
The Operating System should provide memory management
techniques also. Any error in the user program should not be allowed
to spoil the entire memory. So the Operating System divides the main
memory into user memory and reserved memory. If some errors creep
into the user program then only user memory may be affected how-
ever the reserved memory is always in an unaffected condition.
User memory is divided into many partitions to accommodate
various jobs. Therefore the number of jobs accommodated cannot ex-
ceed the number of partitions. Naturally the size of the user program
should be less than that of the available main memory. This is like
cutting the feet to the size of the shoe (if the size of the shoe is
inadequate).the Operating System provides virtual (imaginary) memory
to include the entire program.
163Operating System should manage the devices also. It is not un-
common for several processes to run simultaneously. In order to achieve
successful operation, the processes should effectively communicate with
each other. This interprocess communication is made possible by the
Operating System.
5.3.3 Process management
Process management undertakes the allocation of processors to
one program. The Operating System controls the jobs submitted to the
system (CPU). Several algorithms are used to allocate the job to the pro-
cessor. Algorithm is a step-by-step method to solve a given problem.
1.FIFO.
2.SJF
3.Round Robin.
4.Based on Priority.
FIFO (First In First Out)
This algorithm is based on queuing. Suppose you are stand-
ing in a queue to get your notebook corrected from your teacher.
The student who stands first in the queue gets his/her notebook
corrected first and leaves the queue. Then the next student in the
queue gets it corrected and so on. This is the basic methodology of
the FIFO algorithm.
Now, let us deal with this FIFO a little more technically. The
process (A process is basically a program in execution) that enters
the queue first is executed first by the CPU, then the next and then
the next and so on. The processes are executed in the order in
which they enter the queue.
164SJF
(Shortest Job First:)
This algorithm is based on the size of the job.
Take two jobs A and B.
A = 5 kilo bytes
B = 8 kilo bytes
Kilo literally means 1000 but here kilo means 1024. A byte
consists of eight bits. A bit can store either TRUE (1) or
FALSE (0).
First the job A will be assigned processor time after which B gets
its turn.
Round Robin
Jobs are assigned processor time in a circular method. For ex-
ample take three jobs A, B, C. First the job A is assigned to CPU then job
B and after B job C and then again A,B and C and so on.
Based On Priority
In this method each job is assigned a Priority. The higher Priority
job is awarded favorable treatment. Take two jobs A and B. Let the priority
of A be 5 and priority B be 7.
Job B is assigned to the processor before job A.
The allocation of processors by process management is also known
as the CPU Scheduling. The objectives of the CPU Scheduling should be
to maximise
(1) The CPU utilisation.
(2) The number of jobs done in a unit time (throughput) and to minimise
the time taken.
before the execution of the job and to run the job.
165Let us consider e-mail, which allows to :-
(1) represent the information electrically
(2) carry information from source to destination
(3) manage the flow of such information. The telecommunication
industry provides all the above facilities. The information that may
be sent by network may be voice, data, video, fax etc. Web camera
unites the parents and their children who are away from each other.
Now the size of LAN has grown. You can see a LAN with more than
1000 computers connected to it. Through telecommunication links,
LAN can access remote computers. The size and complexity of the
network grow day by day. It is not a mean achievement to manage
them. The Operating System shoulders the burden (responsibility)
of managing the nets.
5.3.4 Security Management
The biggest challenge to the
computer industry is to safe-
guarding one's data from unauthorized people. The Operating System
provides three levels of securities to the user. They are
(1) File access level
(2) System level
(3) Network level
In order to access the files created by other people, you should
have the requisite permission. Permissions can either be granted
by the creator of the file or by the administrator of the system.
166System level security is offered by the password in a multi-user
environment. Both windows XP professional and Linux offer the
password facility.
Network security is an elusive one. People from all over the
world try to provide such a security.
All the above levels of security are provided only by the Operating
System.
5.3.5 Fault tolerance
The Operating Systems should be robust. When there is a fault, the
Operating System should not crash, instead the Operating System have
fault tolerance capabilities.
5.3.6 Application Base
Operating System should provide a solid basis for running many
popular applications.
5.3.7 Distributed Operating System
If you want to make use of the Network, you must know the
machine address and the variety of services provided by that machine.
But Distributed Operating System ensures that the entire network
behaves as a single computer. Getting access to the remote resources
is similar to access to local resources. The user's job is executed in an
idle machine and the result is communicated to the user machine. The
user is under the illusion that everything is done only in his/her computer.
In a distributed Operating System a user is not aware of multiplicity of
machines.The future of the Operating System may be Distributed
Operating System since all the computers become a part of one or
other network. But the virus attacks discourage people to get connected
to the net.
From the above one can appreciate the importance of the Operating System.
167Summary
Software is of two types. They are
1. System Software and
2. Application Software.
Operating System is a system Software that comes under System
Software.
Operating System is an intermediary between the user and the hard-
ware.
There are
1.Single user Operating System and
2. Multi-user operating system.
The I/O operations are tedious and they are always maintained by the
Operating system. When Application programs want to access the I/O
capabilities, they merely substitute with the system call.
Direct Memory Access (DMA) mechanism allows transferring data to
and from memory without the intervention of the CPU.
Spooling is superior to buffer. Spooling takes care of the printing work
with the printer.
Multiprogramming gives the illusion that many programs run simulta-
neously.
168The desirable characters of the Operating System are
1
2
3
4
5
6
7
8
9
User Interface
Memory management
Process management
File management
Networking Capabilities management
Security Management
Fault tolerance
Application Base
Distributed Operating System.
Exercises
I. Fill in the blanks
1. The ________,________ can access the hardware directly.
2. Operating System is the ________ between the user and com-
puter hardware.
3 Operating System comes under ________ software.
4 The ________ ,________ is only means by which a user in-
teracts with the computer.
II. State whether the following are True or False
1. The primary goal of Operating System is to mainly optimize
the memory management.
2. There are many types of the Operating Systems.
3. The higher priority jobs get executed faster than those with
lower priorities.
4. In Distributed Operating System, the user should know the
address of the accessed machine.
169III. Answer the following
1.
2.
3.
4.
5
6.
7.
8.
Who will access the computer hardware directly?
Define an OS.
Explain the different roles taken by the OS.
Explain the main functions of the operating system.
Explain the process and memory managements.
Explain the input / output managed by operating system.
Write note on User Interface.
List out advantages of the Distributed Operating System over
the Network Operating System.
9. Name some of the required features of Operating System.
170CHAPTER 6
COMPUTER COMMUNICATIONS
6.1 Introduction
Communication is the desire of man. When human voice
became inadequate, ancient civilizations devised drum codes and
smoke signals to send information to far off distances. These primitive
methods have given way to sending messages through electronic
pulses. A stand-alone computer communicates very efficiently by
connecting it with other computers. Data in a computer is transmitted
to another computer located across continents almost
instantaneously using telephone, microwaves or radio links. The long
distance communication link between a computer and a remote
terminal was set up around 1965. Now networking has become a
very important part of computing activity.
6.2 Network
A large number of computers are interconnected by copper
wire, fiber optic cable, microwave and infrared or through satellite.
A system consisting of connected nodes made to share data,
hardware and software is called a Computer Network.
6.3 Some Important Reasons for Networking
(+ Sharing of resources: Primary goal of a computer network is
to share resources. For example several PCs can be connected
to a single expensive line printer.
', Sharing information: Information on a single computer can
be accessed by other computers in the network. Duplication
of data file on separate PCs can be avoided.
171"+ Communication: When several PCs are connected to each
other, messages can be sent and received. From a remote
location, a mobile salesman can relay important messages to
the central office regarding orders. Relevant databases are
updated and the business commitments are fulfilled.
6.4 Applications of Network
The following are the areas where computer networks are
employed.
Electronic data interchange
Tele-conferencing
Cellular telephone
Cable Television
Financial services, marketing and sales
Reservation of Airlines, trains, Theatres and buses
Telemedicine
ATM
Internet banking
Several educational institutions, businesses and other
organizations have discovered the benefits of computer networks.
Users can share data and programmes. They can co-operate on
projects to maximize the usage of available expertise and talent.
6.5 Benefits of Network

Effective handling of personal communications
Allowing several users to access simultaneously
Important programs and data:
Making it easy for the users to keep all critical data on
shared storage device and safeguard the data.
Allowing people to share costly equipment.
172The computer communication should ensure safe, secure and
reliable data transfer.
Safe
Secure :
Reliable:
The data received is the same as the data sent
The data being transferred cannot be damaged
either will fully or accidentally.
Both the sender and the receiver knows the
status of the data sent. Thus the sender knows
whether the receiver got the correct data or not.
6.6 Types of Network
The following are the general types of networks used today.
Local Area Network (LAN)
Metropolitan Area Network (MAN)
Wide Area Network (WAN)
A network connecting systems and devices inside a single
building or buildings close to each other is called Local Area Network
(LAN) (Fig.6.1). Generally LANs do not use the telephone network.
They are connected either by wire or wireless. Wired connection
may be using twisted pairs, coaxial cables or Fiber Optic cables. In
a wireless LAN, connections may be using infrared or radio waves.
Wireless networks are useful when computers are portable. However,
wireless network communicates slowly than a wired network.
Fig. 6.1 Local Area Network
173The number of Computers in the network is between two
to several hundreds. LAN is generally used to share hardware,
software and data. A computer sharing software package and
hard disk is called a file server or network server.
A Network that spans a geographical area covering a
Metropolitan city is called Metropolitan Area Network (MAN)
A WAN is typically two or more LANs connected together
across a wide geographical area. The individual LANs separated
by large distances may be connected by dedicated links, fiber-
optic cables or satellite links.
6.7 Network Topology
The network topology is the structure or layout of the
communication channels that connects the various computers
on the network. Each computer in the network is called a node.
There are a number of factors that determine the topology
suitable for a given situation. Some of the important consideration
is the type of nodes, the expected performance, type of wiring
(physical link) used and the cost.
Network can be laid out in different ways. The five common
topologies are star, ring, bus, hybrid and FDDI.
Star Network : In a star network all computers and other
communication devices are connected to a central hub. (Fig.6.2)
Such as a file server or host computer usually by a Unshielded
Twisted Pair (UTP) cables.
174Fig. 6.2 Star network
Ring Network: In a ring network computers and other communication
devices are connected in a continuous loop (Fig. 6.3). Electronic data
are passed around the ring in one direction, with each node serving as
a repeater until it reaches the right destination. There is no central
host computer or server.
Fig. 6.3 Ring Network
175Bus Network: In a bus network all communication devices are
connected to a common cable called bus (Fig. 6.4). There is no
central computer or server. The data transmission is bidirectional.
Fig 6.4. Bus Network
Hybrid Network: A hybrid network is a combination of the above
three networks suited to the need.
FDDI Network: A FDDI network (pronounced as fiddy short for
Fiber Distributed Data Interface) is a high-speed network using fiber
optic cable. It is used for high tech purposes such as electronic
images, high-resolution graphics and digital video. The main
disadvantage is its high cost.
6.8 Basic Elements in Networking
All networks require the following three elements
1.
Network services
Network services are provided by numerous combinations of
computer hardware and software. Depending upon the task, network
services require data, input/output resources and processing power
to accomplish their goal.
1762.
Transmission media
Transmission media is the pathway for contacting each
computer with other. Transmission media include cables and wireless
Technologies that allows networked devices to contact each other.
This provides a message delivery path.
3.
Protocols
A protocol can be one rule or a set of rules and standards
that allow different devices to hold conversations.
6.9 Common Network Services
The following common network services are available.
6.9.1 File Services
Those are the primary services offered by the computer
networks. This improves the efficient storage and retrieval of computer
data. The service function includes.
(* File transfer -'/Rapidly move files from place to place
regardless of file size, distance and Local operating system.
*. File storage and data migration !,( Increasing amount of
Computer data has caused the development of several storage
devices. Network applications are well suited to control data
storage activity on different storage systems. Some data
becomes less used after certain time. For example higher
secondary examination result posted on the web becomes less
used after a week. Such data can be moved from one storage
media (say hard disc of the computer) to another, less expensive
media (say an optical disk) is called data migration.
177(% File update synchronization ,-% Network service keeps track of
date and time of intermediate changes of a specific file. Using
this information, it automatically updates all file locations with
the latest version.
'' File archiving !!% All organizations create duplicate copies of
critical data and files in the storage device. This practice is
called file archiving or file backup. In case of original file getting
damaged, Computer Operator uses the Network to retrieve
the duplicate file. File archiving becomes easier and safe when
storage devices are connected in the Network.
6.9.2 Print services
Network application that control manage access to printers
and fax equipments. The print service function includes
#& Provide multiple access (more than one user, use the network)
.-% reduce the number of printers required for the organization.
./ Eliminates distance constraints +*! take a printout at a different
location.
-# Handle simultaneous requests ""! queue print jobs reducing
the computer time.
(, Share specialized equipments-Some printers are designed
for specific use such as high-speed output, large size formals
or colour prints. Specialised equipments may be costlier or
may not be frequently used by the user, when numerous clients
are using the network, printer use is optimized.
'( Network fax service (.! Fax service is integrated in the network.
The computer in the network sends the digital document image
to any location. This reduces the time and paper handling.
1786.9.3 Message services
Message services include storing, accessing and delivering
text, binary, graphic digitized video and audio data. Unlike file
services, message services deal actively with communication
interactions between computer users applications, network
applications or documents.
6.9.4 Application Services
Application services are the network services that run software
for network clients. They are different from file services because
they allow computers to share processing power, not just share data.
Data communication is the process of sending data
electronically from one location to another. Linking one computer to
another permits the power and resources of that computer to be
tapped. It also makes possible the updating and sharing of data at
different locations.
6.10 Co-ordinating Data Communication
The device that coordinates the data transfer is called Network
interface card (NIC). NIC is fixed in the computer and communication
channel is connected to it. Ethernet, Arcnet and token ring are the
examples for the NIC. Protocol specifies the procedures for
establishing maintaining and terminating data transfer.
In 1978, the International Standards organization proposed
protocol known as open system interconnection (OSI). The OSI
provided a network architecture with seven layers. Fig.6.5 gives
the seven layers and the respective functions. This architecture
helps to communicate between Network of dissimilar nodes and
channels.
1796.11
Forms of Data Transmission
Data is transmitted in two forms
1. Analog data transmission
2. Digital data transmission
Analog data transmission is the transmission
continuous waveform. The telephone system, for
designed for analog data transmission. Analog
sometimes modulated or encoded to represent binary
of data in a
instance, is
signals are
data.
Digital data transmission is the widely used communication
system in the world. The distinct electrical state of ,"%on()+ and !!(off#-- is
represented by 1 and 0 respectively. Digital data transmission as
shown in Fig.6.6 is faster and more efficient than analog. All computers
understand and work only in digital forms
7 Application
Purpose for communicating:
e-mail, file transfer,
client/server
0
1 0
1
0
1 0 1
6 Presentation
Rules for data conversion
5
Session
Starts, stops and governs
Transmission order.
4
Transport
Ensures delivery of
Complete message
3
Fig 6.6. Digital Data Transmission
Network
Routes data to
different networks
2
Data link
Transmits data to
Different networks
1
Physical
Passes bits on to
Connecting median
Fig 6.5. Seven Layers of Protocols
1806.12 Modem
Computers at different parts of the world are connected by
telephone lines. The telephone converts the voice at one end into
an electric signal that can flow through a telephone cable. The
telephone at the receiving end converts this electric signal into voice.
Hence the receiver could hear the voice. The process of converting
sound or data into a signal that can flow through the telephone wire
is called modulation.
The reverse process is called demodulation. The telephone
instrument contains the necessary circuit to perform these activities.
The device that accomplishes modulation '"+ demodulation process
is called a modem. It is known that the electrical and sound signals
are analog - which continuously vary with time.
The figure 6.7 shows the relationship of modem to communication
link
Fig . 6.7 Communication Using Modem
Equipments (DTE) are connected through modem and
Telephone line. The modems are the Data Circuit Terminating
Equipments (DCE). DTE creates a digital signal and modulates using
the modem. Then the signals relayed through an interface. The second
modem at the receiving end demodulates into a form that the computer
181can accept. A modem that has extra functions such as automatic
answering and dialing is called intelligent Modems.
6.13 Data Transmission Rate
The speed at which data travel over a communication channel
is called the communication rate. The rate at which the data are
transferred is expressed in terms of bits per second (bps)
6.14 Transmission Mode
When two computers are in communication, data transmission
may occur in one of the three modes (Fig.6.8).
Fig. 6.8 Transmission modes
6.14.1 Simplex mode
In simplex mode, data can be transmitted in one direction as
shown in the figure. The device using the simplex mode of
transmission can either send or receive data, but it cannot do both.
An example is the traditional television broadcast, in which the signal
182is sent from the transmitter to the TV. There is no return signal. In other
words a TV cannot send a signal to the transmitter.
6.14.2 Half duplex mode
In Half duplex mode data can be transmitted back and forth
between two stations. But at any point of time data can go in any
one direction only. This arrangement resembles traffic on a one-
lane bridge. When traffic moves in one direction, traffic on the
opposite direction is to wait and take their turn. The common example
is the walky-talky, wherein one waits for his turn while the other talks.
6.14.3 Full duplex mode
In full duplex mode a device can simultaneously send or
receive data. This arrangement resembles traffic on a two-way bridge,
traffic moving on both directions simultaneously. An example is two
people on the telephone talking and listening simultaneously.
Communication in full duplex mode is faster. Full duplex transmission
is used in large computer systems. Products like &,-Microsoft Net
Meeting."' supports such two way interaction
6.15
Internet
Several networks, small and big all over the world, are
connected together to form a Global network called the Internet.
Today's Internet is a network of about 50 million or more computers
spread across 200 countries. Anyone connected to the Internet can
reach, communicate and access information from any other computer
connected to it.
Some of the Internet users are
/#
'(
&-
Students
Faculty members
Scientists
183'&
$'
Executives and Corporate members
Government employees.
The Internet protocol (IP) addressing system is used to keep
track of the million of users. Each computer on net is called a host.
The IP addressing system uses the letter addressing system and
number addressing systems.
6.16
Communication Protocol
Internet is a packet-switching network. Here is how packet-
switching works: A sending computer breaks an electronic message
into packets. The various packets are sent through a communication
network-often by different routes, at different speeds and sandwiched
in between packets from other messages. Once the packets arrive
at the destination, the receiving computer reassembles the packets
in proper sequence. The packet switching is suitable for data
transmission. The software that is responsible for making the Internet
function efficiently is TCP/IP. TCP/IP is made up of two components.
TCP stands for transmission control protocol and IP stands for
Internet Protocol.
TCP breaks up the data to be sent into little packets. It
guarantees that any data sent to the destination computer reaches
intact. It makes the process appear as if one computer is directly
connected to the other providing what appears to be a dedicated
connection.
IP is a set of conventions used to pass packets from one host
to another. It is responsible for routing the packets to a desired
destination IP address.
6.17
Who Governs The Internet ?
The Internet as a whole does not have a single controller. But
the Internet society, which is a voluntary membership organization,
takes the responsibility to promote global information exchange through
the Internet technology. Internet Corporation for Assigned Names and
184Numbers (ICANN) administers the domain name registration. It helps
to avoid a name which is already registered.
6.18 Future of Internet
The popularity of Internet is growing ever since its
evolution 20 years ago. This will bring out
)%
,"
-.
"-
New standard protocol
International connections
Consumer civilization
Data sharing in research and Engineering
6.19 Uses of Internet
The following are some of the popular Internet tools, used
by the million of the users.
World Wide Web
Web is a multimedia portion of the Internet. It consists of
an interconnection system of sites or servers all over the world that
can store information in the multimedia form. The Multimedia sites
include text, animated graph, voice and images.
The World Wide Web is the most graphically inviting and
easily navigable section of the Internet. It contains several
millions of pages of information. Each page is called a web
page. A group of related web pages linked together forms a
web site. The first page of the website is called a Home page.
The Home page usually contains information about the site and
links to other pages on that site. The Fig.6.9 gives the home page
of Indian Space Research Organization ( ISRO ).
185Fig. 6.9. Home Page of ISRO
Every web page has a unique address called the Uniform
Resource Locator or URL. The URL locates the pages on the
Internet. An example of URL is
http:// www.country-watch.com/India
where http stands for Hypertext Transfer Protocol (HTTP). This
protocol is meant for transferring the web files. The www portion of the
address stands for &++world wide web+#, and the next part country-
watch.com is the domain name. Generally, the domain name will be
followed by directory path and the specific document address
separated by slashes. Looking for information on the Internet is
called surfing or browsing. To browse the Internet, a software called
web browser is used. Web browser translates HTML documents of
the website and allows to view it on the screen. Examples of web
browsers are Internet Explorer and Netscape Navigator. The mouse
pointer moves over a underlined or highlighted words and images
186change to a hand icon. This is called an hyperlink. This indicates the
link to other sites. To go to one of the linked sites, just click the mouse
on the hyperlink.
E-mail - The World Wide Web is getting a lot of attention due to
its main attraction of Electronic mail. Electronic mail is usually used to
exchange messages and data files. Each user is assigned an
electronic mail box. Using mail services, one can scan a list of
messages that can be sent to anyone who has the proper email
identification. The message sent to any one resides in the mailbox till it
is opened. Many other features of standard mail delivery are
implemented in email.
Usenet News Groups: Electronic discussion groups. User
network abbreviated as usenet is essentially a giant disbursed bulletin
board. Electronic discussion groups that focus on specific topic forms,
computer forums.
Mailing list: Email based discussion groups combining E-mail,
news groups and mailing lists send messages on a particular subject.
Automatically messages reach the mailbox of that group.
FTP: File Transfer Protocol, abbreviated as FTP is used for
the net user for transferring files around the world. The transfer includes
software, games, photos, maps, music and such other relevant
materials.
Telnet: Telnet is a protocol that allows the user to connect to a
remote computer. This feature is used to communicate a
microcomputer with mainframe.
6.20
Getting connected to Internet
To use an Internet in the simplest way, we need
&/
!*
A Computer
A Telephone line
187-)
!%
A Modem
Internet Service Provided or ISP
The ISPs are the companies which allows the user to use the
Internet for a price. One has to register with the ISP for an Internet
account. ISP provides the following:
+/
$)
$*
.'
User name - An unique name that identifies the user
Password
- A secret code that prevents other users from
using your account
E-mail address- Unique address that you can send or receive
E-mails.
Access telephone number - Internet users can use this
number to connect to the service provider.
Fig.6.10 shows dialog boxes on the computer screen wherein
the user name (Govt. Higher Secondary School, Chennai -600 003
abbreviated as a ghssch3), a password (alpha numeric of word length
8 characters appearing as "',x%/!) and access telephone number are
entered. By clicking on the dial button, the modem establishes a
connection with the ISP.
Fig.6.10. Dialogue Box for Connecting to the Internet
188There are two ways to look for the information on the Web. If
the URL of the website is known, enter it on the address bar (Fig.6.11).
If URL is not known, then #!.Search Engines!$! will help us to get the
information. Search Engines are tools that allow the user to find specific
document through key words or menu choices. Some of the popular
Search engines are Yahoo, Lycos, AltaVista, Hotbot , Google and
Askjeeves.
Fig.6.11. Entering the URL
Internet explorer helps to use the net more effectively with
the navigation buttons (Fig.6.12) on the toolbar.
1
2
3 4 5
Fig.6.12. Navigation Buttons
1. Back button: This button helps to go back to the previous
link. The small triangle adjacent to it displays a dropdown list of
several recently used pages. Instead of pressing the back button several
times, select a page from the list.
2. Forward button: This is a similar to the back button. One
can jump forward by one page or several pages.
1893. Stop button: After clicking on a link, some times we may
realize that the link is not necessary. The click stop button and move
back without wasting time.
4. Refresh button: Sometimes a page may take longer
time or may not load properly. Click on the refresh button, helps
reload the page faster.
5. Home button: While following the hyperlink, it is very easy
to get lost. The home button reverts to the home page of the website.
6.21
Popular uses of the web
Research: The web provides research materials from libraries,
research institutions, encyclopedia, magazines and newspapers.
Some sample sites
www.encarta.com the Internet Public Library site www.ipl.com and
Library of Congress www.loc.gov.
Chatting: Some websites proved chat rooms to interact with an
individual or a group.
Free-wares: Some sites provide free download of software's,
tutorials and benchmarks.
Education online: Educational institutions offer courses via the
web. Student can attend and interact in a class from home using a
computer.
Online services: Online shopping, online booking for travels and
entertainments managing investments are the upcoming areas of
Internet that reaches every home.
Job searches: The digital revolution is changing everything it touches
and the job market is no exception. Several web sites are assisting
people in finding internship, jobs and helps companies to fill job
190vacancies. There are sites relating to specific job and profession also.
Some of these sites charge a fee for the services while others are
free.
6.22
Intranet and Extranet
Many organizations have Local Area Network that allows their
computers to share files, data, printers and other resources.
Sometimes these private network uses TCP / IP and other Internet
standard protocols and hence they are called intranet. All the Internet
services such as web pages, email, chat; usenet and FTP are
provided on the intranet to serve the organization. Creating a web
page on the intranet is simple because they use only Word-
Processing Software One of the main consideration of the intranet
is security. The sensitive company data available on the intranet is
protected from the outside world.
Taking intranet technology a few steps forward extranets are
useful in the business world. Intranet connecting selected customers,
suppliers and offices in addition to the internal personnel, is called
extranet. By using extranet business organizations can save
telephone charges. For example a can manufacturing company can
extend their intranet to their dealers and customers for support and
service.
EXERCISES
I. Fill in the blanks:
1. _is a typically two or more LANs connected
together across a wide geographical area.
2. _network computers and other communication
devices are connected in a continuous loop.
3. In a high speed network _are used.
1914. The device that coordinates the data transfer is called
_,_
5. The OSI provided a network architecture with
_layers.
6. All computers understand and work only in
_form.
7. _signals continuously vary with time.
8. Communication in _mode is faster.
9. _protocol is used to assist communication
between a microcomputer and a mainframe.
10. _tools, that allow the Internet user to find specific
document through keywords or menu choices.
II. Answer the following (short answer)
1. What are the reasons for networking?
2. Mention a few areas, where computer networks are employed
3. What are the elements that a computer communication should
ensure?
4. List the general types of networks used today.
5. Explain WAN.
6. How data is transmitted in different forms?
7. What are the transmission modes?
8. What is TCP?
9. What is the role of ICANN?
10. Explain URL.
Are you a recent graduate currently looking for a job? If you are, then you must have experienced firsthand how challenging it is to write an application letter.

Application Letter Sample for Fresh Graduates

An application letter is one of the first few things that you need to prepare when applying for a job. Your application letter, together with your resume, are two of the most important documents you need in your bid to get a job and finally join the workforce.

The term +-$application letter(,+ and #"$cover letter*-/ are often used interchangeably though both are different when it comes to purpose, content and length. To avoid confusion, we are strictly going to use the term )!/application letter-*- on this article to describe a document which main purpose is to describe your skills, market your abilities and summarizes your experiences.

Your application letter serves as your formal (albeit non-personal) introduction with your potential employer. It contains your background, summarizes your knowledge and experiences and includes a few more details as to why you are qualified for the job. More importantly, your application letter expresses your intent to apply for a specific job within an organization, business or company.

To help you effectively persuade your potential employer in considering your application, take some notes from these application letter samples.

 
Application Letter Sample 1 (Print Copy)

This application letter sample shows the correct format you should use when sending out your application letter in print form. If you plan on submitting your application letter via email, refer to the second application letter sample below.

22 H Venture St.,
Diliman, Quezon City
Philippines

April 17, 2015

Mr. Vincent Chua
Hiring Manager
Bank of the Philippines Islands (BPI)
12/F Ayala Life-FGU Center, Ayala Ave.
Makati City 1226

Dear Mr. Chua,

I am writing to express my interest for the position of Recruitment Assistant in your esteemed company.

Having recently obtained my Bachelor's Degree in Business Administration major in Human Resource Development Management (BSBA-HRDM) in the Polytechnic University of the Philippines (PUP), I wish to bring my knowledge, skills and commitment to excellence to your company's innovative environment.

As a Business Administration student, majoring in HR management, I've become equipped with the necessary knowledge that come with the position including manpower recruitment, workforce organization, personnel training and compensation as well as legal provisions and other labor concerns.

My internship at San Miguel Corporation also afforded me with the crucial skills to work with some of the best professionals in the recruitment and human resources industry. Being a trainee has developed in me enthusiasm and a true passion for human resources and has subsequently convinced me that human resource management is my true calling.

For additional details regarding my qualification and expertise, please review my attached resume.

Thank you for taking the time to consider this application and I look forward to hearing from you.

Sincerely,

(signature)

Jessica Cenadoza

 

Application Letter Writing Tip: When intending to submit a hard copy of your application letter (and resume), make sure that you send it in a strict business letter format. Remember that your application letter not only speaks of your skills and accomplishments. It also shows how effectively you can communicate. Therefore, make it a point to impress your potential employer by writing a grammatically correct, perfectly spelled and properly punctuated application letter.

 

 
Application Letter Sample 2 (Email Copy)

As previously mentioned, the format of your application letter may differ depending on whether you are submitting a print copy or an email copy. The second application letter sample below is a copy tailored specifically for emails.

 

Email Subject: Eric Tala, Marketing Associate Position

Dear Ms. Casta$#eda,

I would like to express my interest in applying for the position of Marketing Associate as was recently made available in your company.

I believe that my degree in Business Administration (BSBA) major in Marketing from the Philippine School of Business Administration (PSBA) has prepared me for this position. As a student, I was equipped with the necessary knowledge and skills to help develop and drive effective marketing strategies.

During my internship at Uniliver Philippines$'' Marketing Department, I learned how companies determine what product or service to sell, how to reach target demographics and how to respond to the demands of competitors. More importantly, I had the opportunity to work with seasoned professionals who taught me how to easily grasp complex marketing concepts and at certain times, how to roll with the punches in order to achieve various objectives.

I have also acquainted myself with a wide range of skills that allow me to blend with the group or team's culture and to continuously strive to reach common goals amidst failures and setbacks.

My active involvement in many academic and extracurricular activities has done so well in developing my communication and leadership skills, which are vital in finding success in the corporate world.

With this application letter, I attach herewith my resume for your full consideration. Thank you for taking time to review my application and I am looking forward to your reply so that we can further discuss my application.

Yours sincerely,
Alvin C. Marfal
7194 Marcelo Ave
Para+(aque City, Metro Manila 1700
Mobile: +63 929 XXX XXXX
Application Letter Writing Tip: Make it a point to include the necessary email subject when sending your application letter via email. The email subject provided on this application letter sample follows the usual format (name, position you are applying for) though some recruiters require applicants to send their application letter (and resumes) with a specific email subject.

Also, when sending your application letter thru email, remember to include your contact details on the email signature. By doing so, you will enable the recruiter or potential employer to respond to your application immediately.

Remember that these samples are merely templates meant to serve as a basis in writing your own, personalized application letter. When writing an application letter, feel free to customize it according to your own personal preference. You don't want to have just another generic application letter because chances are the hiring manager has already read hundreds, or maybe thousands of it. You want your application letter to stand out and ultimately showcase why you are the best person for the job.

NOTE: These application letter samples are for reference only. All information provided should be considered as fictional.

Need more help writing your cover letter? Read "#&Analyzing and Avoiding Common Cover Letter Errors"&-.
About JobStreet.com

JobStreet.com is a leading online job board presently covering the employment markets in Malaysia, Singapore, Hong Kong, Thailand, the Philippines, Indonesia and Vietnam. JobStreet.com currently services over 230,000 corporate hirers and over 15 million jobseekers in its database.


Chapter 1:
COMPUTERS and PROGRAMS:
Almost everyone has used a computer at one time or another. Perhaps you have played computer games or
used a computer to write a paper or balance your checkbook. Computers are used to predict the weather,
design airplanes, make movies, run businesses, perform financial transactions, and control factories.
Have you ever stopped to wonder what exactly a computer is? How can one device perform so many
different tasks? These basic questions are the starting point for learning about computers and computer
programming.
1: The Universal Machine
A modern computer might be defined as "a machine that stores and manipulates information under the con-
trol of a changeable program." There are two key elements to this definition. The first is that computers
are devices for manipulating information. This means that we can put information into a computer, and it
can transform the information into new, useful forms, and then output or display the information for our
interpretation.
Computers are not the only machines that manipulate information. When you use a simple calculator to
add up a column of numbers, you are entering information (the numbers) and the calculator is processing the
information to compute a running sum which is then displayed. Another simple example is a gas pump. As
you fill your tank, the pump uses certain inputs: the current price of gas per gallon and signals from a sensor
that reads the rate of gas flowing into your car. The pump transforms this input into information about how
much gas you took and how much money you owe.
We would not consider either the calculator or the gas pump as full-fledged computers, although modern
versions of these devices may actually contain embedded computers. They are different from computers in
that they are built to perform a single, specific task. This is where the second part of our definition comes into
the picture: computers operate under the control of a changeable program. What exactly does this mean?
A computer program is a detailed, step-by-step set of instructions telling a computer exactly what to do.
If we change the program, then the computer performs a different sequence of actions, and hence, performs
a different task. It is this flexibility that allows your PC to be at one moment a word processor, at the next
moment a financial planner, and later on, an arcade game. The machine stays the same, but the program
controlling the machine changes.
Every computer is just a machine for executing (carrying out) programs. There are many different kinds
of computers. You might be familiar with Macintoshes and PCs, but there are literally thousands of other
kinds of computers both real and theoretical. One of the remarkable discoveries of computer science is
the realization that all of these different computers have the same power; with suitable programming, each
computer can basically do all the things that any other computer can do. In this sense, the PC that you might
have sitting on your desk is really a universal machine. It can do anything you want it to, provided you can
describe the task to be accomplished in sufficient detail. Now that's a powerful machine!
12
CHAPTER 1. COMPUTERS AND PROGRAMS
1.2 Program Power
You have already learned an important lesson of computing: Software (programs) rules the hardware (the
physical machine). It is the software that determines what any computer can do. Without programs, comput-
ers would just be expensive paperweights. The process of creating software is called programming, and that
is the main focus of this book.
Computer programming is a challenging activity. Good programming requires an ability to see the big
picture while paying attention to minute detail. Not everyone has the talent to become a first-class program-
mer, just as not everyone has the skills to be a professional athlete. However, virtually anyone can learn how
to program computers. With some patience and effort on your part, this book will help you to become a
programmer.
There are lots of good reasons to learn programming. Programming is a fundamental part of computer
science and is, therefore, important to anyone interested in becoming a computer professional. But others can
also benefit from the experience. Computers have become a commonplace tool in our society. Understanding
the strengths and limitations of this tool requires an understanding of programming. Non-programmers often
feel they are slaves of their computers. Programmers, however, are truly the masters. If you want to become
a more intelligent user of computers, then this book is for you.
Programming can also be loads of fun. It is an intellectually engaging activity that allows people to
express themselves through useful and sometimes remarkably beautiful creations. Believe it or not, many
people actually write computer programs as a hobby. Programming also develops valuable problem-solving
skills, especially the ability to analyze complex systems by reducing them to interactions of understandable
subsystems.
As you probably know, programmers are in great demand. More than a few liberal arts majors have turned
a couple computer programming classes into a lucrative career option. Computers are so commonplace in the
business world today that the ability to understand and program computers might just give you the edge over
your competition, regardless of your occupation.
1.3 What is Computer Science?
You might be surprised to learn that computer science is not the study of computers. A famous computer
scientist named Edsgar Dijkstra once quipped that computers are to computer science what telescopes are to
astronomy. The computer is an important tool in computer science, but it is not itself the object of study.
Since a computer can carry out any process that we can describe, the real question is What processes can we
describe? Put another way, the fundamental question of computer science is simply What can be computed?
Computer scientists use numerous techniques of investigation to answer this question. The three main ones
are design, analysis, and experimentation.
One way to demonstrate that a particular problem can be solved is to actually design a solution. That is,
we develop a step-by-step process for achieving the desired result. Computer scientists call this an algorithm.
That's a fancy word that basically means ,#!recipe.+', The design of algorithms is one of the most important
facets of computer science. In this book you will find techniques for designing and implementing algorithms.
One weakness of design is that it can only answer the question What is computable? in the positive. If I
can devise an algorithm, then the problem is solvable. However, failing to find an algorithm does not mean
that a problem is unsolvable. It may mean that I'm just not smart enough, or I haven't hit upon the right idea
yet. This is where analysis comes in.
Analysis is the process of examining algorithms and problems mathematically. Computer scientists have
shown that some seemingly simple problems are not solvable by any algorithm. Other problems are in-
tractable. The algorithms that solve these problems take too long or require too much memory to be of
practical value. Analysis of algorithms is an important part of computer science; throughout this book we
will touch on some of the fundamental principles. Chapter 13 has examples of unsolvable and intractable
problems.
Some problems are too complex or ill-defined to lend themselves to analysis. In such cases, computer
scientists rely on experimentation; they actually implement systems and then study the resulting behavior.
Even when theoretical analysis is done, experimentation is often needed in order to verify and refine the1.4. HARDWARE BASICS
3
Output Devices
CPU
Input Devices
Main Memory
Secondary
Memory
Figure 1.1: Functional View of a Computer.
analysis. For most problems, the bottom-line is whether a working, reliable system can be built. Often we
require empirical testing of the system to determine that this bottom-line has been met. As you begin writing
your own programs, you will get plenty of opportunities to observe your solutions in action.
1.4 Hardware Basics
You don't have to know all the details of how a computer works to be a successful programmer, but under-
standing the underlying principles will help you master the steps we go through to put our programs into
action. It's a bit like driving a car. Knowing a little about internal combustion engines helps to explain why
you have to do things like fill the gas tank, start the engine, step on the accelerator, etc. You could learn
to drive by just memorizing what to do, but a little more knowledge makes the whole process much more
understandable. Let's take a moment to %//look under the hood/,& of your computer.
Although different computers can vary significantly in specific details, at a higher level all modern digital
computers are remarkably similar. Figure 1.1 shows a functional view of a computer. The central processing
unit (CPU) is the ($%brain,%) of the machine. This is where all the basic operations of the computer are carried
out. The CPU can perform simple arithmetic operations like adding two numbers and can also do logical
operations like testing to see if two numbers are equal.
The memory stores programs and data. The CPU can only directly access information that is stored in
main memory (called RAM for Random Access Memory). Main memory is fast, but it is also volatile. That is,
when the power is turned off, the information in the memory is lost. Thus, there must also be some secondary
memory that provides more permanent storage. In a modern personal computer, this is usually some sort of
magnetic medium such as a hard disk (also called a hard drive) or floppy.
Humans interact with the computer through input and output devices. You are probably familiar with
common devices such as a keyboard, mouse, and monitor (video screen). Information from input devices is
processed by the CPU and may be shuffled off to the main or secondary memory. Similarly, when information
needs to be displayed, the CPU sends it to one or more output devices.
So what happens when you fire up your favorite game or word processing program? First, the instructions
that comprise the program are copied from the (more) permanent secondary memory into the main memory
of the computer. Once the instructions are loaded, the CPU starts executing the program.
Technically the CPU follows a process called the fetch execute cycle. The first instruction is retrieved
from memory, decoded to figure out what it represents, and the appropriate action carried out. Then the next
instruction is fetched, decoded and executed. The cycle continues, instruction after instruction. This is really
all the computer does from the time that you turn it on until you turn it off again: fetch, decode, execute. It
doesn't seem very exciting, does it? But the computer can execute this stream of simple instructions with
blazing speed, zipping through millions of instructions each second. Put enough simple instructions together
in just the right way, and the computer does amazing things.4
CHAPTER 1. COMPUTERS AND PROGRAMS
1.5 Programming Languages
Remember that a program is just a sequence of instructions telling a computer what to do. Obviously, we
need to provide those instructions in a language that a computer can understand. It would be nice if we could
just tell a computer what to do using our native language, like they do in science fiction movies. (((%Computer,
how long will it take to reach planet Alphalpha at maximum warp?.&/) Unfortunately, despite the continuing
efforts of many top-flight computer scientists (including your author), designing a computer to understand
human language is still an unsolved problem.
Even if computers could understand us, human languages are not very well suited for describing complex
algorithms. Natural language is fraught with ambiguity and imprecision. For example, if I say: &."I saw the
man in the park with the telescope,#/( did I have the telescope, or did the man? And who was in the park? We
understand each other most of the time only because all humans share a vast store of common knowledge and
experience. Even then, miscommunication is commonplace.
Computer scientists have gotten around this problem by designing notations for expressing computa-
tions in an exact, and unambiguous way. These special notations are called programming languages. Every
structure in a programming language has a precise form (its syntax) and a precise meaning (its semantics). A
programming language is something like a code for writing down the instructions that a computer will follow.
In fact, programmers often refer to their programs as computer code, and the process of writing an algorithm
in a programming language is called coding.
Python is one example of a programming language. It is the language that we will use throughout this
book. You may have heard of some other languages, such as C++, Java, Perl, Scheme, or BASIC. Although
these languages differ in many details, they all share the property of having well-defined, unambiguous syntax
and semantics.
All of the languages mentioned above are examples of high-level computer languages. Although they are
precise, they are designed to be used and understood by humans. Strictly speaking, computer hardware can
only understand very low-level language known as machine language.
Suppose we want the computer to add two numbers. The instructions that the CPU actually carries out
might be something like this.
load the number from memory location 2001 into the CPU
load the number from memory location 2002 into the CPU
Add the two numbers in the CPU
store the result into location 2003
This seems like a lot of work to add two numbers, doesn't it? Actually, it's even more complicated than this
because the instructions and numbers are represented in binary notation (as sequences of 0s and 1s).
In a high-level language like Python, the addition of two numbers can be expressed more naturally: c =
a + b. That's a lot easier for us to understand, but we need some way to translate the high-level language
into the machine language that the computer can execute. There are two ways to do this: a high-level language
can either be compiled or interpreted.
A compiler is a complex computer program that takes another program written in a high-level language
and translates it into an equivalent program in the machine language of some computer. Figure 1.2 shows
a block diagram of the compiling process. The high-level program is called source code, and the resulting
machine code is a program that the computer can directly execute. The dashed line in the diagram represents
the execution of the machine code.
An interpreter is a program that simulates a computer that understands a high-level language. Rather than
translating the source program into a machine language equivalent, the interpreter analyzes and executes the
source code instruction by instruction as necessary. Figure 1.3 illustrates the process.
The difference between interpreting and compiling is that compiling is a one-shot translation; once a
program is compiled, it may be run over and over again without further need for the compiler or the source
code. In the interpreted case, the interpreter and the source are needed every time the program runs. Compiled
programs tend to be faster, since the translation is done once and for all, but interpreted languages lend
themselves to a more flexible programming environment as programs can be developed and run interactively.
The translation process highlights another advantage that high-level languages have over machine lan-
guage: portability. The machine language of a computer is created by the designers of the particular CPU.1.6. THE MAGIC OF PYTHON
Source
Code
(Program)
5
Compiler
Machine
Code
Running
Inputs
Outputs
Program
Figure 1.2: Compiling a High-Level Language
Source
Code
(Program)
Computer
Running an
Outputs
Interpreter
Inputs
Figure 1.3: Interpreting a High-Level Language.
Each kind of computer has its own machine language. A program for a Pentium CPU won't run on a Mac-
intosh that sports a PowerPC. On the other hand, a program written in a high-level language can be run on
many different kinds of computers as long as there is a suitable compiler or interpreter (which is just another
program). For example, if I design a new computer, I can also program a Python interpreter for it, and then
any program written in Python can be run on my new computer, as is.
1.6 The Magic of Python
Now that you have all the technical details, it's time to start having fun with Python. The ultimate goal is
to make the computer do our bidding. To this end, we will write programs that control the computational
processes inside the machine. You have already seen that there is no magic in this process, but in some ways
programming feels like magic.
The computational processes inside the computer are like magical spirits that we can harness for our
work. Unfortunately, those spirits only understand a very arcane language that we do not know. What we
need is a friendly Genie that can direct the spirits to fulfill our wishes. Our Genie is a Python interpreter. We
can give instructions to the Python interpreter, and it directs the underlying spirits to carry out our demands.
We communicate with the Genie through a special language of spells and incantations (i.e., Python). The
best way to start learning about Python is to let our Genie out of the bottle and try some spells.
You can start the Python interpreter in an interactive mode and type in some commands to see what
happens. When you first start the interpreter program, you may see something like the following:
Python 2.1 (#1, Jun 21 2001, 11:39:00)
[GCC pgcc-2.91.66 19990314 (egcs-1.1.2 release)] on linux2
Type "copyright", "credits" or "license" for more information.
>>>
The  /#" (./  is a Python prompt indicating that the Genie is waiting for us to give it a command. In programming
languages, a complete command is called a statement.
Here is a sample interaction with the Python interpreter.CHAPTER 1. COMPUTERS AND PROGRAMS
6
>>> print "Hello, World"
Hello, World
>>> print 2 + 3
5
>>> print "2 + 3 =", 2 + 3
2 + 3 = 5
Here I have tried out three examples using the Python print statement. The first statement asks Python to
display the literal phrase Hello, World. Python responds on the next line by printing the phrase. The second
print statement asks Python to print the sum of 2 and 3. The third print combines these two ideas.
Python prints the part in quotes $*.2 + 3 =*)" followed by the result of adding 2 + 3, which is 5.
This kind of interaction is a great way to try out new things in Python. Snippets of interactive sessions
are sprinkled throughout this book. When you see the Python prompt  !)% ,%"  in an example, that should tip
you off that an interactive session is being illustrated. It's a good idea to fire up Python and try the examples
for yourself.
Usually we want to move beyond snippets and execute an entire sequence of statements. Python lets us
put a sequence of statements together to create a brand-new command called a function. Here is an example
of creating a new function called hello.
>>> def hello():
print "Hello"
print "Computers are Fun"
>>>
The first line tells Python that we are defining a new function called hello. The following lines are indented
to show that they are part of the hello function. The blank line (obtained by hitting the <Enter> key
twice) lets Python know that the definition is finished, and the interpreter responds with another prompt.
Notice that the definition did not cause anything to happen. We have told Python what should happen when
the hello function is used as a command; we haven't actually asked Python to perform it yet.
A function is invoked by typing its name. Here's what happens when we use our hello command.
>>> hello()
Hello
Computers are Fun
>>>
Do you see what this does? The two print statements from the hello function are executed in sequence.
You may be wondering about the parentheses in the definition and use of hello. Commands can have
changeable parts called parameters that are placed within the parentheses. Let's look at an example of a
customized greeting using a parameter. First the definition:
>>> def greet(person):
print "Hello", person
print "How are you?"
Now we can use our customized greeting.
>>> greet("John")
Hello John
How are you?
>>> greet("Emily")
Hello Emily
How are you?
>>>1.6. THE MAGIC OF PYTHON
7
Can you see what is happening here? When we use greet we can send different names to customize the
result. We will discuss parameters in detail later on. For the time being, our functions will not use parameters,
so the parentheses will be empty, but you still need to include them when defining and using functions.
One problem with entering functions interactively at the Python prompt like this is that the definitions go
away when we quit Python. If we want to use them again the next time, we have to type them all over again.
Programs are usually created by typing definitions into a separate file called a module or script. This file is
saved on a disk so that it can be used over and over again.
A module file is just a text file, and you can create one using any program for editing text, like a notepad or
word processor program (provided you save your program as a &,!plain text*+& file). A special type of program
known as a programming environment simplifies the process. A programming environment is specifically
designed to help programmers write programs and includes features such as automatic indenting, color high-
lighting, and interactive development. The standard Python distribution includes a programming environment
called Idle that you may use for working on the programs in this book.
Let's illustrate the use of a module file by writing and running a complete program. Our program will
illustrate a mathematical concept known as chaos. Here is the program as we would type it into Idle or some
other editor and save in a module file:
# File: chaos.py
# A simple program illustrating chaotic behavior.
def main():
print "This program illustrates a chaotic function"
x = input("Enter a number between 0 and 1: ")
for i in range(10):
x = 3.9 * x * (1 - x)
print x
main()
This file should be saved with with the name chaos.py. The .py extension indicates that this is a
Python module. You can see that this particular example contains lines to define a new function called main.
(Programs are often placed in a function called main.) The last line of the file is the command to invoke
this function. Don't worry if you don't understand what main actually does; we will discuss it in the next
section. The point here is that once we have a program in a module file, we can run it any time we want.
This program can be run in a number of different ways that depend on the actual operating system and
programming environment that you are using. If you are using a windowing system, you can run a Python
program by (double-)clicking on the module file's icon. In a command-line situation, you might type a
command like python chaos.py. If you are using Idle (or another programming environment) you can
run a program by opening it in the editor and then selecting a command like import, run, or execute.
One method that should always work is to start the Python interpreter and then import the file. Here is
how that looks.
>>> import chaos
This program illustrates a chaotic function
Enter a number between 0 and 1: .25
0.73125
0.76644140625
0.698135010439
0.82189581879
0.570894019197
0.955398748364
0.166186721954
0.540417912062
0.9686289303
0.118509010176
>>>8
CHAPTER 1. COMPUTERS AND PROGRAMS
Typing the first line import chaos tells the Python interpreter to load the chaos module from the file
chaos.py into main memory. Notice that I did not include the .py extension on the import line; Python
assumes the module will have a .py extension.
As Python imports the module file, each line executes. It's just as if we had typed them one-by-one at the
interactive Python prompt. The def in the module causes Python to create the main function. When Python
encounters the last line of the module, the main function is invoked, thus running our program. The running
program asks the user to enter a number between 0 and 1 (in this case, I typed )(%.25*#+) and then prints out a
series of 10 numbers.
When you first import a module file in this way, Python creates a companion file with a .pyc extension.
In this example, Python creates another file on the disk called chaos.pyc. This is an intermediate file used
by the Python interpreter. Technically, Python uses a hybrid compiling/interpreting process. The Python
source in the module file is compiled into more primitive instructions called byte code. This byte code (the
.pyc) file is then interpreted. Having a .pyc file available makes importing a module faster the second time
around. However, you may delete the byte code files if you wish to save disk space; Python will automatically
re-create them as needed.
A module only needs to be imported into a session once. After the module has been loaded, we can run the
program again by asking Python to execute the main command. We do this by using a special dot notation.
Typing chaos.main() tells Python to invoke the main function in the chaos module. Continuing with
our example, here is how it looks when we rerun the program with 26 as the input.
>>> chaos.main()
Enter a number between 0 and 1: .26
0.75036
0.73054749456
0.767706625733
0.6954993339
0.825942040734
0.560670965721
0.960644232282
0.147446875935
0.490254549376
0.974629602149
>>>
1.7 Inside a Python Program
The output from the chaos program may not look very exciting, but it illustrates a very interesting phe-
nomenon known to physicists and mathematicians. Let's take a look at this program line by line and see what
it does. Don't worry about understanding every detail right away; we will be returning to all of these ideas in
the next chapter.
The first two lines of the program start with the # character:
# File: chaos.py
# A simple program illustrating chaotic behavior.
These lines are called comments. They are intended for human readers of the program and are ignored by
Python. The Python interpreter always skips any text from the pound sign (#) through the end of a line.
The next line of the program begins the definition of a function called main.
def main():
Strictly speaking, it would not be necessary to create a main function. Since the lines of a module are
executed as they are loaded, we could have written our program without this definition. That is, the module
could have looked like this:1.7. INSIDE A PYTHON PROGRAM
9
# File: chaos.py
# A simple program illustrating chaotic behavior.
print "This program illustrates a chaotic function"
x = input("Enter a number between 0 and 1: ")
for i in range(10):
x = 3.9 * x * (1 - x)
print x
This version is a bit shorter, but it is customary to place the instructions that comprise a program inside of a
function called main. One immediate benefit of this approach was illustrated above; it allows us to (re)run
the program by simply invoking chaos.main(). We don't have to reload the module from the file in order
to run it again, which would be necessary in the main-less case.
The first line inside of main is really the beginning of our program.
print "This program illustrates a chaotic function"
This line causes Python to print a message introducing the program when it runs.
Take a look at the next line of the program.
x = input("Enter a number between 0 and 1: ")
Here x is an example of a variable. A variable is used to give a name to a value so that we can refer to it at
other points in the program. The entire line is an input statement. When Python gets to this statement, it
displays the quoted message Enter a number between 0 and 1: and then pauses, waiting for the
user to type something on the keyboard and press the <Enter> key. The value that the user types is then
stored as the variable x. In the first example shown above, the user entered .25, which becomes the value of
x.
The next statement is an example of a loop.
for i in range(10):
A loop is a device that tells Python to do the same thing over and over again. This particular loop says to
do something 10 times. The lines indented underneath the loop heading are the statements that are done 10
times. These form the body of the loop.
x = 3.9 * x * (1 - x)
print x
The effect of the loop is exactly the same as if we had written the body of the loop 10 times:
x = 3.9
print x
x = 3.9
print x
x = 3.9
print x
x = 3.9
print x
x = 3.9
print x
x = 3.9
print x
x = 3.9
print x
x = 3.9
print x
x = 3.9
* x * (1 - x)
* x * (1 - x)
* x * (1 - x)
* x * (1 - x)
* x * (1 - x)
* x * (1 - x)
* x * (1 - x)
* x * (1 - x)
* x * (1 - x)CHAPTER 1. COMPUTERS AND PROGRAMS
10
print x
x = 3.9 * x * (1 - x)
print x
Obviously using the loop instead saves the programmer a lot of trouble.
But what exactly do these statements do? The first one performs a calculation.
x = 3.9 * x * (1 - x)
This is called an assignment statement. The part on the right side of the = is a mathematical expression.
Python uses the * character to indicate multiplication. Recall that the value of x is 0 25 (from the input
statement). The computed value is 3 9 0 25 1 0 25 or 0 73125. Once the value on the righthand side is
computed, it is stored back (or assigned) into the variable that appears on the lefthand side of the =, in this
case x. The new value of x (0 73125) replaces the old value (0 25).
The second line in the loop body is a type of statement we have encountered before, a print statement.
print x
When Python executes this statement the current value of x is displayed on the screen. So, the first number
of output is 0.73125.
Remember the loop executes 10 times. After printing the value of x, the two statements of the loop are
executed again.
x = 3.9 * x * (1 - x)
print x
Of course, now x has the value 0 73125, so the formula computes a new value of x as 3 9 0 73125 1
0 73125 , which is 0 76644140625.
Can you see how the current value of x is used to compute a new value each time around the loop? That's
where the numbers in the example run came from. You might try working through the steps of the program
yourself for a different input value (say 0 5). Then run the program using Python and see how well you did
impersonating a computer.
1.8 Chaos and Computers
I said above that the chaos program illustrates an interesting phenomenon. What could be interesting about
a screen full of numbers? If you try out the program for yourself, you'll find that, no matter what number
you start with, the results are always similar: the program spits back 10 seemingly random numbers between
0 and 1. As the program runs, the value of x seems to jump around, well, chaotically.
The function computed by this program has the general form: k x 1 x , where k in this case is 3.9.
This is called a logistic function. It models certain kinds of unstable electronic circuits and is also sometimes
used to predict population under limiting conditions. Repeated application of the logistic function can pro-
duce chaos. Although our program has a well defined underlying behavior, the output seems unpredictable.
An interesting property of chaotic functions is that very small differences in the initial value can lead to
large differences in the result as the formula is repeatedly applied. You can see this in the chaos program by
entering numbers that differ by only a small amount. Here is the output from a modified program that shows
the results for initial values of 0 25 and 0 26 side by side.
input
0.25
0.26
---------------------------
0.731250
0.750360
0.766441
0.730547
0.698135
0.767707
0.821896
0.695499
0.570894
0.825942
0.955399
0.5606711.9. EXERCISES
0.166187
0.540418
0.968629
0.118509
11
0.960644
0.147447
0.490255
0.974630
With very similar starting values, the outputs stay similar for a few iterations, but then differ markedly. By
about the fifth iteration, there no longer seems to be any relationship between the two models.
These two features of our chaos program, apparent unpredictability and extreme sensitivity to initial
values, are the hallmarks of chaotic behavior. Chaos has important implications for computer science. It
turns out that many phenomena in the real world that we might like to model and predict with our computers
exhibit just this kind of chaotic behavior. You may have heard of the so-called butterfly effect. Computer
models that are used to simulate and predict weather patterns are so sensitive that the effect of a single
butterfly flapping its wings in New Jersey might make the difference of whether or not rain is predicted in
Peoria.
It's very possible that even with perfect computer modeling, we might never be able to measure existing
weather conditions accurately enough to predict weather more than a few days in advance. The measurements
simply can't be precise enough to make the predictions accurate over a longer time frame.
As you can see, this small program has a valuable lesson to teach users of computers. As amazing as
computers are, the results that they give us are only as useful as the mathematical models on which the
programs are based. Computers can give incorrect results because of errors in programs, but even correct
programs may produce erroneous results if the models are wrong or the initial inputs are not accurate enough.
1.9 Exercises
1. Compare and contrast the following pairs of concepts from the chapter.
(a) Hardware vs. Software
(b) Algorithm vs. Program
(c) Programming Language vs. Natural Language
(d) High-Level Language vs. Machine Language
(e) Interpreter vs. Compiler
(f) Syntax vs. Semantics
2. List and explain in your own words the role of each of the five basic functional units of a computer
depicted in Figure 1.1.
3. Write a detailed algorithm for making a peanut butter and jelly sandwich (or some other simple every-
day activity).
4. As you will learn in a later chapter, many of the numbers stored in a computer are not exact values, but
rather close approximations. For example, the value 0.1, might be stored as 0.10000000000000000555.
Usually, such small differences are not a problem; however, given what you have learned about chaotic
behavior in Chapter 1, you should realize the need for caution in certain situations. Can you think of
examples where this might be a problem? Explain.
5. Trace through the Chaos program from Section 1.6 by hand using 0 15 as the input value. Show the
sequence of output that results.
6. Enter and run the Chaos program from Section 1.6 using whatever Python implementation you have
available. Try it out with various values of input to see that it functions as described in the chapter.
7. Modify the Chaos program from Section 1.6 using 2.0 in place of 3.9 as the multiplier in the logistic
function. Your modified line of code should look like this:CHAPTER 1. COMPUTERS AND PROGRAMS
12
x = 2.0 * x * (1 - x)
Run the program for various input values and compare the results to those obtained from the original
program. Write a short paragraph describing any differences that you notice in the behavior of the two
versions.
8. Modify the Chaos program from Section 1.6 so that it prints out 20 values instead of 10.
9. (Advanced) Modify the Chaos program so that it accepts two inputs and then prints a table with two
columns similar to the one shown in Section 1.8. (Note: You will probably not be able to get the
columns to line up as nicely as those in the example. Chapter 4 discusses how to print numbers with a
fixed number of decimal places.)Chapter 2
Writing Simple Programs
As you saw in the previous chapter, it is easy to run programs that have already been written. The hard part is
actually coming up with the program in the first place. Computers are very literal, and they must be told what
to do right down to the last detail. Writing large programs is a daunting task. It would be almost impossible
without a systematic approach.
2.1 The Software Development Process
The process of creating a program is often broken down into stages according to the information that is
produced in each phase. In a nutshell, here's what you should do.
Formulate Requirements Figure out exactly what the problem to be solved is. Try to understand as much
as possible about it. Until you really know what the problem is, you cannot begin to solve it.
Determine Specifications Describe exactly what your program will do. At this point, you should not worry
about how your program will work, but rather with deciding exactly what it will accomplish. For
simple programs this involves carefully describing what the inputs and outputs of the program will be
and how they relate to each other.
Create a Design Formulate the overall structure of the program. This is where the how of the program gets
worked out. The main task is to design the algorithm(s) that will meet the specifications.
Implement the Design Translate the design into a computer language and put it into the computer. In this
book, we will be implementing our algorithms as Python programs.
Test/Debug the Program Try out your program and see if it works as expected. If there are any errors (often
called bugs), then you should go back and fix them. The process of locating and fixing errors is called
debugging a program.
Maintain the Program Continue developing the program in response to the needs of your users. Most
programs are never really finished; they keep evolving over years of use.
2.2 Example Program: Temperature Converter
Let's go through the steps of the software development process with a simple real-world example. Suzie
Programmer has a problem. Suzie is an American computer science student spending a year studying in
Europe. She has no problems with language, as she is fluent in many languages (including Python). Her
problem is that she has a hard time figuring out the temperature in the morning so that she knows how to
dress for the day. Suzie listens to the weather report each morning, but the temperatures are given in degrees
Celsius, and she is used to Fahrenheit.
13CHAPTER 2. WRITING SIMPLE PROGRAMS
14
Fortunately, Suzie has an idea to solve the problem. Being a computer science major, she never goes
anywhere without her laptop computer. She thinks it might be possible that a computer program could help
her out.
Suzie begins with the requirements of her problem. In this case, the problem is pretty clear: the radio an-
nouncer gives temperatures in degrees Celsius, but Suzie only comprehends temperatures that are in degrees
Fahrenheit. That's the crux of the problem.
Next, Suzie considers the specifications of a program that might help her out. What should the input
be? She decides that her program will allow her to type in the temperature in degrees Celsius. And the
output? The program will display the temperature converted into degrees Fahrenheit. Now she needs to
specify the exact relationship of the output to the input. Suzie does some quick figuring to derive the formula
F
9 5 C 32 (Can you see how?). That seems an adequate specification.
Notice that this describes one of many possible programs that could solve this problem. If Suzie had
background in the field of Artificial Intelligence (AI), she might consider writing a program that would
actually listen to the radio announcer to get the current temperature using speech recognition algorithms. For
output, she might have the computer control a robot that goes to her closet and picks an appropriate outfit
based on the converted temperature. This would be a much more ambitious project, to say the least!
Certainly the robot program would also solve the problem identified in the requirements. The purpose of
specification is to decide exactly what this particular program will do to solve a problem. Suzie knows better
than to just dive in and start writing a program without first having a clear idea of what she is trying to build.
Suzie is now ready to design an algorithm for her problem. She immediately realizes that this is a simple
algorithm that follows a standard pattern: Input, Process, Output (IPO). Her program will prompt the user
for some input information (the Celsius temperature), process it to convert to a Fahrenheit temperature, and
then output the result by displaying it on the computer screen.
Suzie could write her algorithm down in a computer language. However, the precision of writing it out
formally tends to stifle the creative process of developing the algorithm. Instead, she writes her algorithm
using pseudocode. Pseudocode is just precise English that describes what a program does. It is meant to
communicate algorithms without all the extra mental overhead of getting the details right in any particular
programming language.
Here is Suzie's completed algorithm:
Input the temperature in degrees Celsius (call it celsius)
Calculate fahrenheit as 9/5 celsius + 32
Output fahrenheit
The next step is to translate this design into a Python program. This is straightforward, as each line of the
algorithm turns into a corresponding line of Python code.
# convert.py
#
A program to convert Celsius temps to Fahrenheit
# by: Suzie Programmer
def main():
celsius = input("What is the Celsius temperature? ")
fahrenheit = 9.0 / 5.0 * celsius + 32
print "The temperature is", fahrenheit, "degrees Fahrenheit."
main()
See if you can figure out what each line of this program does. Don't worry if some parts are a bit confusing.
They will be discussed in detail in the next section.
After completing her program, Suzie tests it to see how well it works. She uses some inputs for which
she knows the correct answers. Here is the output from two of her tests.
What is the Celsius temperature? 0
The temperature is 32.0 degrees fahrenheit.2.3. ELEMENTS OF PROGRAMS
15
What is the Celsius temperature? 100
The temperature is 212.0 degrees fahrenheit.
You can see that Suzie used the values of 0 and 100 to test her program. It looks pretty good, and she is
satisfied with her solution. Apparently, no debugging is necessary.
2.3 Elements of Programs
Now that you know something about the programming process, you are almost ready to start writing programs
on your own. Before doing that, though, you need a more complete grounding in the fundamentals of Python.
The next few sections will discuss technical details that are essential to writing correct programs. This
material can seem a bit tedious, but you will have to master these basics before plunging into more interesting
waters.
2.3.1 Names
You have already seen that names are an important part of programming. We give names to modules (e.g.,
convert) and to the functions within modules (e.g., main). Variables are used to give names to values (e.g.,
celsius and fahrenheit). Technically, all these names are called identifiers. Python has some rules
about how identifiers are formed. Every identifier must begin with a letter or underscore (the )"& #)+ character)
which may be followed by any sequence of letters, digits, or underscores. This implies that a single identifier
cannot contain any spaces.
According to these rules, all of the following are legal names in Python:
x
celsius
spam
spam2
SpamAndEggs
Spam_and_Eggs
Identifiers are case-sensitive, so spam, Spam, sPam, and SPAM are all different names to Python. For the
most part, programmers are free to choose any name that conforms to these rules. Good programmers always
try to choose names that describe the thing being named.
One other important thing to be aware of is that some identifiers are part of Python itself. These names
are called reserved words and cannot be used as ordinary identifiers. The complete list of Python reserved
words is shown in Table 2.1.
and
assert
break
class
continue
def
del
elif
else
except
exec
finally
for
from
global
if
import
in
is
lambda
not
or
pass
print
raise
return
try
while
yield
Table 2.1: Python Reserved Words.
2.3.2 Expressions
Programs manipulate data. The fragments of code that produce or calculate new data values are called
expressions. So far our program examples have dealt mostly with numbers, so I'll use numeric data to
illustrate expressions.16
CHAPTER 2. WRITING SIMPLE PROGRAMS
The simplest kind of expression is a literal. A literal is used to indicate a specific value. In chaos.py
you can find the numbers 3.9 and 1. The convert.py program contains 9.0, 5.0, and 32. These are
all examples of numeric literals, and their meaning is obvious: 32 represents, well, 32.
A simple identifier can also be an expression. We use identifiers as variables to give names to values.
When an identifier appears in an expression, this value is retrieved to provide a result for the expression.
Here is an interaction with the Python interpreter that illustrates the use of variables as expressions.
>>> x = 5
>>> x
5
>>> print x
5
>>> print spam
Traceback (innermost last):
File "<pyshell#34>", line 1, in ?
print spam
NameError: spam
>>>
First the variable x is assigned the value 5 (using the numeric literal 5). The next line has Python evaluate the
expression x. Python spits back 5, which is the value that was just assigned to x. Of course, we get the same
result when we put x in a print statement. The last example shows what happens when we use a variable that
has not been assigned a value. Python cannot find a value, so it reports a Name Error. This says that there is
no value with that name. A variable must always be assigned a value before it can be used in an expression.
More complex and interesting expressions can be constructed by combining simpler expressions with
operators. For numbers, Python provides the normal set of mathematical operations: addition, subtraction,
multiplication, division, and exponentiation. The corresponding Python operators are: +, -, *, /, and **.
Here are some examples of complex expressions from chaos.py and convert.py
3.9 * x * (1 - x)
9.0 / 5.0 * celsius + 32
Spaces are irrelevant within an expression. The last expression could have been written 9.0/5.0*celsius+32
and the result would be exactly the same. Usually it's a good idea to place some spaces in expressions to
make them easier to read.
Python's mathematical operators obey the same rules of precedence and associativity that you learned
in your math classes, including using parentheses to modify the order of evaluation. You should have lit-
tle trouble constructing complex expressions in your own programs. Do keep in mind that only the round
parentheses are allowed in expressions, but you can nest them if necessary to create expressions like this.
((x1 - x2) / 2*n) + (spam / k**3)
If you are reading carefully, you may be curious why, in her temperature conversion program, Suzie
Programmer chose to write 9.0/5.0 rather than 9/5. Both of these are legal expressions, but they give
different results. This mystery will be discussed in Chapter 3. If you can't stand the wait, try them out for
yourself and see if you can figure out what's going on.
2.4 Output Statements
Now that you have the basic building blocks, identifier and expression, you are ready for a more complete
description of various Python statements. You already know that you can display information on the screen
using Python's print statement. But what exactly can be printed? Python, like all programming languages,
has a precise set of rules for the syntax (form) and semantics (meaning) of each statement. Computer scientists
have developed sophisticated notations called meta-languages for describing programming languages. In this
book we will rely on a simple template notation to illustrate the syntax of statements.
Here are the possible forms of the print statement:2.5. ASSIGNMENT STATEMENTS
17
print
print <expr>
print <expr>, <expr>, ..., <expr>
print <expr>, <expr>, ..., <expr>,
In a nutshell, these templates show that a print statement consists of the keyword print followed by zero
or more expressions, which are separated by commas. The angle bracket notation ( "$%  ) is used to indicate
(..slots!&' that are filled in by other fragments of Python code. The name inside the brackets indicate what is
missing; expr stands for an expression. The ellipses (-"#...../) indicate an indefinite series (of expressions,
in this case). You don't actually type the dots. The fourth version shows that a print statement may be
optionally ended with a comma. That is all there is to know about the syntax of print.
As far as semantics, a print statement displays information in textual form. Any supplied expressions
are evaluated left to right, and the resulting values are displayed on a single line of output in a left-to-right
fashion. A single blank space character is placed between the displayed values.
Normally, successive print statements will display on separate lines of the screen. A bare print (first
version above) can be used to get a blank line of output. If a print statement ends with a comma (fourth
version), a final space is appended to the line, but the output does not advance to the next line. Using this
method, multiple print statements can be used to generate a single line of output.
Putting it all together, this sequence of print statements
print
print
print
print
print
print
3+4
3, 4, 3 + 4
3, 4,
3+4
"The answer is", 3 + 4
produces this output
7
3 4 7
3 4 7
The answer is 7
That last print statement may be a bit confusing. According to the syntax templates above, print
requires a sequence of expressions. That means "The answer is" must be an expression. In fact, it is
an expression, but it doesn't produce a number. Instead, it produces another kind of data called a string.
A sequence of characters enclosed in quotes is a string literal. Strings will be discussed in detail in a later
chapter. For now, consider this a convenient way of labeling output.
2.5 Assignment Statements
2.5.1 Simple Assignment
One of the most important kinds of statements in Python is the assignment statement. We've already seen a
number of these in our previous examples. The basic assignment statement has this form:
<variable> = <expr>
Here variable is an identifier and expr is an expression. The semantics of the assignment is that the
expression on the right side is evaluated to produce a value, which is then associated with the variable named
on the left side.
Here are some of the assignments we've already seen.
x = 3.9 * x * (1 - x)
fahrenheit = 9.0 / 5.0 * celsius + 32
x = 5CHAPTER 2. WRITING SIMPLE PROGRAMS
18
A variable can be assigned many times. It always retains the value of the most recent assignment. Here
is an interactive Python session that demonstrates the point:
>>>
>>>
0
>>>
>>>
7
>>>
>>>
8
myVar = 0
myVar
myVar = 7
myVar
myVar = myVar + 1
myVar
The last assignment statement shows how the current value of a variable can be used to update its value. In
this case I simply added one to the previous value. The chaos.py program from Chapter 1 did something
similar, though a bit more complex. Remember, the values of variables can change; that's why they're called
variables.
2.5.2 Assigning Input
The purpose of an input statement is to get some information from the user of a program and store it into a
variable. Some programming languages have a special statement to do this. In Python, input is accomplished
using an assignment statement combined with a special expression called input. This template shows the
standard form.
<variable> = input(<prompt>)
Here prompt is an expression that serves to prompt the user for input; this is almost always a string literal
(i.e., some text inside of quotation marks).
When Python encounters an input expression, it evaluates the prompt and displays the result of the
prompt on the screen. Python then pauses and waits for the user to type an expression and press the
Enter   key. The expression typed by the user is then evaluated to produce the result of the input.
This sounds complicated, but most uses of input are straightforward. In our example programs, input
statements are used to get numbers from the user.
x = input("Please enter a number between 0 and 1: ")
celsius = input("What is the Celsius temperature? ")
If you are reading programs carefully, you probably noticed the blank space inside the quotes at the end
of these prompts. I usually put a space at the end of a prompt so that the input that the user types does not
start right next to the prompt. Putting a space in makes the interaction easier to read and understand.
Although these two examples specifically prompt the user to enter a number, a number is just a numeric
literal.("a simple Python expression. In fact, any valid expression would be just as acceptable. Consider the
following interaction with the Python interpreter.
>>> ans = input("Enter an expression: ")
Enter an expression: 3 + 4 * 5
>>> print ans
23
>>>
Here, when prompted to enter an expression, the user typed +(!3 + 4 * 5.'*# Python evaluated this expression and
stored the value in the variable ans. When printed, we see that ans got the value 23 as expected.
In a way, the input is like a delayed expression. The example interaction produced exactly the same
result as if we had simply done ans = 3 + 4 * 5. The difference is that the expression was supplied
at the time the statement was executed instead of being determined when the statement was written by the
programmer. Thus, the user can supply formulas for a program to evaluate.2.5. ASSIGNMENT STATEMENTS
19
2.5.3 Simultaneous Assignment
There is an alternative form of the assignment statement that allows us to calculate several values all at the
same time. It looks like this:
<var>, <var>, ..., <var> = <expr>, <expr>, ..., <expr>
This is called simultaneous assignment. Semantically, this tells Python to evaluate all the expressions on
the right-hand side and then assign these values to the corresponding variables named on the left-hand side.
Here's an example.
sum, diff = x+y, x-y
Here sum would get the sum of x and y and diff would get the difference.
This form of assignment seems strange at first, but it can prove remarkably useful. Here's an example.
Suppose you have two variables x and y and you want to swap the values. That is, you want the value
currently stored in x to be in y and the value that is currently in y to be stored in x. At first, you might think
this could be done with two simple assignments.
x = y
y = x
This doesn't work. We can trace the execution of these statements step-by-step to see why.
Suppose x and y start with the values 2 and 4. Let's examine the logic of the program to see how the
variables change. The following sequence uses comments to describe what happens to the variables as these
two statements are executed.
#
#
x
#
y
#
variables
initial values
= y
now
= x
final
x
2 y
4
4 4
4 4
See how the first statement clobbers the original value of x by assigning to it the value of y? When we then
assign x to y in the second step, we just end up with two copies of the original y value.
One way to make the swap work is to introduce an additional variable that temporarily remembers the
original value of x.
temp = x
x = y
y = temp
Let's walk-through this sequence to see how it works.
# variables
# initial values
temp = x
#
x = y
#
y = temp
#
x
2 y
4
temp
no value yet
2 4 2
4 4 2
4 2 2
As you can see from the final values of x and y, the swap was successful in this case.
This sort of three-way shuffle is common in other programming languages. In Python, the simultaneous
assignment statement offers an elegant alternative. Here is a simpler Python equivalent:
x, y = y, xCHAPTER 2. WRITING SIMPLE PROGRAMS
20
Because the assignment is simultaneous, it avoids wiping out one of the original values.
Simultaneous assignment can also be used to get multiple values from the user in a single input. Con-
sider this program for averaging exam scores:
# avg2.py
#
A simple program to average two exam scores
#
Illustrates use of multiple input
def main():
print "This program computes the average of two exam scores."
score1, score2 = input("Enter two scores separated by a comma: ")
average = (score1 + score2) / 2.0
print "The average of the scores is:", average
main()
The program prompts for two scores separated by a comma. Suppose the user types 86, 92. The effect of
the input statement is then the same as if we had done this assignment:
score1, score2 = 86, 92
We have gotten a value for each of the variables in one fell swoop. This example used just two values, but it
could be generalized to any number of inputs.
Of course, we could have just gotten the input from the user using separate input statements.
score1 = input("Enter the first score: ")
score2 = input("Enter the second score: ")
In some ways this may be better, as the separate prompts are more informative for the user. In this example
the decision as to which approach to take is largely a matter of taste. Sometimes getting multiple values in a
single input provides a more intuitive user interface, so it is nice technique to have in your toolkit.
2.6 Definite Loops
You already know that programmers use loops to execute a sequence of statements several times in succession.
The simplest kind of loop is called a definite loop. This is a loop that will execute a definite number of times.
That is, at the point in the program when the loop begins, Python knows how many times to go around
(or iterate) the body of the loop. For example, the Chaos program from Chapter 1 used a loop that always
executed exactly ten times.
for i in range(10):
x = 3.9 * x * (1 - x)
print x
This particular loop pattern is called a counted loop, and it is built using a Python for statement. Before
considering this example in detail, let's take a look at what for loops are all about.
A Python for loop has this general form.
for <var> in <sequence>:
<body>
The body of the loop can be any sequence of Python statements. The start and end of the body is indicated
by its indentation under the loop heading (the for <var> in <sequence>: part).
The meaning of the for statement is a bit awkward to explain in words, but is very easy to understand,
once you get the hang of it. The variable after the keyword for is called the loop index. It takes on2.6. DEFINITE LOOPS
21
each successive value in the sequence, and the statements in the body are executed once for each value.
Usually, the sequence portion is a list of values. You can build a simple list by placing a sequence of
expressions in square brackets. Some interactive examples help to illustrate the point:
>>> for i in [0,1,2,3]:
print i
0
1
2
3
>>> for odd in [1, 3, 5, 7, 9]:
print odd * odd
1
9
25
49
81
You can see what is happening in these two examples. The body of the loop is executed using each
successive value in the list. The length of the list determines the number of times the loop will execute. In
the first example, the list contains the four values 0 through 3, and these successive values of i are simply
printed. In the second example, odd takes on the values of the first five odd natural numbers, and the body
of the loop prints the squares of these numbers.
Now, let's go back to the example which began this section (from chaos.py) Look again at the loop
heading:
for i in range(10):
Comparing this to the template for the for loop shows that the last portion, range(10) must be some kind
of sequence. Let's see what the Python interpreter tells us.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Do you see what is happening here? The range function is a built-in Python command that simply produces
a list of numbers. The loop using range(10) is exactly equivalent to one using a list of 10 numbers.
for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:
In general, range(<expr>) will produce a list of numbers that starts with 0 and goes up to, but not
including, the value of <expr>. If you think about it, you will see that the value of the expression determines
the number of items in the resulting list. In chaos.py we did not even care what values the loop index
variable used (since the value of i was not referred to anywhere in the loop body). We just needed a list of
length 10 to make the body execute 10 times.
As I mentioned above, this pattern is called a counted loop, and it is a very common way to use definite
loops. When you want to do something in your program a certain number of times, use a for loop with a
suitable range.
for <variable> in range(<expr>):
The value of the expression determines how many times the loop executes. The name of the index variable
doesn't really matter much; programmers often use i or j as the loop index variable for counted loops. Just
be sure to use an identifier that you are not using for any other purpose. Otherwise you might accidentally
wipe out a value that you will need later.CHAPTER 2. WRITING SIMPLE PROGRAMS
22
The interesting and useful thing about loops is the way that they alter the **%flow of control/,% in a program.
Usually we think of computers as executing a series of instructions in strict sequence. Introducing a loop
causes Python to go back and do some statements over and over again. Statements like the for loop are
called control structures because they control the execution of other parts of the program.
Some programmers find it helpful to think of control structures in terms of pictures called flowcharts. A
flowchart is a diagram that uses boxes to represent different parts of a program and arrows between the boxes
to show the sequence of events when the program is running. Figure 2.1 depicts the semantics of the for
loop as a flowchart.
more items in <sequence>
no
yes
<var> = next item
<body>
Figure 2.1: Flowchart of a for loop.
If you are having trouble understanding the for loop, you might find it useful to study the flowchart.
The diamond shape box in the flowchart represents a decision in the program. When Python gets the the loop
heading, it checks to see if there are any (more) items left if the sequence. If the answer is yes, the value of
the loop index variable is set to the next item in the sequence, and then the loop body is executed. Once the
body is complete, the program goes back to the loop heading and checks for another value in the sequence.
The loop quits when there are no more items, and the program moves on to the statements that come after the
loop.
2.7 Example Program: Future Value
Let's close the chapter with one more example of the programming process in action. We want to develop a
program to determine the future value of an investment. Let's start with an analysis of the problem (require-
ments). You know that money that is deposited in a bank account earns interest, and this interest accumulates
as the years pass. How much will an account be worth ten years from now? Obviously it depends on how
much money we start with (the principal) and how much interest the account earns. Given the principal and
the interest rate, a program should be able to calculate the value of the investment ten years into the future.
We continue by developing the exact specifications for the program. Recall, this is a description of what
the program will do. What exactly should the inputs be? We need the user to enter the initial amount to invest,
the principal. We will also need some indication of how much interest the account earns. This depends both
on the interest rate and how often the interest is compounded. One simple way of handling this is to have the
user enter an annualized percentage rate. Whatever the actual interest rate and compounding frequency, the
annualized rate tells us how much the investment accrues in one year. If the annualized interest is 3%, then a2.7. EXAMPLE PROGRAM: FUTURE VALUE
23
$100 investment will grow to $103 in one year's time. How should the user represent an annualized rate of
3%? There are a number of reasonable choices. Let's assume the user supplies a decimal, so the rate would
be entered as 0.03.
This leads us to the following specification.
Program Future Value
Inputs
principal The amount of money being invested in dollars.
apr The annualized percentage rate expressed as a decimal fraction.
Output The value of the investment 10 years into the future.
Relationship Value after one year is given by principal 1 apr . This formula needs to be applied 10 times.
Next we design an algorithm for the program. We'll use pseudocode, so that we can formulate our ideas
without worrying about all the rules of Python. Given our specification, the algorithm seems straightforward.
Print an introduction
Input the amount of the principal (principal)
Input the annualized percentage rate (apr)
Repeat 10 times:
principal = principal * (1 + apr)
Output the value of principal
Now that we've thought the problem all the way through to pseudocode, it's time to put our new Python
knowledge to work and develop a program. Each line of the algorithm translates into a statement of Python.
Print an introduction (print statement, Section 2.4)
print "This program calculates the future value of a 10-year investment"
Input the amount of the principal (input statement, Section 2.5.2)
principal = input("Enter the initial principal:
Input the annualized percentage rate (input statement, Section 2.5.2)
apr = input("Enter the annualized interest rate:
")
")
Repeat 10 times: (counted loop, Section 2.6)
for i in range(10):
Calculate principal = principal * (1 + apr) (simple assignment statement, Section 2.5.1)
principal = principal * (1 + apr)
Output the value of the principal (print statement, Section 2.4)
print "The amount in 10 years is:", principal
All of the statement types in this program have been discussed in detail in this chapter. If you have any
questions, you should go back and review the relevant descriptions. Notice especially the counted loop
pattern is used to apply the interest formula 10 times.
That about wraps it up. Here is the completed program.
# futval.py
#
A program to compute the value of an investment
#
carried 10 years into the futureCHAPTER 2. WRITING SIMPLE PROGRAMS
24
# by:
John M. Zelle
def main():
print "This program calculates the future value of a 10-year investment."
principal = input("Enter the initial principal: ")
apr = input("Enter the annualized interest rate: ")
for i in range(10):
principal = principal * (1 + apr)
print "The amount in 10 years is:", principal
main()
Notice that I have added a few blank lines to separate the Input, Processing, and Output portions of the
program. Strategically placed *&)white space.%. can help make your programs more readable.
That's about it for this example; I leave the testing and debugging as an exercise for you.
2.8 Exercises
1. List and describe in your own words the six steps in the software development process.
2. Write out the chaos.py program (Section 1.6) and identify the parts of the program as follows:
Circle each identifier.
Underline each expression.
Put a comment at the end of each line indicating the type of statement on that line (output, as-
signment, input, loop, etc.)
3. A user-friendly program should print an introduction that tells the user what the program does. Modify
the convert.py program (Section 2.2) to print an introduction.
4. Modify the avg2.py program (Section 2.5.3) to find the average of three exam scores.
5. Modify the futval.py program (Section 2.7) so that the number of years for the investment is also
a user input. Make sure to change the final message to reflect the correct number of years.
6. Modify the convert.py program (Section 2.2) with a loop so that it executes 5 times before quitting
(i.e., it converts 5 temperatures in a row).
7. Modify the convert.py program (Section 2.2) so that it computes and prints a table of Celsius
temperatures and the Fahrenheit equivalents every 10 degrees from 0C to 100C.
8. Write a program that converts from Fahrenheit to Celsius.
9. Modify the futval.py program (Section 2.7) so that it computes the actual purchasing power of
the investment, taking inflation into account. The yearly rate of inflation will be a second input. The
adjustment is given by this formula:
principal = principal/(1 + inflation)Chapter 3
Computing with Numbers
When computers were first developed, they were seen primarily as number crunchers, and that is still an
important application. As you have seen, problems that involve mathematical formulas are easy to translate
into Python programs. This chapter takes a closer look at computations involving numeric calculations.
3.1 Numeric Data Types
The information that is stored and manipulated by computer programs is generically referred to as data.
Different kinds of data will be stored and manipulated in different ways. Consider this program that calculates
the value of loose change.
# change.py
#
A program to calculate the value of some change in dollars
def main():
print "Change Counter"
print
print "Please enter the count of each coin type."
quarters = input("Quarters: ")
dimes = input("Dimes: ")
nickels = input("Nickels: ")
pennies = input("Pennies: ")
total = quarters * .25 + dimes * .10 + nickels * .05 + pennies * .01
print
print "The total value of your change is", total
main()
Here is an example of the output.
Change Counter
Please enter the count of each coin type.
Quarters: 5
Dimes: 3
Nickels: 4
Pennies: 6
The total value of your change is 1.81
This program actually manipulates two different kinds of numbers. The values entered by the user (5, 3,
4, 6) are are whole numbers; they don't have any fractional part. The values of the coins (.25, .10, .05, .01)
25CHAPTER 3. COMPUTING WITH NUMBERS
26
are decimal fractions. Inside the computer, whole numbers and numbers that have fractional components are
represented differently. Technically, we say that these are two different data types.
The data type of an object determines what values it can have and what operations can be performed on it.
Whole numbers are represented using the integer data type (int for short). Values of type int can be positive
or negative whole numbers. Numbers that can have fractional parts are represented as floating point (or float)
values. So how do we tell whether a number is an int or a float? A numeric literal that does not contain a
decimal point produces an int value, while a literal that has a decimal point is represented by a float (even if
the fractional part is 0).
Python provides a special function called type that tells us the data type of any value. Here is an
interaction with the Python interpreter showing the difference between int and float literals.
>>> type(3)
<type $%$int*),>
>>> type(3.14)
<type -'+float$,*>
>>> type(3.0)
<type ,/*float,-$>
>>> myInt = -32
>>> type(myInt)
<type ''-int#&">
>>> myFloat = 32.0
>>> type(myFloat)
<type '''float'&+>
You may be wondering why there are two different data types for numbers. One reason has to do with
program style. Values that represent counts can't be fractional; we can't have 3 12 quarters, for example. Using
an int value tells the reader of a program that the value can't be a fraction. Another reason has to do with the
efficiency of various operations. The underlying algorithms that perform computer arithmetic are simpler,
and therefore faster, for ints than the more general algorithms required for float values.
You should be warned that the float type only stores approximations. There is a limit to the precision, or
accuracy, of the stored values. Since float values are not exact, while ints always are, your general rule of
thumb should be: if you don't absolutely need fractional values, use an int.
operator
%)'
%
abs()
operation
addition
subtraction
multiplication
division
exponentiation
remainder
absolute value
Table 3.1: Python built-in numeric operations.
A value's data type determines what operations can be used on it. As we have seen, Python supports
the usual mathematical operations on numbers. Table 3.1 summarizes these operations. Actually, this table
is somewhat misleading since the two numeric data types have their own operations. When addition is
performed on floats, the computer performs a floating point addition. Whereas, with ints, the computer
performs an integer addition.
Consider the following interaction with Python:
>>> 3.0 + 4.0
7.0
>>> 3 + 4
73.2. USING THE MATH LIBRARY
27
>>> 3.0 * 4.0
12.0
>>> 3 * 4
12
>>> 10.0 / 3.0
3.33333333333
>>> 10 / 3
3
>>> 10 % 3
1
>>> abs(5)
5
>>> abs(-3.5)
3.5
Notice how operations on floats produce floats, and operations on ints produce ints. Most of the time, we
don't have to worry about what type of operation is being performed; for example, integer addition produces
pretty much the same result as floating point addition.
However, in the case of division, the results are quite different. Integer division always produces an
integer, discarding any fractional result. Think of integer division as /+!gozinta.,/. The expression, 10 / 3
produces 3 because three gozinta (goes into) ten three times (with a remainder of one). The third to last
example shows the remainder operation (%) in action. The remainder of dividing 10 by 3 is 1. The last two
examples illustrate taking the absolute value of an expression.
You may recall from Chapter 2 that Suzie Programmer used the expression 9.0 / 5.0 in her tempera-
ture conversion program rather than 9 / 5. Now you know why. The former gives the correct multiplier of
1 8, while the latter yields just 1, since 5 gozinta 9 just once.
3.2 Using the Math Library
Besides the operations listed in Table 3.1, Python provides many other useful mathematical functions in a
special math library. A library is just a module that contains some useful definitions. Our next program
illustrates the use of this library to compute the roots of quadratic equations.
A quadratic equation has the form ax 2 bx c 0. Such an equation has two solutions for the value of
x given by the quadratic formula:
b
b 2 4ac
x
2a
Let's write a program that can find the solutions to a quadratic equation. The input to the program will be the
values of the coefficients a, b, and c. The outputs are the two values given by the quadratic formula. Here's a
program that does the job.
.*#
# quadratic.py
#
A program that computes the real roots of a quadratic equation.
#
Illustrates use of the math library.
#
Note: this program crashes if the equation has no real roots.
import math
# Makes the math library available.
def main():
print "This program finds the real solutions to a quadratic"
print
a, b, c = input("Please enter the coefficients (a, b, c): ")
discRoot = math.sqrt(b * b - 4 * a * c)CHAPTER 3. COMPUTING WITH NUMBERS
28
root1 = (-b + discRoot) / (2 * a)
root2 = (-b - discRoot) / (2 * a)
print
print "The solutions are:", root1, root2
main()
This program makes use of the square root function sqrt from the math library module. The line at the
top of the program:
import math
tells Python that we are using the math module. Importing a module makes whatever is defined in it available
to the program. To compute x, we use math.sqrt(x). You may recall this dot notation from Chapter 1.
This tells Python to use the sqrt function that /&"lives)). in the math module. In the quadratic program we
calculate b 2 4   ac with the line
discRoot = math.sqrt(b * b - 4 * a * c)
Here is how the program looks in action:
This program finds the real solutions to a quadratic
Please enter the coefficients (a, b, c): 3, 4, -2
The solutions are: 0.387425886723 -1.72075922006
This program is fine as long as the quadratics we try to solve have real solutions. However, some inputs
will cause the program to crash. Here's another example run:
This program finds the real solutions to a quadratic
Please enter the coefficients (a, b, c): 1, 2, 3
Traceback (innermost last):
File "<stdin>", line 1, in ?
File "quadratic.py", line 13, in ?
discRoot = math.sqrt(b * b - 4 * a * c)
OverflowError: math range error
The problem here is that b 2 4   a   c 0, and the sqrt function is unable to compute the square root of
a negative number. Python prints a math range error. Right now, we don't have the tools to fix this
problem, so we will just have to assume that the user gives us solvable equations.
Actually, quadratic.py did not need to use the math library. We could have taken the square root
using exponentiation **. (Can you see how?) Using math.sqrt is somewhat more efficient and allowed
me to illustrate the use of the math library. In general, if your program requires a common mathematical
function, the math library is the first place to look. Table 3.2 shows some of the other functions that are
available in the math library.
3.3 Accumulating Results: Factorial
Suppose you have a root beer sampler pack containing six different kinds of root beer. Drinking the various
flavors in different orders might affect how good they taste. If you wanted to try out every possible ordering,
how many different orders would there be? It turns out the answer is a surprisingly large number, 720. Do
you know where this number comes from? The value 720 is the factorial of 6.
In mathematics, factorial is often denoted with an exclamation ($/-!""#). The factorial of a whole number n
1 . This happens to be the number of distinct arrangements for n items.
is defined as n! n n 1 n 2
Given six items, we compute 6!
6 5 4 3 2 1
720 possible arrangements.3.3. ACCUMULATING RESULTS: FACTORIAL
Python
pi
e
sin(x)
cos(x)
tan(x)
asin(x)
acos(x)
atan(x)
log(x)
log10(x)
exp(x)
ceil(x)
floor(x)
Mathematics
*!
e
sin x
cos x
tan x
arcsinx
arccosx
arctanx
ln x
log 10 x
e x
x
x
29
English
An approximation of pi.
An approximation of e.
The sine of x.
The cosine of x.
The tangent of x.
The inverse of sine x.
The inverse of cosine x.
The inverse of tangent x.
The natural (base e) logarithm of x
The common (base 10) logarithm of x.
The exponential of x.
The smallest whole number
x
The largest whole number
x
Table 3.2: Some math library functions.
Let's write a program that will compute the factorial of a number entered by the user. The basic outline
of our program follows an Input-Process-Output pattern.
Input number to take factorial of, n
Compute factorial of n, fact
Output fact
Obviously, the tricky part here is in the second step.
How do we actually compute the factorial? Let's try one by hand to get an idea for the process. In
computing the factorial of 6, we first multiply 6   5 30. Then we take that result and do another multipli-
cation 30   4 120. This result is multiplied by three 120   3 360. Finally, this result is multiplied by 2
360   2 720. According to the definition, we then multiply this result by 1, but that won't change the final
value of 720.
Now let's try to think about the algorithm more generally. What is actually going on here? We are doing
repeated multiplications, and as we go along, we keep track of the running product. This is a very common
algorithmic pattern called an accumulator. We build up, or accumulate, a final value piece by piece. To
accomplish this in a program, we will use an accumulator variable and a loop structure. The general pattern
looks like this.
Initialize the accumulator variable
Loop until final result is reached
update the value of accumulator variable
Realizing this is the pattern that solves the factorial problem, we just need to fill in the details. We will
be accumulating the factorial. Let's keep it in a variable called fact. Each time through the loop, we need
to multiply fact by one of the factors n "!' n 1 .#$.!# )!&/'+ 1. It looks like we should use a for loop that iterates
over this sequence of factors. For example, to compute the factorial of 6, we need a loop that works like this.
fact = 1
for factor in [6,5,4,3,2,1]:
fact = fact * factor
Take a minute to trace through the execution of this loop and convince yourself that it works. When the
loop body first executes, fact has the value 1 and factor is 6. So, the new value of fact is 1   6 6.
The next time through the loop, factor will be 5, and fact is updated to 6   5 30. The pattern continues
for each successive factor until the final result of 720 has been accumulated.
The initial assignment of 1 to fact before the loop is essential to get the loop started. Each time
through the loop body (including the first), the current value of fact is used to compute the next value. The30
CHAPTER 3. COMPUTING WITH NUMBERS
initialization ensures that fact has a value on the very first iteration. Whenever you use the accumulator
pattern, make sure you include the proper initialization. Forgetting it is a common mistake of beginning
programmers.
Of course, there are many other ways we could have written this loop. As you know from math class,
multiplication is commutative and associative, so it really doesn't matter what order we do the multiplications
in. We could just as easily go the other direction. You might also notice that including 1 in the list of factors
is unnecessary, since multiplication by 1 does not change the result. Here is another version that computes
the same result.
fact = 1
for factor in [2,3,4,5,6]:
fact = fact * factor
Unfortunately, neither of these loops solves the original problem. We have hand-coded the list of factors
to compute the factorial of six. What we really want is a program that can compute the factorial of any given
input n. We need some way to generate an appropriate list from the value of n.
Luckily, this is quite easy to do using the Python range function. Recall that range(n) produces a list
of numbers starting with 0 and continuing up to, but not including, n. There are other variations of range that
can be used to produce different sequences. With two parameters, range(start,n) produces a sequence
that starts with the value start and continues up to, but not including, n. A third version range(start,
n, step) is like the two parameter version, except that it uses step as the increment between numbers.
Here are some examples.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(5,10)
[5, 6, 7, 8, 9]
>>> range(5, 10, 3)
[5, 8]
Given our input value n we have a couple of different range commands that produce an appropriate list
of factors for computing the factorial of n. To generate them from smallest to largest (a la our second loop),
we could use range(2,n+1). Notice how I used n+1 as the second parameter, since the range will go up
to, but not including this value. We need the +1 to make sure that n itself is included as the last factor.
Another possibility is to generate the factors in the other direction (a la our first loop) using the three-
parameter version of range and a negative step to cause the counting to go backwards: range(n,1,-1).
This one produces a list starting with n and counting down (step -1) to, but not including 1.
Here then is one possible version of the factorial program.
# factorial.py
#
Program to compute the factorial of a number
#
Illustrates for loop with an accumulator
def main():
n = input("Please enter a whole number: ")
fact = 1
for factor in range(n,1,-1):
fact = fact * factor
print "The factorial of", n, "is", fact
main()
Of course there are numerous other ways this program could have been written. I have already mentioned
changing the order of factors. Another possibility is to initialize fact to n and then use factors starting at
n 1 (as long as n   0). You might try out some of these variations and see which you like best.3.4. THE LIMITS OF INT
31
3.4 The Limits of Int
So far, I have talked about numeric data types as representations of familiar numbers such as integers and
decimal fractions. It is important to keep in mind, however, that these numeric types are just representations,
and they do not always behave exactly like the numbers that they represent. We can see an example of this as
we test out our new factorial program.
>>> import factorial
Please enter a whole number: 6
The factorial of 6 is 720
>>> factorial.main()
Please enter a whole number: 10
The factorial of 10 is 3628800
>>> factorial.main()
Please enter a whole number: 13
Traceback (innermost last):
File "<stdin>", line 1, in ?
File "factorial.py", line 9, in main
fact = fact * factor
OverflowError: integer multiplication
Everything seems fine until we try to compute the factorial of 13. When computing 13! the program prints
out an OverflowError message. What is going on here?
The problem is that this program is representing whole numbers using Python's int data type. Unfortu-
nately, ints are not exactly like mathematical integers. There are infinitely many integers, but only a finite
range of ints. Inside the computer, ints are stored in a fixed-sized binary representation. To make sense of
this, we need to look at what's going on at the hardware level.
Computer memory is composed of electrical ))+switches,."+ each of which can be in one of two possible
states, basically on or off. Each switch represents a binary digit or bit of information. One bit can encode two
possibilities, usually represented with the numerals 0 (for off) and 1 (for on). A sequence of bits can be used
to represent more possibilities. With two bits, we can represent four things.
bit 2
0
0
1
1
bit 1
0
1
0
1
Three bits allow us to represent eight different values by adding a zero or one to each of the four two-bit
patterns.
bit 3 bit 2 bit 1
0
0
0
0
0
1
0
1
0
0
1
1
1
0
0
1
0
1
1
1
0
1
1
1
You can see the pattern here. Each extra bit doubles the number of distinct patterns. In general, n bits can
represent 2 n different values.
The number of bits that a particular computer uses to represent an int depends on the design of the CPU.
Typical PCs today use 32 bits. That means there are 2 32 possible values. These values are centered at 0 toCHAPTER 3. COMPUTING WITH NUMBERS
32
32
represent a range of positive and negative integers. Now 2 2
2 31 . So, the range of integers that can be
31
31
represented in a 32 bit int value is 2
2
1. The reason for the 1 on the high end is to account for
the representation of 0 in the top half of the range.
Let's try out some expressions in Python to test this analysis. Remember that ** is the Python exponen-
tiation operator.
>>> 2 ** 30
1073741824
>>> 2 ** 31
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: integer pow()
Python can calculate 2 30 , but /'/blows up.$( trying to compute 2 31 . You can see that the overflow happens
somewhere between the 30th and 31st power of two. That is consistent with our analysis that the largest int
is 2 31 1.
Suppose we try to display the largest int.
>>> 2 ** 31 - 1
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: integer pow()
Our first try didn't work. Can you see why? Python evaluates this expression by first trying to calculate 2
** 31. That calculation produces the error before Python has a chance to subtract one.
We need to be a little cleverer and sneak up on the value from underneath. We can use the fact that
2 31 2 30 2 30 . Strategically subtracting one from each side gives us 2 31 1 2 30 1 2 30 . By subtracting
one in the middle of the computation, we can ensure that the intermediate value never gets bigger than the
final result. Here's what Python says:
>>> 2 ** 30 - 1 + 2 ** 30
2147483647
By the way, this expression illustrates another way that Python ints differ from the integers that they
represent. In normal arithmetic, there is no difference between 2 31 1 and 2 30 1 2 30 . They both represent
the same value. In computer arithmetic, however, one is computable and the other is not! Representations of
numbers do not always obey all the properties that we take for granted with numbers.
Now that we have a numeric value, we can directly test our conjecture that this is the largest int.
>>> 2147483647
2147483647
>>> 2147483648
OverflowError: integer literal too large
There you have it. The largest int that can be represented in 32 bits is 2 !." 147 !') 483 .%+ 647.
Now you know exactly why our program for factorial can't compute 13!. This value is larger than the
limit of 2 "#+ 147 ,,$ 483 "#" 647. Naturally, the next step is to figure out a way around this limitation.
3.5 Handling Large Numbers: Long Ints
As long as our factorial program relies on the int data type, we will not be able to find the factorial of larger
numbers. We need to use another numeric type. You might first think of using a float instead. This does not
really solve our problem. Here is an example run of a modified factorial program that initializes fact to the
float 1 0.3.5. HANDLING LARGE NUMBERS: LONG INTS
33
Please enter a whole number. 15
The factorial of 15 is 1.307674368e+12
We do not get an overflow error, but we also do not get an exact answer.
A very large (or very small) floating point value is printed out using exponential, or scientific, notation.
The e+12 at the end means that the result is equal to 1 307674368 10 12 . You can think of the +12 at the
end as a marker that shows where the decimal point should be placed. In this case, it must move 12 places to
the right to get the actual value. However, there are only 9 digits to the right of the decimal, so we have %,"lost/"#
the last three digits.
Remember, floats are approximations. Using a float allows us to represent a much larger range of values,
but the amount of precision is still fixed. In fact, a computer stores floating point numbers as a pair of fixed-
length (binary) integers. One integer represents the string of digits in the value, and the second represents the
exponent value that keeps track of where the whole part ends and the fractional part begins.
Fortunately, Python provides a better solution for large, exact values in the form of a third numeric type
long int. A long int is not a fixed size, but expands to accommodate whatever value it holds. The only limit is
the amount of memory the computer has available to it. To get a long int, you put an "!!L!', suffix on a numeric
literal. So, the literal 5 is an int representation of the number five, but 5L is a long int representation of the
number five. Of course, for a number this small, there is no reason to use a long int. However, using a long
int causes Python to use long int operations, and our value can grow to any size. Here are some examples that
illustrate:
>>> 2L
2L
>>> 2L ** 31
2147483648L
>>> type(100L)
<type ('*long int!.(>
>>> 10000000000000000000000000000000000000L + 25
10000000000000000000000000000000000025L
Notice how calculations involving a long int produce a long int result. Using long ints allows us to compute
with really large numbers.
We can modify our factorial program to use long int by simply initializing fact to 1L. Since we start
with a long int, each successive multiplication will produce another long int.
# factorial2.py
def main():
n = input("Please enter a whole number: ")
fact = 1L
# Use a long int here
for factor in range(n,0,-1):
fact = fact * factor
print "The factorial of", n, "is", fact
Now we can take the factorial of arbitrarily large inputs.
>>> import factorial2
Please enter a whole number: 13
The factorial of 13 is 6227020800
>>> factorial2.main()
Please enter a whole number: 100
The factorial of 100 is 933262154439441526816992388562667004907159682
643816214685929638952175999932299156089414639761565182862536979208272
2375825118521091686400000000000000000000000034
CHAPTER 3. COMPUTING WITH NUMBERS
If you have an older version of Python (prior to version 2.0), these answers will be printed with an )$,L+&.
appended. This is Python's way of saying that the number is a long int. In newer versions, this artifact is
automatically removed by the print statement. In the next chapter, you will learn how you could take care
of getting the ')"L""% out yourself.
Now we have a factorial program that can compute interestingly large results. Long ints are pretty cool;
you might be tempted to use them all the time. The down-side of using long ints is that these representations
are less efficient than the plain int data type. The operations needed to do arithmetic on ints is built into the
CPU of the computer. When doing operations on long ints, Python has to employ algorithms that simulate
long arithmetic using the computer's built-in fixed-length operations. As a result, long int arithmetic is much
slower than int arithmetic. Unless you need very large values, ints are preferred.
3.6 Type Conversions
Sometimes values of one data type need to be converted into another. You have seen that combining an int
with an int produces an int, and combining a float with a float creates another float. But what happens if
we write an expression that mixes an int with a float? For example, what should the value of x be after this
assignment statement?
x = 5.0 / 2
If this is floating point division, then the result should be the float value 2 5. If integer division is performed,
the result is 2. Before reading ahead for the answer, take a minute to consider how you think Python should
handle this situation.
In order to make sense of the expression 5.0 / 2, Python must either change 5.0 to 5 and perform
integer division or convert 2 to 2.0 and perform floating point division. In general, converting a float to an
int is a dangerous step, because some information (the fractional part) will be lost. On the other hand, an int
can be safely turned into a float just by adding a fractional part of 0. So, in mixed-typed expressions, Python
will automatically convert ints to floats and perform floating point operations to produce a float result.
Sometimes we may want to perform a type conversion ourselves. This is called an explicit type conver-
sion. For example, suppose we are writing a program that finds the average of some numbers. Our program
would first sum up the numbers and then divide by n, the count of how many numbers there are. The line of
code to compute the average might look like this.
average = sum / n
Unfortunately, this line may not always produce the result we intend.
Consider a specific example. The numbers to be averaged are the ints 4, 5, 6, 7. The sum variable
will hold 22, also an int, and dividing by 4 gives the answer 5, not 5.5. Remember, an int divided by an int
always produces an int.
To solve this problem, we need to tell Python to convert one of the operands to a floating point value.
average = float(sum) / n
The float() function converts an int into a float. We only need to convert the numerator, because this
produces a mixed-type expression, and Python will automatically convert the denominator.
Notice that putting the float() around the entire expression would not work.
average = float(sum/n)
In this form, sum and n could both be ints causing Python to perform an integer division and then convert
the resulting quotient to a float. Of course, this float would always end in 0, since it is being converted from
an int. That is not what we want.
Python also provides int() and long() functions that can be used to convert numbers into ints and
longs, respectively. Here are a few examples.3.7. EXERCISES
>>>
4
>>>
3
>>>
3L
>>>
3.0
>>>
3
>>>
3
35
int(4.5)
int(3.9)
long(3.9)
float(int(3.3))
int(float(3.3))
int(float(3))
As you can see, converting to an int or long int simply discards the fractional part of a float; the value is
truncated, not rounded. If you want a rounded result, you can add 0.5 to the value before using int(),
assuming the value is positive.
A more general way of rounding off numbers is to use the built-in round function which rounds a float
off to the nearest whole value.
>>> round(3.14)
3.0
>>> round(-3.14)
-3.0
>>> round(3.5)
4.0
>>> round(-3.5)
-4.0
>>> int(round(-3.14))
-3
Notice that round returns a float. The last example shows how the result can then be turned into an int value,
if necessary, by using int().
3.7 Exercises
1. Show the result of evaluating each expression. Be sure that the value is in the proper form to indicate
its type (int, long int, or float). If the expression is illegal, explain why.
(a) 4.0 / 10.0 + 3.5 * 2
(b) 10 % 4 + 6 / 2
(c) abs(4 - 20 / 3) ** 3
(d) sqrt(4.5 - 5.0) + 7 * 3
(e) 3 * 10 / 3 + 10 % 3
(f) 3L ** 3
2. Translate each of the following mathematical expressions into an equivalent Python expression. You
may assume that the math library has been imported (via import math).
(a) 3 4   5
(b)
(c)
n n 1
2
4 #& r 2
2
(d)
(e)
r cos a
y2 y1
x2 x1
2
r sinaCHAPTER 3. COMPUTING WITH NUMBERS
36
3. Show the list of numbers that would be generated by each of the following range expressions.
(a) range(5)
(b) range(3, 10)
(c) range(4, 13, 3)
(d) range(15, 5, -2)
(e) range(5, 3)
4. Show the output that would be generated by each of the following program fragments.
(a) for i in range(1, 11):
print i*i
(b) for i in [1,3,5,7,9]:
print i, ":", i**3
print i
(c) x = 2
y = 10
for j in range(0, y, x):
print j,
print x + y
print "done"
(d) ans = 0
for i in range(1, 11):
ans = ans + i*i
print i
print ans
5. Write a program to calculate the volume and surface area of a sphere from its radius, given as input.
Here are some formulas that might be useful: V 4 3 ($ r 3 A 4 ,) r 2
6. Write a program that calculates the cost per square inch of a circular pizza, given its diameter and price.
A -. r 2
7. Write a program that determines the molecular weight of a hydrocarbon based on the number of hy-
drogen, carbon, and oxygen atoms. You should use the following weights:
Atom
H
C
O
Weight
(grams / mole)
1.0079
12.011
15.9994
8. Write a program that determines the distance to a lighting strike based on the time elapsed between the
flash and the sound of thunder. The speed of sound is approximately 1100 ft/sec and 1 mile is 5280 ft.
9. The Konditorei coffee shop sells coffee at $10.50 a pound plus the cost of shipping. Each order ships
for $0.86 per pound + $1.50 fixed cost for overhead. Write a program that calculates the cost of an
order.
10. Two points in a plane are specified using the coordinates (x1,y1) and (x2,y2). Write a program that
y1
calculates the slope of a line through two (non-vertical) points entered by the user. m y2
x2 x1
11. Write a program that accepts two points (see previous problem) and determines the distance between
x2 x1 2 y2 y1 2
them. d3.7. EXERCISES
37
12. The Gregorian Epact is the number of days between Jan. 1st and the previous 1st quarter moon phase.
This value is used to figure out the date of Easter. It is calculated by these formulas (using int arith-
8 C 4 C
8C 13 25 11 year%19 %30 Write a program
metic): C year 100 epact
that prompts the user for a 4-digit year and then outputs the value of the epact.
13. Write a program to calculate the area of a triangle given the length of its three sides a, b, and c.
s a 2 b c A
s s a s b s c
14. Write a program to determine the length of a ladder required to reach a given height when leaned
against a house. The height and angle of the ladder are given as inputs. len sin height
angle
15. Write a program to find the sum of the first n natural numbers, where the value of n is provided by the
user.
16. Write a program to find the sum of the squares for the first n natural numbers.
17. Write a program to sum a series of numbers entered by the user. The program should first prompt the
user for how many numbers are to be summed. It should then input each of the numbers and print a
total sum.
18. Write a program that finds the average of a series of numbers entered by the user. As in the previous
problem, the program will first ask the user how many numbers there are. Note: the average should
always be a float, even if the user inputs are all ints.
19. Write a program that approximates the value of "- by summing the terms of this series: 4 1 4 3
4 5 4 7 4 9 4 11
The program should prompt the user for n, the number of terms to sum
and then output the sum of the first n terms of this series.
20. A Fibonacci sequence is a sequence of numbers where each successive number is the sum of the
previous two. The classic Fibonacci sequence begins: 1, 1, 2, 3, 5, 8, 13, . Write a program that
computes the nth Fibonacci number where n is a value input by the user. For example, if n = 6, then the
result is 8. Note: Fibonacci numbers grow very rapidly; your program should be able to handle very
large numbers.
21. You have seen that the math library contains a function that computes the square root of numbers. In
this exercise, you are to write your own algorithm for computing square roots. One way to solve this
problem is to use a guess-and-check approach. You first guess what the square root might be and then
see how close your guess is. You can use this information to make another guess and continue guessing
until you have found the square root (or a close approximation to it). One particularly good way of
making guesses is to use Newton's method. Suppose x is the number we want the root of, and guess
x
guess guess
2
is the current guessed answer. The guess can be improved by using
as the next guess.
Write a program that implements Newton's method. The program should prompt the user for the value
to find the square root of (x) and the number of times to improve the guess. Starting with a guess value
of x/2, your program should loop the specified number of times applying Newton's method and report
the final value of guess. You might also print out the value of math.sqrt(x) for comparison.38
CHAPTER 3. COMPUTING WITH NUMBERSChapter 4
Computing with Strings
So far, we have been discussing programs designed to manipulate numbers. These days we know that com-
puters are also useful for working with other kinds of data. In fact, the most common use for most personal
computers is word processing. The data in this case is text. Text is represented in programs by the string data
type, which is the subject of this chapter.
4.1 The String Data Type
A string is a sequence of characters. In Chapter 2 you learned that a string literal is a sequence of characters in
quotations. Python also allows strings to be delimited by single quotes (apostrophes). There's no difference.()
just be sure to use a matching set. Strings can be stored in variables, just like numbers. Here are some
examples illustrating these two forms of string literals.
>>> str1 = "Hello"
>>> str2 = .&*spam.+"
>>> print str1, str2
Hello spam
>>> type(str1)
<type /.%string*+$>
>>> type(str2)
<type ($,string)&!>
You already know how to print strings. Some programs also need to get string input from the user (e.g.,
a name). Getting string-valued input requires a bit of care. Remember that the input statement treats
whatever the user types as an expression to be evaluated. Consider the following interaction.
>>> firstName = input("Please
Please enter your name: John
Traceback (innermost last):
File "<pyshell#8>", line 1,
firstName = input("Please
File "<string>", line 0, in
NameError: John
enter your name: ")
in ?
enter your name: ")
?
Something has gone wrong here. Can you see what the problem is?
Remember, an input statement is just a delayed expression. When I entered the name, #+(John-/), this had
the exact same effect as executing this assignment statement:
firstName = John
This statement says, *-*look up the value of the variable John and store that value in firstName./#" Since
John was never given a value, Python cannot find any variable with that name and responds with a NameError.
One way to fix this problem is to type quotes around a string input so that it evaluates as a string literal.
39CHAPTER 4. COMPUTING WITH STRINGS
40
>>> firstName = input("Please enter your name: ")
Please enter your name: "John"
>>> print "Hello", firstName
Hello John
This works, but it is not a very satisfactory solution. We shouldn't have to burden the users of our programs
with details like typing quotes around their names.
Python provides a better mechanism. The raw input function is exactly like input except it does not
evaluate the expression that the user types. The input is simply handed to the program as a string of text.
Revisiting our example, here is how it looks with raw input:
>>> firstName = raw_input("Please enter your name: ")
Please enter your name: John
>>> print "Hello", firstName
Hello John
Notice that this example works as expected without having to type quotes around the input. If you want to
get textual input from the user, raw input is the way to do it.
So far, we have seen how to get strings as input, assign them to variables and print them out. That's
enough to write a parrot program, but not to do any serious text-based computing. For that, we need some
string operations. The rest of this section takes you on a tour of the more important Python string operations.
In the following section, we'll put these ideas to work in some example programs.
While the idea of numeric operations may be old hat to you from your math studies, you may not have
thought about string operations before. What kinds of things can we do with strings?
For starters, remember what a string is: a sequence of characters. One thing we might want to do is
access the individual characters that make up the string. In Python, this can be done through the operation of
indexing. We can think of the positions in a string as being numbered, starting from the left with 0. Figure 4.1
H 0 e l l 2 o 3 4 B 5 6 o 7 b 8
Figure 4.1: Indexing of the string /(.Hello Bob"')
illustrates with the string *&'Hello Bob./'# Indexing is used in string expressions to access a specific character
position in the string. The general form for indexing is <string>[<expr>]. The value of the expression
determines which character is selected from the string.
Here are some interactive indexing examples:
>>>
>>>
*/-H&(#
>>>
H l
>>>
>>>
B
greet = "Hello Bob"
greet[0]
print greet[0], greet[2], greet[4]
o
x = 8
print greet[x-2]
Notice that, in a string of n characters, the last character is at position n 1, because the indexes start at 0.
Indexing returns a string containing a single character from a larger string. It is also possible to access
a contiguous sequence of characters or substring from a string. In Python, this is accomplished through an
operation called slicing. You can think of slicing as a way of indexing a range of positions in the string.
Slicing takes the form string   [ start   : end   ]. Both start and end should be int-valued
expressions. A slice produces the substring starting at the position given by start and running up to, but
not including, position end.
Continuing with our interactive example, here are some slices.4.2. SIMPLE STRING PROCESSING
41
>>> greet[0:3]
'#&Hel&/,
>>> greet[5:9]
.*) Bob/!#
>>> greet[:5]
(/+Hello&!)
>>> greet[5:]
&#& Bob%",
>>> greet[:]
'++Hello Bob+!+
The last three examples show that if either expression is missing, the start and end of the string are the
assumed defaults. The final expression actually hands back the entire string.
Indexing and slicing are useful operations for chopping strings into smaller pieces. The string data type
also supports operations for putting strings together. Two handy operators are concatenation (+) and repetition
(*). Concatenation builds a string by ..-gluing+,, two strings together. Repetition builds a string by multiple
concatenations of a string with itself. Another useful function is len, which tells how many characters are
in a string. Here are some examples:
>>> "spam" + "eggs"
'"-spameggs'"-
>>> "Spam" + "And" + "Eggs"
)!%SpamAndEggs+',
>>> 3 * "spam"
+$.spamspamspam!(/
>>> "spam" * 5
%&"spamspamspamspamspam/"*
>>> (3 * "spam") + ("eggs" * 5)
"'(spamspamspameggseggseggseggseggs.)+
>>> len("spam")
4
>>> len("SpamAndEggs")
11
>>>
These basic string operations are summarized in Table 4.1.
Operator
+
*
string   [ ]
len( string   )
string   [ : ]
Meaning
Concatenation
Repetition
Indexing
length
slicing
Table 4.1: Python string operations
4.2 Simple String Processing
Now that you have an idea what string operations can do, we're ready to write some programs. Our first
example is a program to compute the usernames for a computer system.
Many computer systems use a username and password combination to authenticate system users. The
system administrator must assign a unique username to each user. Often, usernames are derived from the
user's actual name. One scheme for generating usernames is to use the user's first initial followed by upCHAPTER 4. COMPUTING WITH STRINGS
42
to seven letters of the user's last name. Using this method, the username for Elmer Thudpucker would be
#/-ethudpuc,/-. and John Smith would just be %-.jsmith.!),
We want to write a program that reads a person's name and computes the corresponding username. Our
program will follow the basic input-process-output pattern. The result is simple enough that we can skip the
algorithm development and jump right to the code. The outline of the algorithm is included as comments in
the final program.
# username.py
#
Simple string processing program to generate usernames.
def main():
print "This program generates computer usernames."
print
# get user's first and last names
first = raw_input("Please enter your first name (all lowercase): ")
last = raw_input("Please enter your last name (all lowercase): ")
# concatenate first initial with 7 chars of the last name.
uname = first[0] + last[:7]
# output the username
print "Your username is:", uname
main()
This program first uses raw input to get strings from the user. Then indexing, slicing, and concatenation
are combined to produce the username.
Here's an example run.
This program generates computer usernames.
Please enter your first name (all lowercase): elmer
Please enter your last name (all lowercase): thudpucker
Your username is: ethudpuc
As you can see, computing with strings is very similar to computing with numbers.
Here is another problem that we can solve with string operations. Suppose we want to print the abbrevia-
tion of the month that corresponds to a given month number. The input to the program is an int that represents
a month number (1,$(12), and the output is the abbreviation for the corresponding month. For example, if the
input is 3, then the output should be Mar, for March.
At first, it might seem that this program is beyond your current ability. Experienced programmers recog-
nize that this is a decision problem. That is, we have to decide which of 12 different outputs is appropriate,
based on the number given by the user. We will not cover decision structures until later; however, we can
write the program now by some clever use of string slicing.
The basic idea is to store all the month names in a big string.
months = "JanFebMarAprMayJunJulAugSepOctNovDec"
We can lookup a particular month by slicing out the appropriate substring. The trick is computing where to
slice. Since each month is represented by three letters, if we knew where a given month started in the string,
we could easily extract the abbreviation.
monthAbbrev = months[pos:pos+3]
This would get us the substring of length three that starts in the position indicated by pos.
How do we compute this position? Let's try a few examples and see what we find. Remember that string
indexing starts at 0.4.3. STRINGS AND SECRET CODES
month
Jan
Feb
Mar
Apr
43
number
1
2
3
4
position
0
3
6
9
Of course, the positions all turn out to be multiples of 3. To get the correct multiple, we just subtract 1
from the month number and then multiply by 3. So for 1 we get 1 1   3 0   3 0 and for 12 we have
12 1   3 11   3 33
Now we're ready to code the program. Again, the final result is short and sweet; the comments document
the algorithm we've developed.
# month.py
# A program to print the abbreviation of a month, given its number
def main():
# months is used as a lookup table
months = "JanFebMarAprMayJunJulAugSepOctNovDec"
n = input("Enter a month number (1-12): ")
# compute starting position of month n in months
pos = (n-1) * 3
# Grab the appropriate slice from months
monthAbbrev = months[pos:pos+3]
# print the result
print "The month abbreviation is", monthAbbrev + "."
main()
Notice the last line of this program uses string concatenation to put a period at the end of the month abbrevi-
ation.
Here is a sample of program output.
Enter a month number (1-12): 4
The month abbreviation is Apr.
4.3 Strings and Secret Codes
4.3.1 String Representation
Hopefully, you are starting to get the hang of computing with textual (string) data. However, you might still
be wondering how computers actually manipulate strings. In the previous chapter, you saw how computers
store numbers in binary notation (sequences of zeros and ones); the computer CPU contains circuitry to do
arithmetic with these representations. Textual information is represented in exactly the same way. Under-
neath, when the computer is manipulating text, it is really no different from number crunching.
To understand this, you might think in terms of messages and secret codes. Consider the age-old grade
school dilemma. You are sitting in class and want to pass a note to a friend across the room. Unfortunately,
the note must pass through the hands, and in front of the curious eyes, of many classmates before it reaches
its final destination. And, of course, there is always the risk that the note could fall into enemy hands (the
teacher's). So you and your friend need to design a scheme for encoding the contents of your message.
One approach is to simply turn the message into a sequence of numbers. You could choose a number
to correspond to each letter of the alphabet and use the numbers in place of letters. Without too muchCHAPTER 4. COMPUTING WITH STRINGS
44
imagination, you might use the numbers 1-26 to represent the letters a#,/z. Instead of the word "!&sourpuss,+'. you
would write %)%18, 14, 20, 17, 15, 20, 18, 18.$.- To those who don't know the code, this looks like a meaningless
string of numbers. For you and your friend, however, it represents a word.
This is how a computer represents strings. Each character is translated into a number, and the entire
string is stored as a sequence of (binary) numbers in computer memory. It doesn't really matter what number
is used to represent any given character as long as the computer is consistent about the encoding/decoding
process. In the early days of computing, different designers and manufacturers used different encodings. You
can imagine what a headache this was for people transferring data between different systems.
Consider the situation that would result if, say, PCs and MacIntosh computers each used their own en-
coding. If you type a term paper on a PC and save it as a text file, the characters in your paper are represented
as a certain sequence of numbers. Then if the file was read into your instructor's MacIntosh computer, the
numbers would be displayed on the screen as different characters from the ones you typed. The result would
look like gibberish!
To avoid this sort of problem, computer systems today use industry standard encodings. One important
standard is called ASCII (American Standard Code for Information Interchange). ASCII uses the numbers
0 through 127 to represent the characters typically found on an (American) computer keyboard, as well
as certain special values known as control codes that are used to coordinate the sending and receiving of
information. For example, the capital letters A/!$Z are represented by the values 65,(!90, and the lowercase
versions have codes 97"$-122.
One problem with the ASCII encoding, as its name implies, is that it is American-centric. It does not have
symbols that are needed in many other languages. Extended ASCII encodings have been developed by the
International Standards Organization to remedy this situation. Most modern systems are moving to support
of UniCode a much larger standard that includes support for the characters of all written languages. Newer
versions of Python include support for UniCode as well as ASCII.
Python provides a couple built-in functions that allow us to switch back and forth between characters and
the numeric values used to represent them in strings. The ord function returns the numeric ('$-ordinal+')) code
of a single-character string, while chr goes the other direction. Here are some interactive examples:
>>>
97
>>>
65
>>>
#)%a"#,
>>>
.-*Z,)*
ord("a")
ord("A")
chr(97)
chr(90)
4.3.2 Programming an Encoder
Let's return to the note-passing example. Using the Python ord and chr functions, we can write some
simple programs that automate the process of turning messages into strings of numbers and back again. The
algorithm for encoding the message is simple.
get the message to encode
for each character in the message:
print the letter number of the character
Getting the message from the user is easy, a raw input will take care of that for us.
message = raw_input("Please enter the message to encode: ")
Implementing the loop requires a bit more effort. We need to do something for each character of the message.
Recall that a for loop iterates over a sequence of objects. Since a string is a kind of sequence, we can just
use a for loop to run-through all the characters of the message.
for ch in message:4.3. STRINGS AND SECRET CODES
45
Finally, we need to convert each character to a number. The simplest approach is to use the ASCII number
(provided by ord) for each character in the message.
Here is the final program for encoding the message:
# text2numbers.py
#
A program to convert a textual message into a sequence of
#
numbers, utlilizing the underlying ASCII encoding.
def main():
print "This program converts a textual message into a sequence"
print "of numbers representing the ASCII encoding of the message."
print
# Get the message to encode
message = raw_input("Please enter the message to encode: ")
print
print "Here are the ASCII codes:"
# Loop through the message and print out the ASCII values
for ch in message:
print ord(ch),
# use comma to print all on one line.
print
main()
We can use the program to encode important messages.
This program converts a textual message into a sequence
of numbers representing the ASCII encoding of the message.
Please enter the message to encode: What a Sourpuss!
Here are the ASCII codes:
87 104 97 116 32 97 32 83 111 117 114 112 117 115 115 33
One thing to notice about this result is that even the space character has a corresponding ASCII code. It is
represented by the value 32.
4.3.3 Programming a Decoder
Now that we have a program to turn a message into a sequence of numbers, it would be nice if our friend
on the other end had a similar program to turn the numbers back into a readable message. Let's solve that
problem next. Our decoder program will prompt the user for a sequence of numbers representing ASCII
codes and then print out the text message corresponding to those codes. This program presents us with a
couple of challenges; we'll address these as we go along.
The overall outline of the decoder program looks very similar to the encoder program. One change in
structure is that the decoding version will collect the characters of the message in a string and print out the
entire message at the end of the program. To do this, we need to use an accumulator variable, a pattern we
saw in the factorial program from the previous chapter. Here is the decoding algorithm:
get the sequence of numbers to decode
message = ""
for each number in the input:
convert the number to the appropriate character46
CHAPTER 4. COMPUTING WITH STRINGS
add the character to the end of message
print the message
Before the loop, the accumulator variable message is initialized to be an empty string, that is a string
that contains no characters (""). Each time through the loop a number from the input is converted into an
appropriate character and appended to the end of the message constructed so far.
The algorithm seems simple enough, but even the first step presents us with a problem. How exactly do
we get the sequence of numbers to decode? We don't even know how many numbers there will be. To solve
this problem, we are going to rely on some more string manipulation operations.
First, we will read the entire sequence of numbers as a single string using raw input. Then we will
split the big string into a sequence of smaller strings, each of which represents one of the numbers. Finally,
we can iterate through the list of smaller strings, convert each into a number, and use that number to produce
the corresponding ASCII character. Here is the complete algorithm:
get the sequence of numbers as a string, inString
split inString into a sequence of smaller strings
message = ""
for each of the smaller strings:
change the string of digits into the number it represents
append the ASCII character for that number to message
print message
This looks complicated, but Python provides some functions that do just what we need.
We saw in Chapter 3 that Python provides a standard math library containing useful functions for com-
puting with numbers. Similarly, the string library contains many functions that are useful in string-
manipulation programs.
For our decoder, we will make use of the split function. This function is used to split a string into a
sequence of substrings. By default, it will split the string wherever a space occurs. Here's an example:
>>> import string
>>> string.split("Hello string library!")
[!,)Hello%#!, (&/string('#, -&-library!*!%]
You can see how split has turned the original string "Hello string library!" into a list of three
strings: "Hello", "string" and "library!".
By the way, the split function can be used to split a string at places other than spaces by supplying
the character to split on as a second parameter. For example, if we have a string of numbers separated by
commas, we could split on the commas.
>>> string.split("32,24,25,57", ",")
[##-32.+/, **$24,&,, &.!25.#*, '+!57&*.]
Since our decoder program should accept the same format that was produced by the encoder program,
namely a sequence of numbers with spaces between, the default version of split works nicely.
>>> string.split("87 104 97 116 32 97 32 83 111 117 114 112 117 115 115 33")
[)'$87&"$, "$-104/#), &$#97"//, -&-116%+(, /"#32'/$, %(+97)%$, ,'.32*-!, *#,83$$#, #)/111(%+, /+$117)"#,
,."114''., **%112)$", !%+117$(', '+'115&##, ().115$"', --%33/,+]
Notice that the resulting list is not a sequence of numbers, it is a sequence of strings. It just so happens these
strings contain only digits and could be interpreted as numbers.
All that we need now is a way of converting a string containing digits into a Python number. One way to
accomplish this is with the Python eval function. This function takes any string and evaluates it as if it were
a Python expression. Here are some interactive examples of eval:
>>> numStr = "500"
>>> eval(numStr)
5004.3. STRINGS AND SECRET CODES
47
>>> eval("345.67")
345.67
>>> eval("3+4")
7
>>> x = 3.5
>>> y = 4.7
>>> eval("x * y")
16.45
>>> x = eval(raw_input("Enter a number "))
Enter a number 3.14
>>> print x
3.14
The last pair of statements shows that the eval of a raw input produces exactly what we would expect
from an input expression. Remember, input evaluates what the user types, and eval evaluates whatever
string it is given.
Using split and eval we can write our decoder program.
# numbers2text.py
#
A program to convert a sequence of ASCII numbers into
#
a string of text.
import string
# include string library for the split function.
def main():
print "This program converts a sequence of ASCII numbers into"
print "the string of text that it represents."
print
# Get the message to encode
inString = raw_input("Please enter the ASCII-encoded message: ")
# Loop through each substring and build ASCII message
message = ""
for numStr in string.split(inString):
asciiNum = eval(numStr)
# convert digit string to a number
message = message + chr(asciiNum) # append character to message
print "The decoded message is:", message
main()
Study this program a bit, and you should be able to understand exactly how it accomplishes its task. The
heart of the program is the loop.
for numStr in string.split(inString):
asciiNum = eval(numStr)
message = message + chr(asciiNum)
The split function produces a sequence of strings, and numStr takes on each successive (sub)string in the
sequence. I called the loop variable numStr to emphasize that its value is a string of digits that represents
some number. Each time through the loop, the next substring is converted to a number by evaling it.
This number is converted to the corresponding ASCII character via chr and appended to the end of the
accumulator, message. When the loop is finished, every number in inString has been processed and
message contains the decoded text.
Here is an example of the program in action:CHAPTER 4. COMPUTING WITH STRINGS
48
>>> import numbers2text
This program converts a sequence of ASCII numbers into
the string of text that it represents.
Please enter the ASCII-encoded message:
83 116 114 105 110 103 115 32 97 114 101 32 70 117 110 33
The decoded message is: Strings are Fun!
4.3.4 Other String Operations
Now we have a couple programs that can encode and decode messages as sequences of ASCII values. These
programs turned out to be quite simple due to the power both of Python's string data type and its built-in
operations as well as extensions that can be found in the string library.
Python is a very good language for writing programs that manipulate textual data. Table 4.2 lists some
of the other useful functions of the string library. Note that many of these functions, like split, accept
additional parameters to customize their operation. Python also has a number of other standard libraries for
text-processing that are not covered here. You can consult the online documentation or a Python reference to
find out more.
Function
capitalize(s)
capwords(s)
center(s, width)
count(s, sub)
find(s, sub)
join(list)
ljust(s, width)
lower(s)
lstrip(s)
replace(s,oldsub,newsub)
rfind(s, sub)
rjust(s,width)
rstrip(s)
split(s)
upper(s)
Meaning
Copy of s with only the first character capitalized
Copy of s with first character of each word capitalized
Center s in a field of given width
Count the number of occurrences of sub in s
Find the first position where sub occurs in s
Concatenate list of strings into one large string
Like center, but s is left-justified
Copy of s in all lowercase characters
Copy of s with leading whitespace removed
Replace all occurrences of oldsub in s with newsub
Like find, but returns the rightmost position
Like center, but s is right-justified
Copy of s with trailing whitespace removed
Split s into a list of substrings (see text).
Copy of s with all characters converted to upper case
Table 4.2: Some components of the Python string library
4.3.5 From Encoding to Encryption
We have looked at how computers represent strings as a sort of encoding problem. Each character in a string
is represented by a number that is stored in the computer in a binary representation. You should realize that
there is nothing really secret about this code at all. In fact, we are simply using an industry-standard mapping
of characters into numbers. Anyone with a little knowledge of computer science would be able to crack our
code with very little effort.
The process of encoding information for the purpose of keeping it secret or transmitting it privately is
called encryption. The study of encryption methods is an increasingly important subfield of mathematics and
computer science known as cryptography. For example, if you shop over the Internet, it is important that your
personal information such as social security number or credit card number is transmitted using encodings that
keep it safe from potential eavesdroppers on the network.
Our simple encoding/decoding programs use a very weak form of encryption known as a substitution
cipher. Each character of the original message, called the plaintext, is replaced by a corresponding symbol
(in our case a number) from a cipher alphabet. The resulting code is called the ciphertext .4.4. OUTPUT AS STRING MANIPULATION
49
Even if our cipher were not based on the well-known ASCII encoding, it would still be easy to discover
the original message. Since each letter is always encoded by the same symbol, a code-breaker could use
statistical information about the frequency of various letters and some simple trial and error testing to discover
the original message. Such simple encryption methods may be sufficient for grade-school note passing, but
they are certainly not up to the task of securing communication over global networks.
Modern approaches to encryption start by translating a message into numbers, much like our encoding
program. Then sophisticated mathematical algorithms are employed to transform these numbers into other
numbers. Usually, the transformation is based on combining the message with some other special value called
the key. In order to decrypt the message, the party on the receiving end needs to have the appropriate key so
that the encoding can be reversed to recover the original message.
Encryption approaches come in two flavors: private key and public key. In a private key system the same
key is used for encrypting and decrypting messages. All parties that wish to communicate need to know
the key, but it must be kept secret from the outside world. This is usual system that people think of when
considering secret codes.
In public key systems, there are separate but related keys for encrypting and decrypting. Knowing the
encryption key does not allow you to decrypt messages or discover the decryption key. In a public key
system, the encryption key can be made publicly available, while the decryption key is kept private. Anyone
can safely send a message using the public key for encryption. Only the party holding the decryption key
will be able to decipher it. For example, a secure web site can send your web browser its public key, and the
browser can use it to encode your credit card information before sending it on the Internet. Then only the
company that is requesting the information will be able to decrypt and read it using the proper private key.
4.4 Output as String Manipulation
Even programs that we may not view as primarily doing text-manipulation often need to make use of string
operations. For example, a program to do a financial analysis must produce a nicely formatted report of the
results. Much of this report will be in the form of text that is used to label and explain numbers, charts, tables
and figures. In this section, we'll look at techniques for generating nicely formatted text-based output.
4.4.1 Converting Numbers to Strings
In the ASCII decoding program, we used the eval function to convert from a string data type into a numeric
data type. Recall that eval evaluates a string as a Python expression. It is very general and can be used to
turn strings into nearly any other Python data type.
It is also possible to go the other direction and turn many Python data types into strings using the str
function. Here are a couple of simple examples.
>>> str(500)
---500)&(
>>> value = 3.14
>>> str(value)
".-3.14$)%
>>> print "The value is", str(value) + "."
The value is 3.14.
Notice particularly the last example. By turning value into a string, we can use string concatenation to put
a period at the end of a sentence. If we didn't first turn value into a string, Python would interpret the + as
a numerical operation and produce an error, because *//.(-) is not a number.
Adding eval and str to the type-conversion operations discussed in Chapter 3, we now have a complete
set of operations for converting values among various Python data types. Table 4.3 summarizes these five
Python type conversion functions.
One common reason for converting a number into a string is so that string operations can be used to
control the way the value is printed. For example, in the factorial program from last chapter we saw that
Python long ints have the letter +,"L!/* appended to them. In versions of Python prior to 2.0, the .-(L$$$ showed upCHAPTER 4. COMPUTING WITH STRINGS
50
Function
float(<expr>)
int(<expr>)
long(<expr>
str(<expr>)
eval(<string>)
Meaning
Convert expr to a floating point value.
Convert expr to an integer value.
Convert expr to a long integer value.
Return a string representation of expr.
Evaluate string as an expression.
Table 4.3: Type Conversion Functions
whenever a long int was printed. However, it is easy to remove this artifact using some straightforward string
manipulation.
factStr = str(fact)
print factStr[0:len(factStr)-1]
Can you see how this code turns the long int into a string and then uses slicing to remove the &(!L?#!. The
print statement prints every position in the string up to, but not including, the final +"$L,(%, which is in position
length - 1.
As an aside, Python also allows sequences to be indexed from the back by using negative numbers as
indexes. Thus -1 is the last position in a string, -2 is the second to last, etc. Using this convention, we can
slice off the last character without first computing the length of the string.
print str(fact)[:-1]
This version uses str to turn fact into a string and then immediately slices it $'$in place+&! from the beginning
(0 is the default start) up to, but not including, the last position.
4.4.2 String Formatting
As you have seen, basic string operations can be used to build nicely formatted output. This technique is
useful for simple formatting, but building up a complex output through slicing and concatenation of smaller
strings can be tedious. Python provides a powerful string formatting operation that makes the job much easier.
Let's start with a simple example. Here is a run of the change counting program from last chapter.
Change Counter
Please enter the count of each coin type.
How many quarters do you have? 6
How many dimes do you have? 0
How many nickels do you have? 0
How many pennies do you have? 0
The total value of your change is 1.5
Notice that the final value is given as a fraction with only one decimal place. This looks funny, since we
expect the output to be something like $1.50.
We can fix this problem by changing the very last line of the program as follows.
print "The total value of your change is $%0.2f" % (total)
Now the program prints this message:
The total value of your change is $1.50
Let's try to make some sense of this. The percent sign % is Python's string formatting operator. In general,
the string formatting operator is used like this:
<template-string> % (<values>)4.4. OUTPUT AS STRING MANIPULATION
51
Percent signs inside the template-string mark $!,slots-($ into which the values are inserted. There must
be exactly one slot for each value. Each of the slots is described by a format specifier that tells Python how
the value for that slot should appear.
Returning to the example, the template contains a single specifier at the end: %0.2f. The value of
total will be inserted into the template in place of the specifier. The specifier also tells Python that total
is a floating point number that should be rounded to two decimal places. To understand the formatting, we
need to look at the structure of the specifier.
A formatting specifier has this general form:
%<width>.<precision><type-char>
The specifier starts with a % and ends with a character that indicates the data type of the value being inserted.
We will use three different format types: decimal, float, and string. Decimal mode is used to display ints as
base-10 numbers. (Python allows ints to be printed using a number of different bases; we will only use the
normal decimal representation.) Float and string formats are obviously used for the corresponding data types.
The width and precision portions of a specifier are optional. If present, width tells how many
spaces to use in displaying the value. If a value requires more room than is given in width, Python will just
expand the width so that the value fits. You can use a 0 width to indicate ''!use as much space as needed.&*+
Precision is used with floating point values to indicate the desired number of digits after the decimal. The
example specifier %0.2f tells Python to insert a floating point value using as much space as necessary and
rounding it to two decimal places.
The easiest way to get the hang of formatting is just to play around with some examples in the interactive
environment.
>>> "Hello %s %s, you may have won $%d!" % ("Mr.", "Smith", 10000)
)'#Hello Mr. Smith, you may have already won $10000!""*
>>> ',#This int, %5d, was placed in a field of width 5*+. % (7)
&.%This int,
7, was placed in a field of width 5!!+
>>> !%#This int, %10d, was placed in a field of width 10%)+ % (7)
(')This int,
7, was placed in a field of width 10/%#
>>> *%!This float, %10.5f, has width 10 and precision 5.,&" % (3.1415926)
&,%This float,
3.14159, has width 10 and precision 5./-/
>>> -+&This float, %0.5f, has width 0 and precision 5.#+& % (3.1415926)
%$"This float, 3.14159, has width 0 and precision 5../"
>>> "Compare %f and %0.20f" % (3.14, 3.14)
!'!Compare 3.140000 and 3.14000000000000012434)-%
A couple points are worth noting here. If the width in the specifier is larger than needed, the value is
right-justified in the field by default. You can left-justify the value in the field by preceding the width with
a minus sign (e.g., %-8.3f). The last example shows that if you print enough digits of a floating point
number, you will almost always find a #')surprise.$*' The computer can't represent 3.14 exactly as a floating
point number. The closest value it can represent is ever so slightly larger than 3.14. If not given an explicit
precision, Python will print the number out to a few decimal places. The slight extra extra amount shows up
if you print lots of digits. Generally, Python only displays a closely rounded version of a float. Using explicit
formatting allows you to see the full result down to the last bit.
4.4.3 Better Change Counter
Let's close our formatting discussion with one more example program. Given what you have learned about
floating point numbers, you might be a little uneasy about using them to represent money.52
CHAPTER 4. COMPUTING WITH STRINGS
Suppose you are writing a computer system for a bank. Your customers would not be too happy to learn
that a check went through for an amount ,'#very close to $107.56."&( They want to know that the bank is keeping
precise track of their money. Even though the amount of error in a given value is very small, the small errors
can be compounded when doing lots of calculations, and the resulting error could add up to some real cash.
That's not a satisfactory way of doing business.
A better approach would be to make sure that our program used exact values to represent money. We
can do that by keeping track of the money in cents and using an int (or long int) to store it. We can then
convert this into dollars and cents in the output step. If total represents the value in cents, then we can
get the number of dollars by total / 100 and the cents from total % 100. Both of these are integer
calculations and, hence, will give us exact results. Here is the updated program:
# change2.py
#
A program to calculate the value of some change in dollars
#
This version represents the total cash in cents.
def main():
print "Change Counter"
print
print "Please enter the count of each coin type."
quarters = input("Quarters: ")
dimes = input("Dimes: ")
nickels = input("Nickels: ")
pennies = input("Pennies: ")
total = quarters * 25 + dimes * 10 + nickels * 5 + pennies
print
print "The total value of your change is $%d.%02d" \
% (total/100, total%100)
main()
I have split the final print statement across two lines. Normally a statement ends at the end of the line.
Sometimes it is nicer to break a long statement into smaller pieces. A backslash at the end of a line is one
way to indicate that a statement is continued on the following line. Notice that the backslash must appear
outside of the quotes; otherwise, it would be considered part of the string literal.
The string formatting in the print statement contains two slots, one for dollars as an int and one for cents
as an int. This example also illustrates one additional twist on format specifiers. The value of cents is printed
with the specifier %02d. The zero in front of the width tells Python to pad the field (if necessary) with zeroes
instead of spaces. This ensures that a value like 10 dollars and 5 cents prints as $10.05 rather than $10.
5.
4.5 File Processing
I began the chapter with a reference to word-processing as an application of the string data type. One critical
feature of any word processing program is the ability to store and retrieve documents as files on disk. In this
section, we'll take a look at file input and output, which, as it turns out, is really just another form of string
processing.
4.5.1 Multi-Line Strings
Conceptually, a file is a sequence of data that is stored in secondary memory (usually on a disk drive). Files
can contain any data type, but the easiest files to work with are those that contain text. Files of text have
the advantage that they can be read and understood by humans, and they are easily created and edited using
general-purpose text editors and word processors. In Python, text files can be very flexible, since it is easy to
convert back and forth between strings and other types.4.5. FILE PROCESSING
53
You can think of a text file as a (possibly long) string that happens to be stored on disk. Of course, a
typical file generally contains more than a single line of text. A special character or sequence of characters is
used to mark the end of each line. There are numerous conventions for end-of-line markers. Python uses a
single character called newline as a marker.
You can think of newline as the character produced when you press the Enter   key on your keyboard.
Although a newline is a single character, it is represented in Python (and many other computer languages)
using the special notation (## n%,-. Other special characters are represented using a similar notation (i.e., #(( t+''
for Tab   ).
Let's take a look at a concrete example. Suppose you type the following lines into a text editor exactly as
shown here.
Hello
World
Goodbye 32
When stored to a file, you get this sequence of characters.
Hello\nWorld\n\nGoodbye 32\n
Notice that the blank line becomes a bare newline in the resulting file/string.
By the way, by embedding newline characters into output strings, you can produce multiple lines of output
with a single print statement. Here is the example from above printed interactively.
>>> print "Hello\nWorld\n\nGoodbye 32\n"
Hello
World
Goodbye 32
>>>
If you simply ask Python to evaluate a string containing newline characters, you will just get the embedded
newline representation back again.
>>>"Hello\nWorld\n\nGoodbye 32\n"
-.%Hello\nWorld\n\nGoodbye 32\n-("
It's only when a string is printed that the special characters affect how the string is displayed.
4.5.2 File Processing
The exact details of file-processing differ substantially among programming languages, but virtually all lan-
guages share certain underlying file manipulation concepts. First, we need some way to associate a file on
disk with a variable in a program. This process is called opening a file. Once a file has been opened, it is
manipulated through the variable we assign to it.
Second, we need a set of operations that can manipulate the file variable. At the very least, this includes
operations that allow us to read the information from a file and write new information to a file. Typically, the
reading and writing operations for text files are similar to the operations for text-based, interactive input and
output.
Finally, when we are finished with a file, it is closed. Closing a file makes sure that any bookkeeping that
was necessary to maintain the correspondence between the file on disk and the file variable is finished up. For
example, if you write information to a file variable, the changes might not show up on the disk version until
the file has been closed.
This idea of opening and closing files is closely related to how you might work with files in an application
program like a word processor. However, the concepts are not exactly the same. When you open a file in a
program like Microsoft Word, the file is actually read from the disk and stored into RAM. In programming54
CHAPTER 4. COMPUTING WITH STRINGS
terminology, the file is opened for reading and the the contents of the file are then read into memory via file
reading operations. At this point, the file is closed (again in the programming sense). As you )*/edit the file,"%)
you are really making changes to data in memory, not the file itself. The changes will not show up in the file
on the disk until you tell the application to ("'save#*$ it.
Saving a file also involves a multi-step process. First, the original file on the disk is reopened, this time in
a mode that allows it to store information*)'the file on disk is opened for writing. Doing so actually erases the
old contents of the file. File writing operations are then used to copy the current contents of the in-memory
version into the new file on the disk. From your perspective, it appears that you have edited an existing file.
From the program's perspective, you have actually opened a file, read its contents into memory, closed the
file, created a new file (having the same name), written the (modified) contents of memory into the new file,
and closed the new file.
Working with text files is easy in Python. The first step is to associate a file with a variable using the
open function.
<filevar> = open(<name>, <mode>)
Here name is a string that provides the name of the file on the disk. The mode parameter is either the string
"r" or "w" depending on whether we intend to read from the file or write to the file.
For example, to open a file on our disk called $.*numbers.dat(!# for reading, we could use a statement like
the following.
infile = open("numbers.dat", "r")
Now we can use the variable infile to read the contents of numbers.dat from the disk.
Python provides three related operations for reading information from a file:
<filevar>.read()
<filevar>.readline()
<filevar>.readlines()
The read operation returns the entire contents of the file as a single string. If the file contains more than one
line of text, the resulting string has embedded newline characters between the lines.
Here's an example program that prints the contents of a file to the screen.
# printfile.py
#
Prints a file to the screen.
def main():
fname = raw_input("Enter filename: ")
infile = open(fname,!+!r./.)
data = infile.read()
print data
main()
The program first prompts the user for a filename and then opens the file for reading through the variable
infile. You could use any name for the variable, I used infile to emphasize that the file was being used
for input. The entire contents of the file is then read as one large string and stored in the variable data.
Printing data causes the contents to be displayed.
The readline operation can be used to read one line from a file; that is, it reads all the characters up
through the next newline character. Each time it is called, readline returns the next line from the file. This
is analogous to raw input which reads characters interactively until the user hits the Enter   key; each
call to raw input get another line from the user. One thing to keep in mind, however, is that the string
returned by readline will always end with a newline character, whereas raw input discards the newline
character.
As a quick example, this fragment of code prints out the first five lines of a file.4.5. FILE PROCESSING
55
infile = open(someFile, $$-r%$/)
for i in range(5):
line = infile.readline()
print line[:-1]
Notice the use of slicing to strip off the newline character at the end of the line. Since print automatically
jumps to the next line (i.e., it outputs a newline), printing with the explicit newline at the end would put an
extra blank line of output between the lines of the file.
As an alternative to readline, when you want to loop through all the (remaining) lines of a file, you
can use readlines. This operation returns a sequence of strings representing the lines of the file. Used
with a for loop, it is a particularly handy way to process each line of a file.
infile = open(someFile, ,&$r,%,)
for line in infile.readlines():
# process the line here
infile.close()
Opening a file for writing prepares that file to receive data. If no file with the given name exists, a new
file will be created. A word of warning: if a file with the given name does exist, Python will delete it and
create a new, empty file. When writing to a file, make sure you do not clobber any files you will need later!
Here is an example of opening a file for output.
outfile = open("mydata.out", "w")
We can put data into a file, using the write operation.
<file-var>.write(<string>)
This is similar to print, except that write is a little less flexible. The write operation takes a single
parameter, which must be a string, and writes that string to the file. If you want to start a new line in the file,
you must explicitly provide the newline character.
Here's a silly example that writes two lines to a file.
outfile = open("example.out", $.-w'/')
count = 1
outfile.write("This is the first line\n")
count = count + 1
outfile.write("This is line number %d" % (count))
outfile.close()
Notice the use of string formatting to write out the value of the variable count. If you want to output
something that is not a string, you must first convert it; the string formatting operator is often a handy way to
do this. This code will produce a file on disk called %#%example.out'+, containing the following two lines:
This is the first line
This is line number 2
If !+.example.out()& existed before executing this fragment, it's old contents were destroyed.
4.5.3 Example Program: Batch Usernames
To see how all these pieces fit together, let's redo the username generation program. Our previous version
created usernames interactively by having the user type in his or her name. If we were setting up accounts for
a large number of users, the process would probably not be done interactively, but in batch mode. In batch
processing, program input and output is done through files.
Our new program is designed to process a file of names. Each line of the input file will contain the
first and last names of a new user separated by one or more spaces. The program produces an output file
containing a line for each generated username.CHAPTER 4. COMPUTING WITH STRINGS
56
# userfile.py
#
Program to create a file of usernames in batch mode.
import string
def main():
print "This program creates a file of usernames from a"
print "file of names."
# get the file names
infileName = raw_input("What file are the names in? ")
outfileName = raw_input("What file should the usernames go in? ")
# open the files
infile = open(infileName, &$)r+!-)
outfile = open(outfileName, *,*w%(&)
# process each line of the input file
for line in infile.readlines():
# get the first and last names from line
first, last = string.split(line)
# create the username
uname = string.lower(first[0]+last[:7])
# write it to the output file
outfile.write(uname+"#%\n.*$)
# close both files
infile.close()
outfile.close()
print "Usernames have been written to", outfileName
main()
There are a few things worth noticing in this program. I have two files open at the same time, one for
input (infile) and one for output (outfile). It's not unusual for a program to operate on several files
simultaneously. Also, when creating the username, I used the lower function from the string library.
This ensures that the username is all lower case, even if the input names are mixed case. Finally, you should
also notice the line that writes the username to the file.
outfile.write(uname+,&'\n!,))
Concatenating the newline character is necessary to indicate the end of line. Without this, all of the usernames
would run together in one giant line.
4.5.4 Coming Attraction: Objects
Have you noticed anything strange about the syntax of the file processing examples? To apply an operation
to a file, we use dot notation. For example, to read from infile we type infile.read(). This is
different from the normal function application that we have used before. Afterall, to take the absolute value
of a variable x, we type abs(x), not x.abs().
In Python, a file is an example of an object. Objects combine both data and operations together. An
object's operations, called methods, are invoked using the dot notation. That's why the syntax looks a bit
different.4.6. EXERCISES
57
For completeness, I should mention that strings are also objects in Python. If you have a relatively new
version of Python (2.0 or later), you can use string methods in place of the string library functions that we
discussed earlier. For example,
myString.split()
is equivalent to
string.split(myString)
If this object stuff sounds confusing right now, don't worry; Chapter 5 is all about the power of objects (and
pretty pictures, too).
4.6 Exercises
1. Given the initial statements:
import string
s1 = "spam"
s2 = "ni!"
Show the result of evaluating each of the following string expressions.
(a) "The Knights who say, " + s2
(b) 3 * s1 + 2 * s2
(c) s1[1]
(d) s1[1:3]
(e) s1[2] + s2[:2]
(f) s1 + s2[-1]
(g) string.upper(s1)
(h) string.ljust(string.upper(s2),4) * 3
2. Given the same initial statements as in the previous problem, show a Python expression that could
construct each of the following results by performing string operations on s1 and s2.
(a) "NI"
(b) "ni!spamni!"
(c) "Spam Ni!
Spam Ni!
Spam Ni!"
(d) "span"
(e) ["sp","m"]
(f) "spm"
3. Show the output that would be generated by each of the following program fragments.
(a) for ch in "aardvark":
print ch
(b) for w in string.split("Now is the winter of our discontent..."):
print w
(c) for w in string.split("Mississippi", "i"):
print w,CHAPTER 4. COMPUTING WITH STRINGS
58
(d) msg = ""
for s in string.split("secret","e"):
msg = msg + s
print msg
(e) msg = ""
for ch in "secret":
msg = msg + chr(ord(ch)+1)
print msg
4. Show the string that would result from each of the following string formatting operations. If the oper-
ation is not legal, explain why.
(a) "Looks like %s and %s for breakfast" % ("spam", "eggs")
(b) "There is %d %s %d %s" % (1,"spam", 4, "you")
(c) "Hello %s" % ("Suzie", "Programmer")
(d) "%0.2f %0.2f" % (2.3, 2.3468)
(e) "%7.5f %7.5f" % (2.3, 2.3468)
(f) "Time left %02d:%05.2f" % (1, 37.374)
(g) "%3d" % ("14")
5. Explain why public key encryption is more useful for securing communications on the Internet than
private (shared) key encryption.
6. A certain CS professor gives 5-point quizzes that are graded on the scale 5-A, 4-B, 3-C, 2-D, 1-F, 0-F.
Write a program that accepts a quiz score as an input and prints out the corresponding grade.
7. A certain CS professor gives 100-point exams that are graded on the scale 90$,+100:A, 80#++89:B, 70/"/
79:C, 60/$/69:D, 60:F. Write a program that accepts an exam score as input and prints out the corre-
sponding grade.
8. An acronym is a word formed by taking the first letters of the words in a phrase and making a word
from them. For example, RAM is an acronym for $-#random access memory.-)* Write a program that
allows the user to type in a phrase and outputs the acronym for that phrase. Note: the acronym should
be all uppercase, even if the words in the phrase are not capitalized.
9. Numerologists claim to be able to determine a person's character traits based on the +"-numeric value/!.
of a name. The value of a name is determined by summing up the values of the letters of the name
where *,+a(%( is 1, !/+b+)' is 2, '(/c-(* is 3 etc., up to $+.z&!' being 26. For example, the name /+)Zelle$"! would have the
value 26 5 12 12 5 60 (which happens to be a very auspicious number, by the way). Write a
program that calculates the numeric value of a single name provided as input.
10. Expand your solution to the previous problem to allow the calculation of a complete name such as )+$John
Marvin Zelle%+( or ,+(John Jacob Jingleheimer Smith...! The total value is just the sum of the numeric value
for each name.
11. A Caesar cipher is a simple substitution cipher based on the idea of shifting each letter of the plaintext
message a fixed number (called the key) of positions in the alphabet. For example, if the key value is
2, the word ,,!Sourpuss+)( would be encoded as %,*Uqwtrwuu.#"* The original message can be recovered by
"(,reencoding*$- it using the negative of the key.
Write a program that can encode and decode Caesar ciphers. The input to the program will be a string
of plaintext and the value of the key. The output will be an encoded message where each character in
the original message is replaced by shifting it key characters in the ASCII character set. For example,
if ch is a character in the string and key is the amount to shift, then the character that replaces ch can
be calculated as: chr(ord(ch) + key).4.6. EXERCISES
59
12. One problem with the previous exercise is that it does not deal with the case when we *,!drop off the
end-!+ of the alphabet (or ASCII encodings). A true Caesar cipher does the shifting in a circular fashion
where the next character after -$&z,*+ is $&'a$)'. Modify your solution to the previous problem to make it
circular. You may assume that the input consists only of letters and spaces.
13. Write a program that counts the number of words in a sentence entered by the user.
14. Write a program that calculates the average word length in a sentence entered by the user.
15. Write an improved version of the Chaos program from Chapter 1 that allows a user to input two initial
values and the number of iterations and then prints a nicely formatted table showing how the values
change over time. For example, if the starting values were .25 and .26 with 10 iterations, the table
might look like this:
index
0.25
0.26
----------------------------
1
0.731250
0.750360
2
0.766441
0.730547
3
0.698135
0.767707
4
0.821896
0.695499
5
0.570894
0.825942
6
0.955399
0.560671
7
0.166187
0.960644
8
0.540418
0.147447
9
0.968629
0.490255
10
0.118509
0.974630
16. Write an improved version of the future value program from Chapter 2. Your program will prompt
the user for the amount of the investment, the annualized interest rate, and the number of years of
the investment. The program will then output a nicely formatted table that tracks the value of the
investment year by year. Your output might look something like this:
Years
Value
----------------
0
$2000.00
1
$2200.00
2
$2420.00
3
$2662.00
4
$2928.20
5
$3221.02
6
$3542.12
7
$3897.43
17. Redo any of the previous programming problems to make them batch oriented (using text files for input
and output).
18. Word count. A common utility on Unix/Linux systems is a small program called +%#wc.-/+ This program
analyzes a file to determine the number of lines, words, and characters contained therein. Write your
own version of wc. The program should accept a file name as input and then print three numbers
showing the count of lines, words, and characters in the file.60
CHAPTER 4. COMPUTING WITH STRINGSChapter 5
Objects and Graphics
So far we have been writing programs that use the built-in Python data types for numbers and strings. We
saw that each data type could represent a certain set of values, and each had a set of associated operations.
Basically, we viewed the data as passive entities that were manipulated and combined via active operations.
This is a traditional way to view computation. To build complex systems, however, it helps to take a richer
view of the relationship between data and operations.
Most modern computer programs are built using an object-oriented (OO) approach. Object orientation
is not easily defined. It encompasses a number of principles for designing and implementing software, prin-
ciples that we will return to numerous times throughout course of this book. This chapter provides a basic
introduction to object concepts by way of some computer graphics.
5.1 The Object of Objects
The basic idea of object-oriented development is to view a complex system as the interaction of simpler
objects. The word objects is being used here in a specific technical sense. Part of the challenge of OO
programming is figuring out the vocabulary. You can think of an OO object as a sort of active data type that
combines both data and operations. To put it simply, objects know stuff (they contain data), and they can do
stuff (they have operations). Objects interact by sending each other messages. A message is simply a request
for an object to perform one of its operations.
Consider a simple example. Suppose we want to develop a data processing system for a college or
university. We will need to keep track of considerable information. For starters, we must keep records
on the students who attend the school. Each student could be represented in the program as an object. A
student object would contain certain data such as name, ID number, courses taken, campus address, home
address, GPA, etc. Each student object would also be able to respond to certain requests. For example,
to send out a mailing, we would need to print an address for each student. This task might be handled by a
printCampusAddress operation. When a particular student object is sent the printCampusAddress
message, it prints out its own address. To print out all the addresses, a program would loop through the
collection of student objects and send each one in turn the printCampusAddress message.
Objects may refer to other objects. In our example, each course in the college might also be represented
by an object. Course objects would know things such as who the instructor is, what students are in the
course, what the prerequisites are, and when and where the course meets. One example operation might be
addStudent, which causes a student to be enrolled in the course. The student being enrolled would be
represented by the appropriate student object. Instructors would be another kind of object, as well as rooms,
and even times. You can see how successive refinement of these ideas could lead to a rather sophisticated
model of the information structure of the college.
As a beginning programmer, you're probably not yet ready to tackle a college information system. For
now, we'll study objects in the context of some simple graphics programming.
61CHAPTER 5. OBJECTS AND GRAPHICS
62
5.2 Graphics Programming
Modern computer applications are not limited to the sort of textual input and output that we have been using
so far. Most of the applications that you are familiar with probably have a so-called Graphical User Interface
(GUI) that provides visual elements like windows, icons (representative pictures), buttons and menus.
Interactive graphics programming can be very complicated; entire textbooks are devoted to the intricacies
of graphics and graphical interfaces. Industrial-strength GUI applications are usually developed using a
dedicated graphics programming framework. Python comes with its own standard GUI module called Tkinter.
As GUI frameworks go, Tkinter is one of the simplest to use, and Python is great language for developing
real-world GUIs. Even so, taking the time to learn Tkinter would detract from the more fundamental task of
learning the principles of programming and design that are the focus of this book.
To make learning easier, I have written a graphics library (graphics.py) for use with this book. This
library is freely available as a Python module file 1 and you are welcome to use it as you see fit. Using the
library is as easy as placing a copy of the graphics.py file in the same folder as your graphics program(s).
Alternatively, you can put graphics.py in the system directory where other Python libraries are stored so
that it can be used from any folder on the system.
The graphics library makes it easy to write simple graphics programs. As you do, you will be learning
principles of object-oriented programming and computer graphics that can be applied in more sophisticated
graphical programming environments. The details of the graphics module will be explored in later sec-
tions. Here we'll concentrate on a basic hands-on introduction to whet your appetite.
As usual, the best way to start learning new concepts is to roll up your sleeves and try out some examples.
The first step is to import the graphics module. Assuming you have placed graphics.py in an appropriate
place, you can import the graphics commands into an interactive Python session.
>>> import graphics
Next we need to create a place on the screen where the graphics will appear. That place is a graphics
window or GraphWin, which is provided by the graphics module.
>>> win = graphics.GraphWin()
This command creates a new window on the screen. The window will have the title '!+Graphics Window.$*& The
GraphWin may overlap your Python interpreter window, so you might have to resize the Python window to
make both fully visible. Figure 5.1 shows an example screen view.
The GraphWin is an object, and we have assigned it to the the variable called win. We can manipulate
the window object through this variable, similar to the way that file objects are manipulated through file
variables. For example, when we are finished with a window, we can destroy it. This is done by issuing the
close command.
>>> win.close()
Typing this command causes the window to vanish from the screen.
We will be working with quite a few commands from the graphics library, and it gets tedious having
to type the graphics. notation every time we use one. Python has an alternative form of import that can
help out.
from graphics import *
The from statement allows you to load specific definitions from a library module. You can either list the
names of definitions to be imported or use an asterisk, as shown, to import everything defined in the module.
The imported commands become directly available without having to preface them with the module name.
After doing this import, we can create a GraphWin more simply.
win = GraphWin()
1 See
Appendix A for information on how to obtain the graphics library and other supporting materials for this book.5.2. GRAPHICS PROGRAMMING
63
Figure 5.1: Screen shot with a Python window and a GraphWin
All of the rest of the graphics examples will assume that the entire graphics module has been imported
using from.
Let's try our hand at some drawing. A graphics window is actually a collection of tiny points called
pixels (short for picture elements). By controlling the color of each pixel, we control what is displayed
in the window. By default, a GraphWin is 200 pixels tall and 200 pixels wide. That means there are
40,000 pixels in the GraphWin. Drawing a picture by assigning a color to each individual pixel would be a
daunting challenge. Instead, we will rely on a library of graphical objects. Each type of object does its own
bookkeeping and knows how to draw itself into a GraphWin.
The simplest object in the graphics module is a Point. In geometry, a point is a dimensionless
location in space. A point is located by reference to a coordinate system. Our graphics object Point is
similar; it can represent a location in a GraphWin. We define a point by supplying x and y coordinates x !+" y .
The x value represents the horizontal location of the point, and the y value represents the vertical.
Traditionally, graphics programmers locate the point 0 (/* 0 in the upper-left corner of the window. Thus
x values increase from left to right, and y values increase from top to bottom. In the default 200 x 200
GraphWin, the lower-right corner has the coordinates 199 #,- 199 . Drawing a Point sets the color of the
corresponding pixel in the GraphWin. The default color for drawing is black.
Here is a sample interaction with Python illustrating the use of Points.
>>>
>>>
50
>>>
60
>>>
>>>
>>>
>>>
p = Point(50,60)
p.getX()
p.getY()
win = GraphWin()
p.draw(win)
p2 = Point(140,100)
p2.draw(win)
The first line creates a Point located at 50 !/' 60 . After the Point has been created, its coordinate values can
be accessed by the operations getX and getY. A Point is drawn into a window using the draw operation.
In this example, two different point objects (p and p2) are created and drawn into the GraphWin called
win. Figure 5.2 shows the resulting graphical output.
In addition to points, the graphics library contains commands for drawing lines, circles, rectangles, ovals,CHAPTER 5. OBJECTS AND GRAPHICS
64
Figure 5.2: Graphics window with two points drawn.
polygons and text. Each of these objects is created and drawn in a similar fashion. Here is a sample interaction
to draw various shapes into a GraphWin.
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
#### Open a graphics window
win = GraphWin(+$%Shapes*.-)
#### Draw a red circle centered at point (100,100) with radius 30
center = Point(100,100)
circ = Circle(center, 30)
circ.setFill(!""red+.!)
circ.draw(win)
#### Put a textual label in the center of the circle
label = Text(center, "Red Circle")
label.draw(win)
#### Draw a square using a Rectangle object
rect = Rectangle(Point(30,30), Point(70,70))
rect.draw(win)
#### Draw a line segment using a Line object
line = Line(Point(20,30), Point(180, 165))
line.draw(win)
#### Draw an oval using the Oval object
oval = Oval(Point(20,150), Point(180,199))
oval.draw(win)
Try to figure out what each of these statements does. If you type them in as shown, the final result will look
like Figure 5.3.
5.3 Using Graphical Objects
Some of the examples in the above interactions may look a bit strange to you. To really understand the
graphics module, we need to take an object-oriented point of view. Recall, objects combine data with
operations. Computation is performed by asking an object to carry out one of its operations. In order to make
use of objects, you need to know how to create them and how to request operations.
In the interactive examples above, we manipulated several different kinds of objects: GraphWin, Point,
Circle, Oval, Line, Text, and Rectangle. These are examples of classes. Every object is an instance
of some class, and the class describes the properties the instance will have.
Borrowing a biological metaphor, when we say that Fido is a dog, we are actually saying that Fido is a
specific individual in the larger class of all dogs. In OO terminology, Fido is an instance of the dog class.5.3. USING GRAPHICAL OBJECTS
65
Figure 5.3: Various shapes from the graphics module.
Because Fido is an instance of this class, we expect certain things. Fido has four legs, a tail, a cold, wet nose
and he barks. If Rex is a dog, we expect that he will have similar properties, even though Fido and Rex may
differ in specific details such as size or color.
The same ideas hold for our computational objects. We can create two separate instances of Point, say
p and p2. Each of these points has an x and y value, and they both support the same set of operations like
getX and draw. These properties hold because the objects are Points. However, different instances can
vary in specific details such as the values of their coordinates.
To create a new instance of a class, we use a special operation called a constructor. A call to a constructor
is an expression that creates a brand new object. The general form is as follows.
<class-name>(<param1>, <param2>, ...)
Here <class-name> is the name of the class that we want to create a new instance of, e.g., Circle or
Point. The expressions in the parentheses are any parameters that are required to initialize the object. The
number and type of the parameters depends on the class. A Point requires two numeric values, while a
GraphWin can be constructed without any parameters. Typically, a constructor is used on the right side of
an assignment statement, and the resulting object is immediately assigned to a variable on the left side that is
then used to manipulate the object.
To take a concrete example, let's look at what happens when we create a graphical point. Here is a
constructor statement from the interactive example above.
p = Point(50,60)
The constructor for the Point class requires two parameters giving the x and y coordinates for the new point.
These values are stored as instance variables inside of the object. In this case, Python creates an instance
of Point having an x value of 50 and a y value of 60. The resulting point is then assigned to the variable
p. A conceptual diagram of the result is shown in Figure 5.4. Note that, in this diagram as well as similar
ones later on, only the most salient details are shown. Points also contain other information such as their
color and which window (if any) they are drawn in. Most of this information is set to default values when the
Point is created.
To perform an operation on an object, we send the object a message. The set of messages that an object
responds to are called the methods of the object. You can think of methods as functions that live inside of the
object. A method is invoked using dot-notation.
<object>.<method-name>(<param1>, <param2>, ...)
The number and type of the parameters is determined by the method being used. Some methods require no
parameters at all. You can find numerous examples of method invocation in the interactive examples above.
As examples of parameterless methods, consider these two expressions.CHAPTER 5. OBJECTS AND GRAPHICS
66
Point
p:
x: 50
y: 60
Figure 5.4: Conceptual picture of the result of p = Point(50,60). The variable p refers to a freshly
created Point having the given coordinates.
p.getX()
p.getY()
The getX and getY methods return the x and y values of a point, respectively. Methods such as these are
sometimes called accessors, because they allow us to access information from the instance variables of the
object.
Other methods change the values of an object's instance variables, hence changing the state of the object.
All of the graphical objects have a move method. Here is a specification:
move(dx, dy): Moves the object dx units in the x direction and dy units in the y direction.
To move the point p to the right 10 units, we could use this statement.
p.move(10,0)
This changes the x instance variable of p by adding 10 units. If the point is currently drawn in a GraphWin,
move will also take care of erasing the old image and drawing it in its new position. Methods that change the
state of an object are sometimes called mutators.
The move method must be supplied with two simple numeric parameters indicating the distance to move
the object along each dimension. Some methods require parameters that are themselves complex objects. For
example, drawing a Circle into a GraphWin involves two objects. Let's examine a sequence of commands
that does this.
circ = Circle(Point(100,100), 30)
win = GraphWin()
circ.draw(win)
The first line creates a Circle with a center located at the Point 100 -%( 100 and a radius of 30. Notice that
we used the Point constructor to create a location for the first parameter to the Circle constructor. The
second line creates a GraphWin. Do you see what is happening in the third line? This is a request for the
Circle object circ to draw itself into the GraphWin object win. The visible effect of this statement is
a circle in the GraphWin centered at 100 (/) 100 and having a radius of 30. Behind the scenes, a lot more is
happening.
Remember, the draw method lives inside the circ object. Using information about the center and
radius of the circle from the instance variables, the draw method issues an appropriate sequence of low-
level drawing commands (a sequence of method invocations) to the GraphWin. A conceptual picture of the
interactions among the Point, Circle and GraphWin objects is shown in Figure 5.5. Fortunately, we
don't usually have to worry about these kinds of details; they're all taken care of by the graphical objects. We
just create objects, call the appropriate methods, and let them do the work. That's the power of object-oriented
programming.
There is one subtle -($gotcha'/$ that you need to keep in mind when using objects. It is possible for two
different variables to refer to exactly the same object; changes made to the object through one variable will
also be visible to the other. Suppose we are trying to write a sequence of code that draws a smiley face. We
want to create two eyes that are 20 units apart. Here is a sequence of code intended to draw the eyes.5.3. USING GRAPHICAL OBJECTS
67
Circle
circ:
Point
center:
radius:
draw(
.
.
.
30
)
x: 100
y: 100
Low-level drawing commands
GraphWin
win:
.
.
.
Figure 5.5: Object interactions to draw a circle.
## Incorrect way to create two circles.
leftEye = Circle(Point(80, 50), 5)
leftEye.setFill((#'yellow%*.)
leftEye.setOutline($,"red/&/)
rightEye = leftEye
rightEye.move(20,0)
The basic idea is to create the left eye and then copy that into a right eye which is then moved over 20 units.
This doesn't work. The problem here is that only one Circle object is created. The assignment
rightEye = leftEye
simply makes rightEye refer to the very same circle as leftEye. Figure 5.6 shows the situation. When
the Circle is moved in the last line of code, both rightEye and leftEye refer to it in its new location
on the right side. This situation where two variables refer to the same object is called aliasing, and it can
sometimes produce rather unexpected results.
leftEye:
Circle
Point
center:
radius:
10
x: 80
y: 50
rightEye:
Figure 5.6: Variables leftEye and rightEye are aliases.
One solution to this problem would be to create a separate circle for each eye.
## A correct way to create two circles.
leftEye = Circle(Point(80, 50), 5)
leftEye.setFill(,.!yellow%)&)CHAPTER 5. OBJECTS AND GRAPHICS
68
leftEye.setOutline(-&+red%&*)
rightEye = Circle(Point(100, 50), 5)
rightEye.setFill(.*)yellow"())
rightEye.setOutline(,/#red+,,)
This will certainly work, but it's cumbersome. We had to write duplicated code for the two eyes. That's easy
to do using a )'/cut and paste"&& approach, but it's not very elegant. If we decide to change the appearance of the
eyes, we will have to be sure to make the changes in two places.
The graphics library provides a better solution; all graphical objects support a clone method that
makes a copy of the object. Using clone, we can rescue the original approach.
## Correct way to create two circles, using clone.
leftEye = Circle(Point(80, 50), 5)
leftEye.setFill(()+yellow!-$)
leftEye.setOutline(&*!red(/-)
rightEye = leftEye.clone() # rightEye is an exact copy of the left
rightEye.move(20,0)
Strategic use of cloning can make some graphics tasks much easier.
5.4 Graphing Future Value
Now that you have some idea of how to use objects from the graphics module, we're ready to try some
real graphics programming. One of the most important uses of graphics is providing a visual representation
of data. They say a picture is worth a thousand words; it is almost certainly better than a thousand numbers.
Few programs that manipulate numeric data couldn't be improved with a bit of graphical output. Remember
the program in Chapter 2 that computed the future value of a ten year investment? Let's try our hand at
creating a graphical summary.
Programming with graphics requires careful planning. You'll probably want pencil and paper handy to
draw some diagrams and scratch out calculations as we go along. As usual, we begin by considering the
specification of exactly what the program will do.
The original program futval.py had two inputs, the amount of money to be invested and the annual-
ized rate of interest. Using these inputs, the program calculated the change in principal year by year for ten
years using the formula principal principal 1 apr . It then printed out the final value of the principal. In
the graphical version, the output will be a ten-year bar graph where the height of successive bars represents
the value of the principal in successive years.
Let's use a concrete example for illustration. Suppose we invest $2000 at 10% interest. This table shows
the growth of the investment over a ten-year period:
Years
0
1
2
3
4
5
6
7
8
9
10
Value
$2,000.00
$2,200.00
$2,420.00
$2,662.00
$2,928.20
$3,221.02
$3,542.12
$3,897.43
$4,287.18
$4,715.90
$5,187.49
Our program will display this information in a bar graph. Figure 5.7 shows the data in graphical form. The
graph actually contains eleven bars. The first bar shows the original value of the principal. For reference,
let's number these bars according the the number of years of interest accrued, 0*%/10.
Here is a rough design for the program.5.4. GRAPHING FUTURE VALUE
69
Figure 5.7: Bar graph showing growth of $2,000 at 10% interest
Print an introduction
Get value of principal and apr from user
Create a GraphWin
Draw scale labels on left side of window
Draw bar at position 0 with height corresponding to principal
For successive years 1 through 10
Calculate principal = principal * (1 + apr)
Draw a bar for this year having a height corresponding to principal
Wait for user to press Enter
The pause created by the last step is necessary to keep the graphics window displayed so that we can interpret
the results. Without such a pause, the program would end and the GraphWin would vanish with it.
While this design gives us the broad brush strokes for our algorithm, there are some very important details
that have been glossed over. We must decide exactly how big the graphics window will be and how we will
position the objects that appear in this window. For example, what does it mean to draw, say, a bar for year
five with height corresponding to $3,221.02?
Let's start with the size of the GraphWin. Recall that the size of a window is given in terms of the
number of pixels in each dimension. Computer screens are also measured in terms of pixels. The number of
pixels or resolution of the screen is determined by the monitor and graphics card in the computer you use.
The lowest resolution screen you are likely to encounter these days is a so-called standard VGA screen that is
640 x 480 pixels. Most screens are considerably larger. Let's make the GraphWin one quarter the size of a
640 x 480 screen, or 320 x 240. That should allow all users to see the graphical output as well as the textual
output from our program.
Given this analysis, we can flesh out a bit of our design. The third line of the design should now read:
Create a 320 x 240 GraphWin titled #-'#*.Investment Growth Chart%,*(,!
You may be wondering how this will translate into Python code. You have already seen that the GraphWin
constructor allows an optional parameter to specify the title of the window. You may also supply width and
height parameters to control the size of the window. Thus, the command to create the output window will be:
win = GraphWin("Investment Growth Chart", 320, 240)
Next we turn to the problem of printing labels along the left edge of our window. To simplify the problem,
we will assume the graph is always scaled to a maximum of $10,000 with the five labels (%-0.0K%$& to /$*10.0K*"%
as shown in the example window. The question is how should the labels be drawn? We will need some TextCHAPTER 5. OBJECTS AND GRAPHICS
70
objects. When creating Text, we specify the anchor point (the point the text is centered on) and the string to
use as the label.
The label strings are easy. Our longest label is five characters, and the labels should all line up on the
right side of a column, so the shorter strings will be padded on the left with spaces. The placement of the
labels is chosen with a bit of calculation and some trial and error. Playing with some interactive examples,
it seems that a string of length five looks nicely positioned in the horizontal direction placing the center 20
pixels in from the left edge. This leaves just a bit of whitespace at the margin.
In the vertical direction, we have just over 200 pixels to work with. A simple scaling would be to have
100 pixels represent $5,000. That means our five labels should be spaced 50 pixels apart. Using 200 pixels
for the range 0"!+10,000 leaves 240 200 40 pixels to split between the top and bottom margins. We might
want to leave a little more margin at the top to accommodate values that grow beyond $10,000. A little
experimentation suggests that putting the '*/ 0.0K&%$ label 10 pixels from the bottom (position 230) seems to
look nice.
Elaborating our algorithm to include these details, the single step
Draw scale labels on left side of window
becomes a sequence of steps
Draw
Draw
Draw
Draw
Draw
label
label
label
label
label
" 0.0K"
" 2.5K"
" 5.0K"
" 7.5K"
"10.0K"
at
at
at
at
at
(20,
(20,
(20,
(20,
(20,
230)
180)
130)
80)
30)
The next step in the original design calls for drawing the bar that corresponds to the initial amount of the
principal. It is easy to see where the lower left corner of this bar should be. The value of $0.0 is located
vertically at pixel 230, and the labels are centered 20 pixels in from the left edge. Adding another 20 pixels
gets us to the right edge of the labels. Thus the lower left corner of the 0th bar should be at location 40 ,'- 230 .
Now we just need to figure out where the opposite (upper right) corner of the bar should be so that we
can draw an appropriate rectangle. In the vertical direction, the height of the bar is determined by the value
of principal. In drawing the scale, we determined that 100 pixels is equal to $5,000. This means that
we have 100 5000 0 02 pixels to the dollar. This tells us, for example, that a principal of $2,000 should
40 pixels. In general, the y position of the upper-right corner will be
produce a bar of height 2000 02
given by 230 principal 0 02 . (Remember that 230 is the 0 point, and the y coordinates decrease going
up).
How wide should the bar be? The window is 320 pixels wide, but 40 pixels are eaten up by the labels on
the left. That leaves us with 280 pixels for 11 bars 280 11 25 4545. Let's just make each bar 25 pixels; that
will give us a bit of margin on the right side. So, the right edge of our first bar will be at position 40 25 65.
We can now fill the details for drawing the first bar into our algorithm.
Draw a rectangle from (40, 230) to (65, 230 - principal *
0.02)
At this point, we have made all the major decisions and calculations required to finish out the problem. All
that remains is to percolate these details into the rest of the algorithm. Figure 5.8 shows the general layout of
the window with some of the dimensions we have chosen.
Let's figure out where the lower-left corner of each bar is going to be located. We chose a bar width
of 25, so the bar for each successive year will start 25 pixels farther right than the previous year. We can
use a variable year to represent the year number and calculate the x coordinate of the lower left corner as
year 25 40. (The 40 leaves space on the left edge for the labels.) Of course, the y coordinate of this
point is still 230 (the bottom of the graph).
To find the upper-right corner of a bar, we add 25 (the width of the bar) to the x value of the lower-left
corner. The y value of the upper right corner is determined from the (updated) value of principal exactly
as we determined it for the first bar. Here is the refined algorithm.
for year running from a value of 1 up through 10:
Calculate principal = principal * (1 + apr)5.4. GRAPHING FUTURE VALUE
71
(0,0)
10.0K
7.5K
240
5.0K
2.5K
50
0.0K
10
(315,230)
(40,230)
(319,239)
40
25
320
Figure 5.8: Position of elements in future value bar graph.
Calculate xll = 25 * year + 40
Calculate height = principal * 0.02
Draw a rectangle from (xll, 230) to (xll+25, 230 - height)
The variable xll stands for x lower left"$!the x value of the lower left corner of the bar.
Putting all of this together produces the detailed algorithm shown below.
Print an introduction
Get value of principal and apr from user
Create a 320x240 GraphWin titled ++,#*(Investment Growth Chart/&,,,'
Draw label " 0.0K" at (20,230)
Draw label " 2.5K" at (20, 180)
Draw label " 5.0K" at (20, 130)
Draw label " 7.5K" at (20, 80)
Draw label "10.0K" at (20, 30)
Draw a rectangle from (40, 230) to (65, 230 - principal * 0.02)
for year running from a value of 1 up through 10:
Calculate principal = principal * (1 + apr)
Calculate xll = 25 * year + 40
Draw a rectangle from (xll, 230) to (xll+25, 230 - principal * 0.02)
Wait for user to press Enter
Whew! That was a lot of work, but we are finally ready to translate this algorithm into actual Python
code. The translation is straightforward using objects from the graphics module. Here's the program:
# futval_graph.py
from graphics import *
def main():
# Introduction
print "This program plots the growth of a 10-year investment."
# Get principal and interest rate
principal = input("Enter the initial principal: ")
apr = input("Enter the annualized interest rate: ")CHAPTER 5. OBJECTS AND GRAPHICS
72
# Create a graphics window with labels on left edge
win = GraphWin("Investment Growth Chart", 320, 240)
win.setBackground("white")
Text(Point(20, 230), '&/ 0.0K#/!).draw(win)
Text(Point(20, 180), %&" 2.5K+#&).draw(win)
Text(Point(20, 130), ..% 5.0K$(/).draw(win)
Text(Point(20, 80), $#* 7.5k(-,).draw(win)
Text(Point(20, 30), /,"10.0K+!.).draw(win)
# Draw bar for initial principal
height = principal * 0.02
bar = Rectangle(Point(40, 230), Point(65, 230-height))
bar.setFill("green")
bar.setWidth(2)
bar.draw(win)
# Draw bars for successive years
for year in range(1,11):
# calculate value for the next year
principal = principal * (1 + apr)
# draw bar for this value
xll = year * 25 + 40
height = principal * 0.02
bar = Rectangle(Point(xll, 230), Point(xll+25, 230-height))
bar.setFill("green")
bar.setWidth(2)
bar.draw(win)
raw_input("Press <Enter> to quit.")
win.close()
main()
If you study this program carefully, you will see that I added a number of features to spruce it up a bit.
All graphical objects support methods for changing color. I have set the background color of the window to
white (by default it's gray).
win.setBackground("white")
I have also changed the color of the bar object. The following line asks the bar to color its interior green
(because it's money, you know).
bar.setFill("green")
You can also change the color of a shape's outline using the setOutline method. In this case, I have
chosen to leave the outline the default black so that the bars stand out from each other. To enhance this effect,
this code makes the outline wider (two pixels instead of the default one).
bar.setWidth(2)
You might also have noted the economy of notation in drawing the labels. Since we don't ever change the
labels, saving them into a variable is unnecessary. We can just create a Text object, tell it to draw itself, and
be done with it. Here is an example.
Text(Point(20,230), #'+ 0.0K"!").draw(win)
Finally, take a close look at the use of the year variable in the loop.5.5. CHOOSING COORDINATES
73
for year in range(1,11):
The expression range(1,11) produces a sequence of ints 1)%.10. The loop index variable year marches
through this sequence on successive iterations of the loop. So, the first time through year is 1, then 2, then
3, etc., up to 10. The value of year is then used to compute the proper position of the lower left corner of
each bar.
xll = year * 25 + 40
I hope you are starting to get the hang of graphics programming. It's a bit strenuous, but very addictive.
5.5 Choosing Coordinates
The lion's share of the work in designing the futval graph program was in determining the precise coor-
dinates where things would be placed on the screen. Most graphics programming problems require some sort
of a coordinate transformation to change values from a real-world problem into the window coordinates that
get mapped onto the computer screen. In our example, the problem domain called for x values representing
the year (0+/!10) and y values representing monetary amounts ($0(%'$10,000). We had to transform these val-
ues to be represented in a 320 x 240 window. It's nice to work through an example or two to see how this
transformation happens, but it makes for tedious programming.
Coordinate transformation is an integral and well-studied component of computer graphics. It doesn't
take too much mathematical savvy to see that the transformation process always follows the same general
pattern. Anything that follows a pattern can be done automatically. In order to save you the trouble of having
to explicitly convert back and forth between coordinate systems, the graphics module provides a simple
mechanism to do it for you. When you create a GraphWin you can specify a coordinate system for the
window using the setCoords method. The method requires four parameters specifying the coordinates
of the lower-left and upper-right corners, respectively. You can then use this coordinate system to place
graphical objects in the window.
To take a simple example, suppose we just want to divide the window into nine equal squares, Tic-Tac-
Toe fashion. This could be done without too much trouble using the default 200 x 200 window, but it would
require a bit of arithmetic. The problem becomes trivial if we first change the coordinates of the window to
run from 0 to 3 in both dimensions.
# create a default 200x200 window
win = GraphWin("Tic-Tac-Toe")
# set coordinates to go from (0,0) in the lower left
#
to (3,3) in the upper right.
win.setCoords(0.0, 0.0, 3.0, 3.0)
# Draw vertical lines
Line(Point(1,0), Point(1,3)).draw(win)
Line(Point(2,0), Point(2,3)).draw(win)
# Draw horizontal lines
Line(Point(0,1), Point(3,1)).draw(win)
Line(Point(0,2), Point(3,2)).draw(win)
Another benefit of this approach is that the size of the window can be changed by simply changing the di-
mensions used when the window is created (e.g. win = GraphWin("Tic-Tac-Toe", 300, 300)).
Because the same coordinates span the window (due to setCoords) the objects will scale appropriately to
the new window size. Using $(.raw#,! window coordinates would require changes in the definitions of the lines.
We can apply this idea to simplify our graphing future value program. Basically, we want our graphics
window to go from 0 through 10 (representing years) in the x dimension and from 0 to 10,000 (representing
dollars) in the y dimension. We could create just such a window like this.CHAPTER 5. OBJECTS AND GRAPHICS
74
win = GraphWin("Investment Growth Chart", 320, 240)
win.setCoords(0.0, 0.0, 10.0, 10000.0)
Then creating a bar for any values of year and principal would be simple. Each bar starts at the given
year and a baseline of 0 and grows to the next year and a height equal to principal.
bar = Rectangle(Point(year, 0), Point(year+1, principal))
There is a small problem with this scheme. Can you see what I have forgotten? The bars will fill the entire
window; we haven't left any room for labels or margins around the edges. This is easily fixed by expanding
the coordinates of the window slightly. Since our bars start at 0, we can locate the left side labels at -1. We
can add a bit of whitespace around the graph by expanding the coordinates slightly beyond that required for
our graph. A little experimentation leads to this window definition:
win = GraphWin("Investment Growth Chart", 320, 240)
win.setCoords(-1.75,-200, 11.5, 10400)
Here is the program again, using the alternative coordinate system:
# futval_graph2.py
from graphics import *
def main():
# Introduction
print "This program plots the growth of"
print "a 10-year investment."
# Get principal and interest rate
principal = input("Enter the initial principal: ")
apr = input("Enter the annualized interest rate: ")
# Create a graphics window with labels on left edge
win = GraphWin("Investment Growth Chart", 320, 240)
win.setBackground("white")
win.setCoords(-1.75,-200, 11.5, 10400)
Text(Point(-1, 0), %$- 0.0K!*").draw(win)
Text(Point(-1, 2500), )&) 2.5K./').draw(win)
Text(Point(-1, 5000), "(' 5.0K*"#).draw(win)
Text(Point(-1, 7500), )$) 7.5k)+-).draw(win)
Text(Point(-1, 10000), //&10.0K%))).draw(win)
# Draw bar for initial principal
bar = Rectangle(Point(0, 0), Point(1, principal))
bar.setFill("green")
bar.setWidth(2)
bar.draw(win)
# Draw a bar for each subsequent year
for year in range(1, 11):
principal = principal * (1 + apr)
bar = Rectangle(Point(year, 0), Point(year+1, principal))
bar.setFill("green")
bar.setWidth(2)
bar.draw(win)5.6. INTERACTIVE GRAPHICS
75
raw_input("Press <Enter> to quit.")
main()
Notice how the complex calculations have been eliminated. This version also makes it easy to change the
size of the GraphWin. Changing the window size to 640 x 480 produces a larger, but correctly drawn bar
graph. In the original program, all of the calculations would have to be redone to accommodate the new
scaling factors in the larger window.
Obviously, the second version of our program is much easier to develop and understand. When you are
doing graphics programming, give some consideration to choosing a coordinate system that will make your
task as simple as possible.
5.6 Interactive Graphics
Graphical interfaces can be used for input as well as output. In a GUI environment, users typically interact
with their applications by clicking on buttons, choosing items from menus, and typing information into
on-screen text boxes. These applications use a technique called event-driven programming. Basically, the
program draws a set of interface elements (often called widgets) on the screen, and then waits for the user to
do something.
When the user moves the mouse, clicks a button or types a key on the keyboard, this generates an event.
Basically, an event is an object that encapsulates data about what just happened. The event object is then sent
off to an appropriate part of the program to be processed. For example, a click on a button might produce
a button event. This event would be passed to the button handling code, which would then perform the
appropriate action corresponding to that button.
Event-driven programming can be tricky for novice programmers, since it's hard to figure out &-$who's in
charge*%- at any given moment. The graphics module hides the underlying event-handling mechanisms and
provides two simple ways of getting user input in a GraphWin.
5.6.1 Getting Mouse Clicks
We can get graphical information from the user via the getMouse method of the GraphWin class. When
getMouse is invoked on a GraphWin, the program pauses and waits for the user to click the mouse
somewhere in the graphics window. The spot where the user clicks is returned to the program as a Point.
Here is a bit of code that reports the coordinates of ten successive mouse clicks.
from graphics import *
win = GraphWin("Click Me!")
for i in range(10):
p = win.getMouse()
print "You clicked (%d, %d)" % (p.getX(), p.getY())
The value returned by getMouse() is a ready-made Point. We can use it like any other point using
accessors such as getX and getY or other methods such as draw and move.
Here is an example of an interactive program that allows the user to draw a triangle by clicking on three
points in a graphics window. This example is completely graphical, making use of Text objects as prompts.
No interaction with a Python text window is required. If you are programming in a Windows environment,
you can name this program using a .pyw extension. Then when the program is run, it will not even display
the Python shell window.
# Program: triangle.pyw
from graphics import *
def main():
win = GraphWin("Draw a Triangle")CHAPTER 5. OBJECTS AND GRAPHICS
76
win.setCoords(0.0, 0.0, 10.0, 10.0)
message = Text(Point(5, 0.5), "Click on three points")
message.draw(win)
# Get and draw three vertices of triangle
p1 = win.getMouse()
p1.draw(win)
p2 = win.getMouse()
p2.draw(win)
p3 = win.getMouse()
p3.draw(win)
# Use Polygon object to draw the triangle
triangle = Polygon(p1,p2,p3)
triangle.setFill("peachpuff")
triangle.setOutline("cyan")
triangle.draw(win)
# Wait for another click to exit
message.setText("Click anywhere to quit.")
win.getMouse()
main()
The three-click triangle illustrates a couple new features of the graphics module. There is no triangle
class; however there is a general class Polygon that can be used for any multi-sided, closed shape. The
constructor for Polygon accepts any number of points and creates a polygon by using line segments to
connect the points in the order given and to connect the last point back to the first. A triangle is just a
three-sided polygon. Once we have three Points p1, p2, and p3, creating the triangle is a snap.
triangle = Polygon(p1, p2, p3)
You should also study how the Text object is used to provide prompts. A single Text object is created
and drawn near the beginning of the program.
message = Text(Point(5, 0.5), "Click on three points")
message.draw(win)
To change the prompt, we don't need to create a new Text object, we can just change the text that is
displayed. This is done near the end of the program with the setText method.
message.setText("Click anywhere to quit.")
As you can see, the getMouse method of GraphWin provides a simple way of interacting with the user
in a graphics-oriented program.
5.6.2 Handling Textual Input
In the triangle example, all of the input was provided through mouse clicks. The graphics module also
includes a simple Entry object that can be used to get keyboard input in a GraphWin.
An Entry object draws a box on the screen that can contain text. It understands setText and getText
methods just like the Text object does. The difference is that the contents of an Entry can be edited by the
user. Here's a version of the temperature conversion program from Chapter 2 with a graphical user interface:
# convert_gui1.pyw
# Program to convert Celsius to Fahrenheit using a simple
#
graphical interface.5.6. INTERACTIVE GRAPHICS
77
from graphics import *
def main():
win = GraphWin("Celsius Converter", 300, 200)
win.setCoords(0.0, 0.0, 3.0, 4.0)
# Draw the interface
Text(Point(1,3), "
Celsius Temperature:").draw(win)
Text(Point(1,1), "Fahrenheit Temperature:").draw(win)
input = Entry(Point(2,3), 5)
input.setText("0.0")
input.draw(win)
output = Text(Point(2,1),"")
output.draw(win)
button = Text(Point(1.5,2.0),"Convert It")
button.draw(win)
Rectangle(Point(1,1.5), Point(2,2.5)).draw(win)
# wait for a mouse click
win.getMouse()
# convert input
celsius = eval(input.getText())
fahrenheit = 9.0/5.0 * celsius + 32
# display output and change button
output.setText("%0.1f" % fahrenheit)
button.setText("Quit")
# wait for click and then quit
win.getMouse()
win.close()
main()
When run, this produces a window with an entry box for typing in a Celsius temperature and a #.*button+$)
for doing the conversion. The button is just for show. The program actually just pauses for a mouse click
anywhere in the window. Figure 5.9 shows how the window looks when the program starts.
Initially, the input entry box is set to contain the value 0.0. The user can delete this value and type in
another temperature. The program pauses until the user clicks the mouse. Notice that the point where the
user clicks is not even saved; the getMouse function is just used to pause the program until the user has a
chance to enter a value in the input box.
The program then processes the input in four steps. First, the text in the input box is converted into a
number (via eval). This number is then converted to degrees Fahrenheit. Finally, the resulting number is
turned back into a string (via the string formatting operator) for display in the output text area.
Figure 5.10 shows how the window looks after the user has typed an input and clicked the mouse. Notice
that the converted temperature shows up in the output area, and the label on the button has changed to "%"Quit//*
to show that clicking again will exit the program. This example could be made much prettier using some of
the options in the graphics library for changing the colors, sizes and line widths of the various widgets. The
code for the program is deliberately Spartan to illustrate just the essential elements of GUI design.
Although the basic tools getMouse and Entry do not provide a full-fledged GUI environment, we will
see in later chapters how these simple mechanisms can support surprisingly rich interactions.78
CHAPTER 5. OBJECTS AND GRAPHICS
Figure 5.9: Initial screen for graphical temperature converter
Figure 5.10: Graphical temperature converter after user input.5.7. GRAPHICS MODULE REFERENCE
79
5.7 Graphics Module Reference
The examples in this chapter have touched on most of the elements in the graphics module. This section
provides a complete reference to the objects and functions provided in the graphics library. Experienced
programmers use these sorts of guides to learn about new libraries. You will probably want to refer back to
this section often when you are writing your own graphical programs.
5.7.1 GraphWin Objects
A GraphWin object represents a window on the screen where graphical images may be drawn. A program
may define any number of GraphWins. A GraphWin understands the following methods.
GraphWin(title, width, height) Constructs a new graphics window for drawing on the screen.
The parameters are optional, the default title is "/-Graphics Window,*(/ and the default size is 200 x 200.
plot(x, y, color) Draws the pixel at x //& y in the window. Color is optional, black is the default.
plotPixel(x, y, Color) Draws the pixel at the %$/raw%!$ position x (#) y ignoring any coordinate trans-
formations set up by setCoords.
setBackground(color) Sets the window background to the given color. The initial background is
gray. See section 5.7.5 for information on specifying colors.
close() Closes the on-screen window.
getMouse() Pauses for the user to click a mouse in the window and returns where the mouse was clicked
as a Point object.
setCoords(xll, yll, xur, yur) Sets the coordinate system of the window. The lower left corner
is xll %%. yll and the upper right corner is xur '(" yur . All subsequent drawing will be done with respect
to the altered coordinate system (except for plotPixel).
flush() Updates the appearance of the window to reflect all drawing operations that have been done so
far. In normal operation, the window is only updated during /!.idle(!% periods. A sequence of drawing
commands may end up appearing all at once. If you want to get an animation effect, flush should be
called at appropriate places in the program to perform drawing operations incrementally.
5.7.2 Graphics Objects
The module provides the following classes of drawable objects: Point, Line, Circle, Oval, Rectangle,
Polygon, and Text. All objects are initially created unfilled with a black outline. All graphics objects sup-
port the following generic set of methods.
setFill(color) Sets the interior of the object to the given color.
setOutline(color) Sets the outline of the object to the given color.
setWidth(pixels) Sets the width of the outline of the object to this many pixels.
draw(aGraphWin) Draws the object into the given GraphWin.
undraw() Undraws the object from a graphics window. This produces an error if the object is not currently
drawn.
move(dx,dy) Moves the object dx units in the x direction and dy units in the y direction. If the object is
currently drawn, the image is adjusted to the new position.
clone() Returns a duplicate of the object. Clones are always created in an undrawn state. Other than that,
they are identical to the cloned object.80
CHAPTER 5. OBJECTS AND GRAPHICS
Point Methods
Point(x,y) Constructs a point having the given coordinates.
getX() Returns the x coordinate of a point.
getY() Returns the y coordinate of a point.
Line Methods
Line(point1, point2) Constructs a line segment from point1 to point2.
setArrow(string) Sets the arrowhead status of a line. Arrows may be drawn at either the first point,
the last point, or both. Possible values of string are ))$first&$#, &#"last#.&, "#-both&*/, and &&%none$,$.
The default setting is ,$$none*#+.
getCenter() Returns a clone of the midpoint of the line segment.
getP1(), getP2() Returns a clone of the corresponding endpoint of the segment.
Circle Methods
Circle(centerPoint, radius) Constructs a circle with given center point and radius.
getCenter() Returns a clone of the center point of the circle.
getRadius() Returns the radius of the circle.
getP1(), getP2() Returns a clone of the corresponding corner of the circle's bounding box. These are
opposite corner points of a square that circumscribes the circle.
Rectangle Methods
Rectangle(point1, point2) Constructs a rectangle having opposite corners at point1 and point2.
getCenter() Returns a clone of the center point of the rectangle.
getP1(), getP2() Returns a clone of corner points originally used to construct the rectangle.
Oval Methods
Oval(point1, point2) Constructs an oval in the bounding box determined by point1 and point2.
getCenter() Returns a clone of the point at the center of the oval.
getP1(), getP2 Return a clone of the corresponding point used to construct the oval.
Polygon Methods
Polygon(point1, point2, point3, ...) Constructs a polygon having the given points as ver-
tices.
getPoints() Returns a list containing clones of the points used to construct the polygon.5.7. GRAPHICS MODULE REFERENCE
81
Text Methods
Text(anchorPoint, string) Constructs a text object that displays the given string centered at
anchorPoint. The text is displayed horizontally.
setText(string) Sets the text of the object to string.
getText() Returns the current string.
getAnchor() Returns a clone of the anchor point.
setFace(family) Changes the font face to the given family. Possible values are: .,%helvetica))(,
,&"courier%)', **)times roman/'*, and .,'arial*'+.
setSize(point) Changes the font size to the given point size. Sizes from 5 to 36 points are legal.
setStyle(style) Changes font to the given style. Possible values are: -$&normal)-(, $$+bold($%,
'/*italic/%#, and &&%bold italic.%#.
5.7.3 Entry Objects
Objects of type Entry are displayed as text entry boxes that can be edited by the user of the program. Entry
objects support the generic graphics methods move(), draw(graphwin), undraw(), setFill(color),
and clone(). The Entry specific methods are given below.
Entry(centerPoint, width) Constructs an Entry having the given center and width. The width
is specified in number of characters of text that can be displayed.
getAnchor() Returns a clone of the point where the entry box is centered.
getText() Returns the string of text that is currently in the entry box.
setText(string) Sets the text in the entry box to the given string.
5.7.4 Displaying Images
The graphics module also provides minimal support for displaying certain image formats into a GraphWin.
Most platforms will support JPEG, PPM and GIF images. Display is done with an Image object. Images
support the generic methods move(dx,dy), draw(graphwin), undraw(), and clone(). Image
specific methods are given below.
Image(centerPoint, filename) Constructs an image from contents of the given file, centered at
the given center point.
getAnchor() Returns a clone of the point where the image is centered.
5.7.5 Generating Colors
Colors are indicated by strings. Most normal colors such as /+'red'%-, )#(purple.#&, &&!green)&$, -,+cyan.,', etc.
should be available. Many colors come in various shades, such as "",red1-(), ''$red2-%(,#-"red3*++, ')"red4.".,
which are increasingly darker shades of red.
The graphics module also provides a function for mixing your own colors numerically. The function
color rgb(red, green, blue) will return a string representing a color that is a mixture of the inten-
sities of red, green and blue specified. These should be ints in the range 0#&*255. Thus color rgb(255, 0, 0)
is a bright red, while color rgb(130, 0, 130) is a medium magenta.CHAPTER 5. OBJECTS AND GRAPHICS
82
5.8 Exercises
1. Pick an example of an interesting real-world object and describe it as a programming object by listing
its data (attributes, what it %$-knows+,') and its methods (behaviors, what it can .!.do'(%).
2. Describe in your own words the object produced by each of the following operations from the graphics
module. Be as precise as you can. Be sure to mention such things as the size, position, and appearance
of the various objects. You may include a sketch if that helps.
(a) Point(130,130)
(b) c = Circle(Point(30,40),25)
c.setFill(","blue"&.)
c.setOutline(*!"red&.")
(c) r = Rectangle(Point(20,20), Point(40,40))
r.setFill(color_rgb(0,255,150))
r.setWidth(3)
(d) l = Line(Point(100,100), Point(100,200))
l.setOutline(.-#red4,//)
l.setArrow(-+#first+&')
(e) Oval(Point(50,50), Point(60,100))
(f) shape = Polygon(Point(5,5), Point(10,10), Point(5,10), Point(10,5))
shape.setFill("$'orange/+&)
(g) t = Text(Point(100,100), "Hello World!")
t.setFace("courier")
t.setSize(16)
t.setStyle("italic")
3. Describe what happens when the following interactive graphics program runs.
from graphics import *
def main():
win = GraphWin()
shape = Circle(Point(50,50), 20)
shape.setOutline("red")
shape.setFill("red")
shape.draw(win)
for i in range(10):
p = win.getMouse()
c = shape.getCenter()
dx = p.getX() - c.getX()
dy = p.getY() - c.getY()
shape.move(dx,dy)
win.close()
4. Modify the program from the previous problem in the following ways:
(a) Make it draw squares instead of circles.
(b) Have each successive click draw an additional square on the screen (rather than moving the ex-
isting one).
(c) Print a message on the window when all the clicks is entered, and wait for a final click before
closing the window.5.8. EXERCISES
83
5. An archery target consists of a central circle of yellow surrounded by concentric rings of red, blue,
black and white. Each ring has the same +$#width,$%( which is the same as the radius of the yellow circle.
Write a program that draws such a target. Hint: Objects drawn later will appear on top of objects drawn
earlier.
6. Write a program that draws some sort of face.
7. Write a program that draws a winter scene with a Christmas tree and a snowman.
8. Write a program that draws 5 dice on the screen depicting a straight (1, 2, 3, 4, 5 or 2, 3, 4, 5, 6).
9. Modify the graphical future value program so that the input (principal and apr) also are done in a
graphical fashion using Entry objects.
10. Circle Intersection. Write a program that computes the intersection of a circle with a horizontal line
and displays the information textually and graphically.
Input: Radius of the circle and the y-intercept of the line.
Output: Draw a circle centered at 0 #// 0 with the given radius in a window with coordinates running
from -10,-10 to 10,10.
Draw a horizontal line across the window with the given y-intercept.
Draw the two points of intersection in red.
Print out the x values of the points of intersection.
Formula: x
r 2
y 2
11. Line Information.
This program allows the user to draw a line segment and then displays some graphical and textual
information about the line segment.
Input: 2 mouse clicks for the end points of the line segment.
Output: Draw the midpoint of the segment in cyan.
Draw the line.
Print the length and the slope of the line.
dx x 2 x 1
dy y 2 y 1
slope dy dx
length
dx 2 dy 2
Formulas:
12. Rectangle Information.
This program displays information about a rectangle drawn by the user.
Input: 2 mouse clicks for the opposite corners of a rectangle.
Output: Draw the rectangle.
Print the perimeter and area of the rectangle.
Formulas:
length width
area
perimeter 2 length width
13. Triangle Information.
Same as previous problem, but with 3 clicks for the verticies of a triangle.
Formulas: For perimeter, see length from line problem.
s s a s b s c where a +,. b ,*+ and c are the lengths of the sides and s
area
a b c
2CHAPTER 5. OBJECTS AND GRAPHICS
84
14. 5-click house.
You are to write a program that allows the user to draw a simple house using five mouse-clicks. The
first two clicks will be the opposite corners of the rectangular frame of the house. The third click will
indicate the center of the top edge of a rectangular door. The door should have a total width that is 15
of the width of the house frame. The sides of the door should extend from the corners of the top down
to the bottom of the frame. The fourth click will indicate the center of a square window. The window
is half as wide as the door. The last click will indicate the peak of the roof. The edges of the roof will
extend from the point at the peak to the corners of the top edge of the house frame.
5
2
3
1
4Chapter 6
Defining Functions
The programs that we have written so far comprise a single function, usually called main. We have also been
using pre-written functions and methods including built-in Python functions (e.g., abs), functions from the
Python standard libraries (e.g., math.sqrt, string.split), and object methods from the graphics
module (e.g., myPoint.getX()).
Functions are an important tool for building sophisticated programs. This chapter covers the whys and
hows of designing your own functions to make your programs easier to write and understand.
6.1 The Function of Functions
In the previous chapter, we looked at a graphic solution to the future value problem. This program makes use
of the graphics library to draw a bar chart showing the growth of an investment. Here is the program as
we left it:
# futval_graph2.py
from graphics import *
def main():
# Introduction
print "This program plots the growth of a 10-year investment."
# Get principal and interest rate
principal = input("Enter the initial principal: ")
apr = input("Enter the annualized interest rate: ")
# Create a graphics window with labels on left edge
win = GraphWin("Investment Growth Chart", 640, 480)
win.setBackground("white")
win.setCoords(-1.75,-200, 11.5, 10400)
Text(Point(-1, 0), &-" 0.0K%*,).draw(win)
Text(Point(-1, 2500), .%) 2.5K%-,).draw(win)
Text(Point(-1, 5000), $,. 5.0K)/#).draw(win)
Text(Point(-1, 7500), ##. 7.5k+,-).draw(win)
Text(Point(-1, 10000), "'!10.0K'**).draw(win)
# Draw bar for initial principal
bar = Rectangle(Point(0, 0), Point(1, principal))
bar.setFill("green")
bar.setWidth(2)
bar.draw(win)
85CHAPTER 6. DEFINING FUNCTIONS
86
# Draw a bar for each subsequent year
for year in range(1, 11):
principal = principal * (1 + apr)
bar = Rectangle(Point(year, 0), Point(year+1, principal))
bar.setFill("green")
bar.setWidth(2)
bar.draw(win)
raw_input("Press <Enter> to quit.")
This is certainly a workable program, but there is a nagging issue of program style that really should be
addressed. Notice that this program draws bars in two different places. The initial bar is drawn just before
the loop, and the subsequent bars are drawn inside of the loop.
Having similar code like this in two places has some drawbacks. Obviously, one issue is having to write
the code twice. A more subtle problem is that the code has to be maintained in two different places. Should we
decide to change the color or other facets of the bars, we would have to make sure these changes occurred in
both places. Failing to keep related parts of the code in synch is a common problem in program maintenance.
Functions can be used to reduce code duplication and make programs more understandable and easier to
maintain. Before fixing up the future value program, let's take look at what functions have to offer.
6.2 Functions, Informally
You can think of a function as a subprogram)/.a small program inside of a program. The basic idea of a
function is that we write a sequence of statements and give that sequence a name. The instructions can then
be executed at any point in the program by referring to the function name.
The part of the program that creates a function is called a function definition. When a function is
subsequently used in a program, we say that the definition is called or invoked. A single function definition
may be called at many different points of a program.
Let's take a concrete example. Suppose you want to write a program that prints out the lyrics to the
*+)Happy Birthday-*% song. The standard lyrics look like this.
Happy
Happy
Happy
Happy
birthday to you!
birthday to you!
birthday, dear <insert-name>.
birthday to you!
We're going to play with this example in the interactive Python environment. You might want to fire up
Python and try some of this out for yourself.
A simple approach to this problem is to use four print statements. Here's an interactive session that
creates a program for singing Happy Birthday to Fred.
>>> def main():
print "Happy
print "Happy
print "Happy
print "Happy
birthday to you!"
birthday to you!"
birthday, dear Fred."
birthday to you!"
We can then run this program to get our lyrics.
>>> main()
Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Fred.
Happy birthday to you!6.2. FUNCTIONS, INFORMALLY
87
Obviously, there is some duplicated code in this program. For such a simple program, that's not a big
deal, but even here it's a bit annoying to keep retyping the same line. Let's introduce a function that prints
the lyrics of the first, second, and fourth lines.
>>> def happy():
print "Happy birthday to you!"
We have defined a new function called happy. Here is an example of what it does.
>>> happy()
Happy birthday to you!
Invoking the happy command causes Python to print a line of the song.
Now we can redo the verse for Fred using happy. Let's call our new version singFred.
>>> def singFred():
happy()
happy()
print "Happy birthday, dear Fred."
happy()
This version required much less typing, thanks to the happy command. Let's try printing the lyrics for Fred
just to make sure it works.
>>> singFred()
Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Fred.
Happy birthday to you!
So far, so good. Now suppose that it's also Lucy's birthday, and we want to sing a verse for Fred followed
by a verse for Lucy. We've already got the verse for Fred; we can prepare one for Lucy as well.
>>> def singLucy():
happy()
happy()
print "Happy birthday, dear Lucy."
happy()
Now we can write a main program that sings to both Fred and Lucy.
>>> def main():
singFred()
print
singLucy()
The bare print between the two function calls puts a space between the verses in our output. And here's
the final product in action.
>>> main()
Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Fred.
Happy birthday to you!
Happy
Happy
Happy
Happy
birthday to you!
birthday to you!
birthday, dear Lucy.
birthday to you!CHAPTER 6. DEFINING FUNCTIONS
88
Well now, that certainly seems to work, and we've removed some of the duplication by defining the
happy function. However, something still doesn't feel quite right. We have two functions, singFred and
singLucy, that are almost identical. Following this approach, adding a verse for Elmer would have us
create a singElmer function that looks just like those for Fred and Lucy. Can't we do something about the
proliferation of verses?
Notice that the only difference between singFred and singLucy is the name at the end of the third
print statement. The verses are exactly the same except for this one changing part. We can collapse these
two functions together by using a parameter. Let's write a generic function called sing.
>>> def sing(person):
happy()
happy()
print "Happy Birthday, dear", person + "."
happy()
This function makes use of a parameter named person. A parameter is a variable that is initialized when
the function is called. We can use the sing function to print a verse for either Fred or Lucy. We just need to
supply the name as a parameter when we invoke the function.
>>> sing("Fred")
Happy birthday to you!
Happy birthday to you!
Happy Birthday, dear Fred.
Happy birthday to you!
>>> sing("Lucy")
Happy birthday to you!
Happy birthday to you!
Happy Birthday, dear Lucy.
Happy birthday to you!
Let's finish with a program that sings to all three of our birthday people.
>>> def main():
sing("Fred")
print
sing("Lucy")
print
sing("Elmer")
It doesn't get much easier than that.
Here is the complete program as a module file.
# happy.py
def happy():
print "Happy Birthday to you!"
def sing(person):
happy()
happy()
print "Happy birthday, dear", person + "."
happy()
def main():
sing("Fred")
print6.3. FUTURE VALUE WITH A FUNCTION
89
sing("Lucy")
print
sing("Elmer")
6.3 Future Value with a Function
Now that you've seen how defining functions can help solve the code duplication problem, let's return to
the future value graph. Recall the problem is that bars of the graph are printed at two different places in the
program.
The code just before the loop looks like this.
# Draw bar for initial principal
bar = Rectangle(Point(0, 0), Point(1, principal))
bar.setFill("green")
bar.setWidth(2)
bar.draw(win)
And the code inside of the loop is as follows.
bar = Rectangle(Point(year, 0), Point(year+1, principal))
bar.setFill("green")
bar.setWidth(2)
bar.draw(win)
Let's try to combine these two into a single function that draws a bar on the screen.
In order to draw the bar, we need some information. Specifically, we need to know what year the bar will
be for, how tall the bar will be, and what window the bar will be drawn in. These three values will be supplied
as parameters for the function. Here's the function definition.
def drawBar(window, year, height):
# Draw a bar in window for given year with given height
bar = Rectangle(Point(year, 0), Point(year+1, height))
bar.setFill("green")
bar.setWidth(2)
bar.draw(window)
To use this function, we just need to supply values for the three parameters. For example, if win is a
GraphWin, we can draw a bar for year 0 and a principal of $2,000 by invoking drawBar like this.
drawBar(win, 0, 2000)
Incorporating the drawBar function, here is the latest version of our future value program.
# futval_graph3.py
from graphics import *
def drawBar(window, year, height):
# Draw a bar in window starting at year with given height
bar = Rectangle(Point(year, 0), Point(year+1, height))
bar.setFill("green")
bar.setWidth(2)
bar.draw(window)
def main():
# Introduction
print "This program plots the growth of a 10-year investment."CHAPTER 6. DEFINING FUNCTIONS
90
# Get principal and interest rate
principal = input("Enter the initial principal: ")
apr = input("Enter the annualized interest rate: ")
# Create a graphics window with labels on left edge
win = GraphWin("Investment Growth Chart", 320, 240)
win.setBackground("white")
win.setCoords(-1.75,-200, 11.5, 10400)
Text(Point(-1, 0), &&# 0.0K#)&).draw(win)
Text(Point(-1, 2500), (#% 2.5K*%/).draw(win)
Text(Point(-1, 5000), !'# 5.0K%!").draw(win)
Text(Point(-1, 7500), &'+ 7.5k'!#).draw(win)
Text(Point(-1, 10000), &"-10.0K./.).draw(win)
# Draw bar for initial principal
drawBar(win, 0, principal)
# Draw a bar for each subsequent year
for year in range(1, 11):
principal = principal * (1 + apr)
drawBar(win, year, principal)
raw_input("Press <Enter> to quit.")
You can see how drawBar has eliminated the duplicated code. Should we wish to change the appearance
of the bars in the graph, we only need to change the code in one spot, the definition of drawBar. Don't worry
yet if you don't understand every detail of this example. You still have some things to learn about functions.
6.4 Functions and Parameters: The Gory Details
You may be wondering about the choice of parameters for the drawBar function. Obviously, the year for
which a bar is being drawn and the height of the bar are the changeable parts in the drawing of a bar. But,
why is window also a parameter to this function? After all, we will be drawing all of the bars in the same
window; it doesn't seem to change.
The reason for making window a parameter has to do with the scope of variables in function definitions.
Scope refers to the places in a program where a given variable may be referenced. Remember each function
is its own little subprogram. The variables used inside of one function are local to that function, even if they
happen to have the same name as variables that appear inside of another function.
The only way for a function to see a variable from another function is for that variable to be passed as a
parameter. Since the GraphWin (in the variable win) is created inside of main, it is not directly accessible
in drawBar. However, the window parameter in drawBar gets assigned the value of win from main
when drawBar is called. To see how this happens, we need to take a more detailed look at the function
invocation process.
A function definition looks like this.
def <name>(<formal-parameters>):
<body>
The name of the function must be an identifier, and formal-parameters is a (possibly empty) list of
variable names (also identifiers). The formal parameters, like all variables used in the function, are only
accessible in the body of the function. Variables with identical names elswhere in the program are distinct
from the formal parameters and variables inside of the function body.
A function is called by using its name followed by a list of actual parameters or arguments.
<name>(<actual-parameters>)6.4. FUNCTIONS AND PARAMETERS: THE GORY DETAILS
91
When Python comes to a function call, it initiates a four-step process.
1. The calling program suspends at the point of the call.
2. The formal parameters of the function get assigned the values supplied by the actual parameters in the
call.
3. The body of the function is executed.
4. Control returns to the point just after where the function was called.
Returning to the Happy Birthday example, let's trace through the singing of two verses. Here is part of
the body from main.
sing("Fred")
print
sing("Lucy")
...
When Python gets to sing("Fred"), execution of main is temporarily suspended. At this point, Python
looks up the definition of sing and sees that it has a single formal parameter, person. The formal parameter
is assigned the value of the actual, so it is as if we had executed this statement:
person = "Fred"
A snapshot of this situation is shown in Figure 6.1. Notice the variable person inside of sing has just been
initialized.
def
def main():
person = "Fred"
sing("Fred")
print
sing("Lucy")
sing(person):
happy()
happy()
print "Happy birthday, dear", person + "."
happy()
person: "Fred"
Figure 6.1: Illustration of control transferring to sing.
At this point, Python begins executing the body of sing. The first statement is another function call, this
one to happy. Python suspends execution of sing and transfers control to the called function. The body of
happy consists of a single print. This statement is executed, and then control returns to where it left off
in sing. Figure 6.2 shows a snapshot of the execution so far.
def
def main():
person = "Fred"
sing("Fred")
print
sing("Lucy")
def happy():
sing(person):
print "Happy Birthday to you!"
happy()
happy()
print "Happy birthday, dear", person + "."
happy()
person: "Fred"
Figure 6.2: Snaphot of completed call to happy.
Execution continues in this manner with Python making two more side trips back to happy to complete
the execution of sing. When Python get to the end of sing, control then returns to main and continues
immediately after the function call. Figure 6.3 shows where we are at that point. Notice that the personCHAPTER 6. DEFINING FUNCTIONS
92
def
def main():
person = "Fred"
sing("Fred")
print
sing("Lucy")
sing(person):
happy()
happy()
print "Happy birthday, dear", person + "."
happy()
Figure 6.3: Snaphot of completed call to sing.
variable in sing has disappeared. The memory occupied by local function variables is reclaimed when the
function finishes. Local variables do not retain any values from one function execution to the next.
The next statement to execute is the bare print statement in main. This produces a blank line in the
output. Then Python encounters another call to sing. As before, control transfers to the function definition.
This time the formal parameter is "Lucy". Figure 6.4 shows the situation as sing begins to execute for the
second time.
def
def main():
ucy"
L
"
sing("Fred")
on =
pers
print
sing("Lucy")
sing(person):
happy()
happy()
print "Happy birthday, dear", person + "."
happy()
person: "Lucy"
Figure 6.4: Snaphot of second call to sing.
Now we'll fast forward to the end. The function body of sing is executed for Lucy (with three side trips
through happy) and control returns to main just after the point of the function call. Now we have reached
the bottom of our code fragment, as illustrated by Figure 6.5. These three statements in main have caused
sing to execute twice and happy to execute six times. Overall, nine total lines of output were generated.
def
def main():
y"
"Luc
sing("Fred")
=
on
print
pers
sing("Lucy")
sing(person):
happy()
happy()
print "Happy birthday, dear", person + "."
happy()
Figure 6.5: Completion of second call to sing.
Hopefully you're getting the hang of how function calls actually work. One point that this example did
not address is the use of multiple parameters. When a function definition has several parameters, the actual
parameters are matched up with the formal parameters by position. The first actual parameter is assigned to
the first formal paramter, the second actual is assigned to the second formal, etc.
As an example, look again at the use of the drawBar function from the future value program. Here is
the call to draw the initial bar.
drawBar(win, 0, principal)
When Python transfers control to drawBar, these parameters are matched up to the formal parameters in
the function heading.
def drawBar(window, year, height):6.5. FUNCTIONS THAT RETURN VALUES
93
The net effect is as if the function body had been prefaced with three assignment statements.
window = win
year = 0
height = principal
You must always be careful when calling a function that you get the actual parameters in the correct order to
match the function definition.
6.5 Functions that Return Values
You have seen that parameter passing provides a mechanism for initializing the variables in a function. In a
way, parameters act as inputs to a function. We can call a function many times and get different results by
changing the input parameters.
Sometimes we also want to get information back out of a function. This is accomplished by having
functions return a value to the caller. You have already seen numerous examples of this type of function. For
example, consider this call to the sqrt function from the math library.
discRt = math.sqrt(b*b - 4*a*c)
Here the value of b*b - 4*a*c is the actual parameter of math.sqrt. This function call occurs on
the right side of an assignment statement; that means it is an expression. The math.sqrt function must
somehow produce a value that is then assigned to the variable discRt. Technically, we say that sqrt
returns the square root of its argument.
It's very easy to write functions that return values. Here's an example value-returning function that does
the opposite of sqrt; it returns the square of its argument.
def square(x):
return x * x
The body of this function consists of a single return statement. When Python encounters return, it exits
the function and returns control to the point where the function was called. In addition, the value(s) provided
in the return statement are sent back to the caller as an expression result.
We can use our square function any place that an expression would be legal. Here are some interactive
examples.
>>>
9
>>>
16
>>>
>>>
>>>
25
>>>
34
square(3)
print square(4)
x = 5
y = square(x)
print y
print square(x) + square(3)
Let's use the square function to write another function that finds the distance between two points. Given
two points x 1 #,% y 1 and x 2 ,&- y 2 , the distance between them is calculated from the Pythagorean Theorem as
x 2 x 1 2
y 2 y 1 2 . Here is a Python function to compute the distance between two Point objects.
def distance(p1, p2):
dist = math.sqrt(square(p2.getX() - p1.getX())
+ square(p2.getY() - p1.getY())
return dist
Using the distance function, we can augment the interactive triangle program from last chapter to
calculate the perimeter of the triangle. Here's the complete program:CHAPTER 6. DEFINING FUNCTIONS
94
# Program: triangle2.py
from graphics import *
def square(x):
return x * x
def distance(p1, p2):
dist = math.sqrt(square(p2.getX() - p1.getX())
+ square(p2.getY() - p1.getY())
return dist
def main():
win = GraphWin("Draw a Triangle")
win.setCoords(0.0, 0.0, 10.0, 10.0)
message = Text(Point(5, 0.5), "Click on three points")
message.draw(win)
# Get and draw three vertices of triangle
p1 = win.getMouse()
p1.draw(win)
p2 = win.getMouse()
p2.draw(win)
p3 = win.getMouse()
p3.draw(win)
# Use Polygon object to draw the triangle
triangle = Polygon(p1,p2,p3)
triangle.setFill("peachpuff")
triangle.setOutline("cyan")
triangle.draw(win)
# Calculate the perimeter of the triangle
perim = distance(p1,p2) + distance(p2,p3) + distance(p3,p1)
message.setText("The perimeter is: %0.2f" % perim)
# Wait for another click to exit
win.getMouse()
You can see how distance is called three times in one line to compute the perimeter of the triangle. Using
a function here saves quite a bit of tedious coding.
Sometimes a function needs to return more than one value. This can be done by simply listing more than
one expression in the return statement. As a silly example, here is a function that computes both the sum
and the difference of two numbers.
def sumDiff(x,y):
sum = x + y
diff = x - y
return sum, diff
As you can see, this return hands back two values. When calling this function, we would place it in a
simultaneous assignment.
num1, num2 = input("Please enter two numbers (num1, num2) ")
s, d = sumDiff(num1, num2)
print "The sum is", s, "and the difference is", d6.6. FUNCTIONS AND PROGRAM STRUCTURE
95
As with parameters, when multiple values are returned from a function, they are assigned to variables by
position. In this example, s will get the first value listed in the return (sum), and d will get the second
value (diff).
That's just about all there is to know about functions in Python. There is one #.'gotcha'/$ to warn you about.
Technically, all functions in Python return a value, regardless of whether or not the function actually contains
a return statement. Functions without a return always hand back a special object, denoted None.
This object is often used as a sort of default value for variables that don't currently hold anything useful. A
common mistake that new (and not-so-new) programmers make is writing what should be a value-returning
function but forgetting to include a return statement at the end.
Suppose we forget to include the return statement at the end of the distance function.
def distance(p1, p2):
dist = math.sqrt(square(p2.getX() - p1.getX())
+ square(p2.getY() - p1.getY())
Running the revised triangle program with this version of distance generates this Python error message.
Traceback (innermost last):
File "<stdin>", line 1, in ?
File "triangle2err.py", line 44, in ?
main()
File "triangle2err.py", line 37, in main
perim = distance(p1,p2) + distance(p2,p3) + distance(p3,p1)
TypeError: bad operand type(s) for +
The problem here is that this version of distance does not return a number, but always hands back the
value None. Addition is not defined for None, and so Python complains. If your value-returning functions
are producing strange error messages, check to make sure you remembered to include the return.
6.6 Functions and Program Structure
So far, we have been discussing functions as a mechanism for reducing code duplication, thus shortening
and simplifying our programs. Surprisingly, functions are often used even when doing so actually makes the
program longer. A second reason for using functions is to make programs more modular.
As the algorithms that you design get more complex, it gets more and more difficult to make sense out
of programs. Humans are pretty good at keeping track of eight to ten things at a time. When presented
with an algorithm that is hundreds of lines long, even the best programmers will throw up their hands in
bewilderment.
One way to deal with this complexity is to break an algorithm into smaller subprograms, each of which
makes sense on its own. I'll have a lot more to say about this later when we discuss program design in
Chapter 9. For now, we'll just take a look at an example. Let's return to the future value problem one more
time. Here is the main program as we left it:
def main():
# Introduction
print "This program plots the growth of a 10-year investment."
# Get principal and interest rate
principal = input("Enter the initial principal: ")
apr = input("Enter the annualized interest rate: ")
# Create a graphics window with labels on left edge
win = GraphWin("Investment Growth Chart", 320, 240)
win.setBackground("white")
win.setCoords(-1.75,-200, 11.5, 10400)CHAPTER 6. DEFINING FUNCTIONS
96
Text(Point(-1,
Text(Point(-1,
Text(Point(-1,
Text(Point(-1,
Text(Point(-1,
0), -/" 0.0K!%").draw(win)
2500), )*) 2.5K$!)).draw(win)
5000), &-* 5.0K+#!).draw(win)
7500), )&- 7.5k-"#).draw(win)
10000), #+!10.0K!*().draw(win)
# Draw bar for initial principal
drawBar(win, 0, principal)
# Draw a bar for each subsequent year
for year in range(1, 11):
principal = principal * (1 + apr)
drawBar(win, year, principal)
raw_input("Press <Enter> to quit.")
Although we have already shortened this algorithm through the use of the drawBar function, it is still
long enough to make reading through it awkward. The comments help to explain things, but, not to put too
fine a point on it, this function is just too long. One way to make the program more readable is to move some
of the details into a separate function. For example, there are eight lines in the middle that simply create the
window where the chart will be drawn. We could put these steps into a value returning function.
def createLabeledWindow():
# Returns a GraphWin with title and labels drawn
window = GraphWin("Investment Growth Chart", 320, 240)
window.setBackground("white")
window.setCoords(-1.75,-200, 11.5, 10400)
Text(Point(-1, 0), $'' 0.0K&.+).draw(window)
Text(Point(-1, 2500), '., 2.5K'#-).draw(window)
Text(Point(-1, 5000), //" 5.0K""%).draw(window)
Text(Point(-1, 7500), )+" 7.5k&/*).draw(window)
Text(Point(-1, 10000), !)&10.0K(*/).draw(window)
return window
As its name implies, this function takes care of all the nitty-gritty details of drawing the initial window. It is
a self-contained entity that performs this one well-defined task.
Using our new function, the main algorithm seems much simpler.
def main():
print "This program plots the growth of a 10-year investment."
principal = input("Enter the initial principal: ")
apr = input("Enter the annualized interest rate: ")
win = createLabeledWindow()
drawBar(win, 0, principal)
for year in range(1, 11):
principal = principal * (1 + apr)
drawBar(win, year, principal)
raw_input("Press <Enter> to quit.")
Notice that I have removed the comments; the intent of the algorithm is now clear. With suitably named
functions, the code has become nearly self-documenting.
Here is the final version of our future value program:6.7. EXERCISES
97
# futval_graph4.py
from graphics import *
def createLabeledWindow():
window = GraphWin("Investment Growth Chart", 320, 240)
window.setBackground("white")
window.setCoords(-1.75,-200, 11.5, 10400)
Text(Point(-1, 0), /-- 0.0K'*$).draw(window)
Text(Point(-1, 2500), """ 2.5K.($).draw(window)
Text(Point(-1, 5000), #/+ 5.0K$($).draw(window)
Text(Point(-1, 7500), /!. 7.5k!.&).draw(window)
Text(Point(-1, 10000), +..10.0K!-().draw(window)
return window
def drawBar(window, year, height):
bar = Rectangle(Point(year, 0), Point(year+1, height))
bar.setFill("green")
bar.setWidth(2)
bar.draw(window)
def main():
print "This program plots the growth of a 10 year investment."
principal = input("Enter the initial principal: ")
apr = input("Enter the annualized interest rate: ")
win = createLabeledWindow()
drawBar(win, 0, principal)
for year in range(1, 11):
principal = principal * (1 + apr)
drawBar(win, year, principal)
raw_input("Press <Enter> to quit.")
win.close()
Although this version is longer than the previous version, experienced programmers would find it much easier
to understand. As you get used to reading and writing functions, you too will learn to appreciate the elegance
of more modular code.
6.7 Exercises
1. In your own words, describe the two motivations for defining functions in your programs.
2. We have been thinking about computer programs as sequences of instructions where the computer
methodically executes one instruction and then moves on to the next one. Do programs that contain
functions fit this model? Explain your answer.
3. Parameters are an important concept in defining functions.
(a) What is the purpose of parameters?
(b) What is the difference between a formal parameter and an actual parameter?
(c) In what ways are parameters similar to and different from ordinary variables?CHAPTER 6. DEFINING FUNCTIONS
98
4. Functions can be thought of as miniature (sub)programs inside of other programs. Like any other
program, we can think of functions as having input and output to communicate with the main program.
(a) How does a program provide '--input$$' to one of its functions?
(b) How does a function provide ',(output)"( to the program?
5. Consider this very simple function:
def cube(x):
answer = x * x * x
return answer
(a) What does this function do?
(b) Show how a program could use this function to print the value of y 3 , assuming y is a variable.
(c) Here is a fragment of a program that uses this function:
answer = 4
result = cube(3)
print answer, result
The output from this fragment is 4 27. Explain why the output is not 27 27, even though cube
seems to change the value of answer to 27.
6. Write a program to print the lyrics of the song $+.Old MacDonald.&/- Your program should print the lyrics
for five different animals, similar to the example verse below.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
And on that farm he had a cow, Ee-igh, Ee-igh, Oh!
With a moo, moo here and a moo, moo there.
Here a moo, there a moo, everywhere a moo, moo.
Old MacDonald had a farm, Ee-igh, Ee-igh, Oh!
7. Write a program to print the lyrics for ten verses of *&-The Ants Go Marching./'# A couple sample verses
are given below. You may choose your own activity for the little one in each verse, but be sure to
choose something that makes the rhyme work (or almost work).
The ants go marching one by one, hurrah! hurrah!
The ants go marching one by one, hurrah! hurrah!
The ants go marching one by one.
The little one stops to suck his thumb
And they all go marching down...
In the gound...
To get out....
Of the rain.
Boom! Boom! Boom!
The ants go marching two by two, hurrah! hurrah!
The ants go marching two by two, hurrah! hurrah!
The ants go marching two by two.
The little one stops to tie his shoe
And they all go marching down...
In the ground...
To get out...
Of the rain.
Boom! Boom! Boom!6.7. EXERCISES
99
8. Redo any of your favorite programming problems from previous chapters and use a function or two
to encapsulate the calculations. For example, a program to compute the volume and surface area of a
sphere could use functions sphereVol and sphereArea to do the calculations.
9. Redo some more problems....100
CHAPTER 6. DEFINING FUNCTIONSChapter 7
Control Structures, Part 1
So far, we have viewed computer programs as sequences of instructions that are followed one after the
other. Sequencing is a fundamental concept of programming, but alone, it is not sufficient to solve every
problem. Often it is necessary to alter the sequential flow of a program to suit the needs of a particular
situation. This is done with special statements known as control structures. In this chapter, we'll take a
look at decision structures, which are statements that allow a program to execute different sequences of
instructions for different cases, effectively allowing the program to %"(choose$)& an appropriate course of action.
7.1 Simple Decisions
7.1.1 Example: Temperature Warnings
Let's start by getting the computer to make a simple decision. For an easy example, we'll return to the
Celsius to Fahrenheit temperature conversion program from Chapter 2. Remember, this was written by Suzie
Programmer to help her figure out how to dress each morning in Europe. Here is the program as we left it:
# convert.py
#
A program to convert Celsius temps to Fahrenheit
# by: Suzie Programmer
def main():
celsius = input("What is the Celsius temperature? ")
fahrenheit = 9.0 / 5.0 * celsius + 32
print "The temperature is", fahrenheit, "degrees fahrenheit."
main()
This is a fine program as far as it goes, but we want to enhance it. Suzie Programmer is not a morning
person, and even though she has a program to convert the temperatures, sometimes she does not pay very
close attention to the results. Our enhancement to the program will ensure that when the temperatures are
extreme, the program prints out a suitable warning so that Suzie takes notice.
The first step is to fully specify the enhancement. An extreme temperature is either quite hot or quite cold.
Let's say that any temperature over 90 degrees Fahrenheit deserves a heat warning, and a temperature under
30 degrees warrants a cold warning. With this specification in mind, we can design an enhanced algorithm.
Input the temperature in degrees Celsius (call it celsius)
Calculate fahrenheit as 9/5 celsius + 32
Output fahrenheit
if fahrenheit > 90
print a heat warning
if fahrenheit < 30
print a cold warning
101CHAPTER 7. CONTROL STRUCTURES, PART 1
102
This new design has two simple decisions at the end. The indentation indicates that a step should be
performed only if the condition listed in the previous line is met. The idea here is that the decision introduces
an alternative flow of control through the program. The exact set of steps taken by the algorithm will depend
on the value of fahrenheit.
Figure 7.1 is a flowchart showing the possible paths that can be taken through the algorithm. The diamond
boxes show conditional decisions. If the condition is false, control passes to the next statement in the sequence
(the one below). If the condition holds, however, control transfers to the instructions in the box to the right.
Once these instructions are done, control then passes to the next statement.
Input Celsius Temperature
Farenheit = 9/5 * celsius + 32
Print Fahrenheit
fahrenheit > 90?
no
fahrenheit < 30?
no
yes
Print a Heat Warning
yes
Print a Cold Warning
Figure 7.1: Flowchart of temperature conversion program with warnings.
Here is how the new design translates into Python code:
# convert2.py
#
A program to convert Celsius temps to Fahrenheit.
#
This version issues heat and cold warnings.
def main():
celsius = input("What is the Celsius temperature? ")
fahrenheit = 9.0 / 5.0 * celsius + 32
print "The temperature is", fahrenheit, "degrees fahrenheit."
# Print warnings for extreme temps
if fahrenheit > 90:
print "It's really hot out there, be careful!"
if fahrenheit < 30:
print "Brrrrr. Be sure to dress warmly!"
main()
You can see that the Python if statement is used to implement the decision.
The form of the if is very similar to the pseudo-code in the algorithm.
if <condition>:
<body>7.1. SIMPLE DECISIONS
103
The body is just a sequence of one or more statements indented under the if heading. In convert2.py
there are two if statements, both of which have a single statement in the body.
The semantics of the if should be clear from the example above. First, the condition in the heading
is evaluated. If the condition is true, the sequence of statements in the body is executed, and then control
passes to the next statement in the program. If the condition is false, the statements in the body are skipped.
Figure 7.2 shows the semantics of the if as a flowchart. Notice that the body of the if either executes or
<condition> true?
yes
no
<Body>
Figure 7.2: Control flow of simple if-statement
not depending on the condition. In either case, control then passes to the next statement after the if. This is
a one-way or simple decision.
7.1.2 Forming Simple Conditions
One point that has not yet been discussed is exactly what a condition looks like. For the time being, our
programs will use simple conditions that compare the values of two expressions.
<expr> <relop> <expr>
<relop> is short for relational operator. That's just a fancy name for the mathematical concepts like #/#less
than/*- or '))equal to.&"# There are six relational operators in Python, shown in the following table.
Python
Mathematics
!
Meaning
Less than
Less than or equal to
Equal to
Greater than or equal to
Greater than
Not equal to
Notice especially the use of
for equality. Since Python uses the sign to indicate an assignment state-
ment, a different symbol is required for the concept of equality. A common mistake in Python programs is
using in conditions, where a
is required.
Conditions may compare either numbers or strings. When comparing strings, the ordering is lexico-
graphic. Basically, this means that strings are put in alphabetic order according to the underlying ASCII
codes. So all upper-case letters come before lower case letters (e.g., %,-Bbbb##$ comes before ',*aaaa%+!, since .()B'#)
precedes $%/a-,)).
I should mention that conditions are actually a type of expression, called a Boolean expression, after
George Boole, a 19th century English mathematician. When a Boolean expression is evaluated, it produces
a value of either true (the condition holds) or false (it does not hold). In Python, conditions return int values.
A true condition produces a 1, while a false condition produces a 0. Here are a few examples:CHAPTER 7. CONTROL STRUCTURES, PART 1
104
>>>
1
>>>
0
>>>
1
>>>
0
>>>
1
3 < 4
3 * 4 < 3 + 4
"hello" == "hello"
"hello" < "hello"
"Hello" < "hello"
7.1.3 Example: Conditional Program Execution
Back in Chapter 1, I mentioned that there are several different ways of running Python programs. Some
Python module files are designed to be run directly. These are usually referred to as **"programs*'* or ,,'scripts.*&!
Other Python modules are designed primarily to be imported and used by other programs, these are often
called --,libraries.'). Sometimes we want to create a sort of hybrid module that can be used both as a stand-
alone program and as a library that can be imported by other programs.
So far, all of our programs have had a line at the bottom to invoke the main function.
main()
As you know, this is what actually starts a program running. These programs are suitable for running directly.
In a windowing environment, you might run a file by (double-)clicking its icon. Or you might type a command
like python <myfile>.py.
Since Python evaluates the lines of a module during the import process, our current programs also run
when they are imported into either an interactive Python session or into another Python program. Generally,
it is nicer not to have modules run as they are imported. When testing a program interactively, the usual
approach is to first import the module and then call its main (or some other function) each time we want to
run it.
In a program that can be either imported (without running) or run directly, the call to main at the bottom
must be made conditional. A simple decision should do the trick.
if <condition>:
main()
We just need to figure out a suitable condition.
Whenever a module is imported, Python sets a special variable in the module called name to be the
name of the imported module. Here is an example interaction showing what happens with the math library.
>>> import math
>>> math.__name__
''-math'%/
You can see that, when imported, the name variable inside the math module is assigned the string
//,math.,/.
However, when Python code is being run directly (not imported), Python sets the value of name to be
/&) main (!/. To see this in action, you just need to start Python and look at the value.
>>> __name__
#,#__main__)-)
So, if a module is imported, the code in that module will see a variable called name whose value is the
name of the module. When a file is run directly, the code will see that name has the value )+- main ,"&.
A program can determine how it is being used by inspecting this variable.
Putting the pieces together, we can change the final lines of our programs to look like this:7.2. TWO-WAY DECISIONS
105
if __name__ == "!$__main__/.):
main()
This guarantees that main will automatically run when the program is invoked directly, but it will not run
if the module is imported. You will see a line of code similar to this at the bottom of virtually every Python
program.
7.2 Two-Way Decisions
Now that we have a way to selectively execute certain statements in a program using decisions, it's time to
go back and spruce up the quadratic equation solver from Chapter 3. Here is the program as we left it:
# quadratic.py
#
A program that computes the real roots of a quadratic equation.
#
Illustrates use of the math library.
#
Note: this program crashes if the equation has no real roots.
import math
# Makes the math library available.
def main():
print "This program finds the real solutions to a quadratic"
print
a, b, c = input("Please enter the coefficients (a, b, c): ")
discRoot = math.sqrt(b * b - 4 * a * c)
root1 = (-b + discRoot) / (2 * a)
root2 = (-b - discRoot) / (2 * a)
print
print "The solutions are:", root1, root2
main()
As noted in the comments, this program crashes when it is given coefficients of a quadratic equation that
has no real roots. The problem with this code is that when b 2 4ac is less than 0, the program attempts to
take the square root of a negative number. Since negative numbers do not have real roots, the math library
reports an error. Here's an example.
>>> import quadratic
This program finds the real solutions to a quadratic
Please enter the coefficients (a, b, c): 1,2,3
Traceback (innermost last):
File "<stdin>", line 1, in ?
File "quadratic.py", line 21, in ?
main()
File "quadratic.py", line 14, in main
discRoot = math.sqrt(b * b - 4 * a * c)
OverflowError: math range error
We can use a decision to check for this situation and make sure that the program can't crash. Here's a
first attempt:
# quadratic2.py
import mathCHAPTER 7. CONTROL STRUCTURES, PART 1
106
def main():
print "This program finds the real solutions to a quadratic\n"
a, b, c = input("Please enter the coefficients (a, b, c): ")
dicrim = b * b - 4 * a * c
if discrim >= 0:
discRoot = math.sqrt(discrim)
root1 = (-b + discRoot) / (2 * a)
root2 = (-b - discRoot) / (2 * a)
print "\nThe solutions are:", root1, root2
This version first computes the value of the discriminant (b 2 4ac) and then checks to make sure it is not
negative. Only then does the program proceed to take the square root and calculate the solutions. This
program will never attempt to call math.sqrt when discrim is negative.
Incidently, you might also notice that I have replaced the bare print statements from the original version
of the program with embedded newlines to put whitespace in the output; you hadn't yet learned about n the
first time we encountered this program.
Unfortunately, this updated version is not really a complete solution. Study the program for a moment.
What happens when the equation has no real roots? According to the semantics for a simple if, when b*b
- 4*a*c is less than zero, the program will simply skip the calculations and go to the next statement. Since
there is no next statement, the program just quits. Here's what happens in an interactive session.
>>> quadratic2.main()
This program finds the real solutions to a quadratic
Please enter the coefficients (a, b, c): 1,2,3
>>>
This is almost worse than the previous version, because it does not give the user any indication of what
went wrong; it just leaves them hanging. A better program would print a message telling the user that their
particular equation has no real solutions. We could accomplish this by adding another simple decision at the
end of the program.
if discrim < 0:
print "The equation has no real roots!"
This will certainly solve our problem, but this solution just doesn't feel right. We have programmed a
sequence of two decisions, but the two outcomes are mutually exclusive. If discrim >= 0 is true then
discrim < 0 must be false and vice versa. We have two conditions in the program, but there is really only
one decision to make. Based on the value of discrim The program should either print that there are no
real roots or it should calculate and display the roots. This is an example of a two-way decision. Figure 7.3
illustrates the situation.
In Python, a two-way decision can be implemented by attaching an else clause onto an if. The result
is called an if-else statement.
if <condition>:
<statements>
else:
<statements>
When the Python interpreter encounters this structure, it will first evaluate the condition. If the condition is
true, the statements under the if are executed. If the condition is false, the statements under the else are
executed. In either case, control then passes to the statement following the if-else.
Using a two-way decision in the quadratic solver yields a more elegant solution.7.3. MULTI-WAY DECISIONS
107
no
discrim < 0 ?
yes
Calculate roots
Print "no roots"
Figure 7.3: Quadratic solver as a two-way decision.
# quadratic3.py
import math
def main():
print "This program finds the real solutions to a quadratic\n"
a, b, c = input("Please enter the coefficients (a, b, c): ")
discrim = b * b - 4 * a * c
if discrim < 0:
print "\nThe equation has no real roots!"
else:
discRoot = math.sqrt(b * b - 4 * a * c)
root1 = (-b + discRoot) / (2 * a)
root2 = (-b - discRoot) / (2 * a)
print
print "\nThe solutions are:", root1, root2
This program fits the bill nicely. Here is a sample session that runs the new program twice.
>>> quadratic3.main()
This program finds the real solutions to a quadratic
Please enter the coefficients (a, b, c): 1,2,3
The equation has no real roots!
>>> quadratic3.main()
This program finds the real solutions to a quadratic
Please enter the coefficients (a, b, c): 2,4,1
The solutions are: -0.292893218813 -1.70710678119
7.3 Multi-Way Decisions
The newest version of the quadratic solver is certainly a big improvement, but it still has some quirks. Here
is another example run.CHAPTER 7. CONTROL STRUCTURES, PART 1
108
>>> quadratic3.main()
This program finds the real solutions to a quadratic
Please enter the coefficients (a, b, c): 1, 2, 1
The solutions are: -1.0 -1.0
This is technically correct; the given coefficients produce an equation that has a double root at -1. However,
the output might be confusing to some users. It looks like the program has mistakenly printed the same
number twice. Perhaps the program should be a bit more informative to avoid confusion.
The double-root situation occurs when discrim is exactly 0. In this case, discRoot is also 0, and
both roots have the value 2a b . If we want to catch this special case, it looks like our program actually needs a
three-way decision. Here's a quick sketch of the design.
...
Check the value of discrim
when < 0: handle the case of no roots
when = 0: handle the case of a double root
when > 0: handle the case of two distinct roots.
One way to code this algorithm is to use two if-else statements. The body of an if or else clause
can contain any legal Python statements, including other if or if-else statements. Putting one compound
statement inside of another is called nesting. Here's a fragment of code that uses nesting to achieve a
three-way decision :
if discrim < 0:
print "Equation has no real roots"
else:
if discrim == 0:
root = -b / (2 * a)
print "There is a double root at", root
else:
# Do stuff for two roots
If you trace through this code carefully, you will see that there are exactly three possible paths. The
sequencing is determined by the value of discrim. A flowchart of this solution is shown in Figure 7.4. You
can see that the top-level structure is just an if-else. (Treat the dashed box as one big statement.) The
dashed box contains the second if-else nested comfortably inside the else part of the top-level decision.
Once again, we have a working solution, but the implementation doesn't feel quite right. We have finessed
a three-way decision by using two two-way decisions. The resulting code does not reflect the true three-fold
decision of the original problem. Imagine if we needed to make a five-way decision using this technique. The
if-else structures would nest four levels deep, and the Python code would march off the right-hand edge
of the page.
There is another way to write multi-way decisions in Python that preserves the semantics of the nested
structures but gives it a more appealing look. The idea is to combine an else followed immediately by an
if into a single clause called an elif.
if <condition1>:
<case1 statements>
elif <condition2>:
<case2 statements>
elif <condition3>:
<case3 statements>
...
else:
<default statements>7.4. EXCEPTION HANDLING
yes
109
discrim < 0 ?
no
Print "no roots"
yes
discrim == 0 ?
Do Double Root
no
Do Unique Roots
Figure 7.4: Three-way decision for quadratic solver using nested if-else.
This form is used to set off any number of mutually exclusive code blocks. Python will evaluate each condi-
tion in turn looking for the first one that is true. If a true condition is found, the statements indented under
that condition are executed, and control passes to the next statement after the entire if-elif-else. If
none of the conditions are true, the statements under the else are performed. The else clause is optional;
if omitted, it is possible that no indented statement block will be executed.
Using an if-elif-else to show the three-way decision in our quadratic solver yields a nicely finished
program.
# quadratic4.py
import math
def main():
print "This program finds the real solutions to a quadratic\n"
a, b, c = input("Please enter the coefficients (a, b, c): ")
discrim = b * b - 4 * a * c
if discrim < 0:
print "\nThe equation has no real roots!"
elif discrim == 0:
root = -b / (2 * a)
print "\nThere is a double root at", root
else:
discRoot = math.sqrt(b * b - 4 * a * c)
root1 = (-b + discRoot) / (2 * a)
root2 = (-b - discRoot) / (2 * a)
print "\nThe solutions are:", root1, root2
7.4 Exception Handling
Our quadratic program uses decision structures to avoid taking the square root of a negative number and
generating a run-time error. This is a common pattern in many programs: using decisions to protect againstCHAPTER 7. CONTROL STRUCTURES, PART 1
110
rare but possible errors.
In the case of the quadratic solver, we checked the data before the call to the sqrt function. Sometimes
functions themselves check for possible errors and return a special value to indicate that the operation was
unsuccessful. For example, a different square root operation might return a negative number (say -1) to
indicate an error. Since the square roots of real numbers are never negative, this value could be used to signal
that an error had occurred. The program would check the result of the operation with a decision.
discRt = otherSqrt(b*b - 4*a*c)
if discRt < 0:
print "No real roots."
else:
...
Sometimes programs become so peppered with decisions to check for special cases that the main algo-
rithm for handling the run-of-the-mill cases seems completely lost. Programming language designers have
come up with mechanisms for exception handling that help to solve this design problem. The idea of an
exception handling mechanism is that the programmer can write code that catches and deals with errors that
arise when the program is running. Rather than explicitly checking that each step in the algorithm was suc-
cessful, a program with exception handling can in essence say &./Do these steps, and if any problem crops up,
handle it this way.)$,
We're not going to discuss all the details of the Python exception handling mechanism here, but I do want
to give you a concrete example so you can see how exception handling works and understand programs that
use it. In Python, exception handling is done with a special control structure that is similar to a decision.
Let's start with a specific example and then take a look at the general approach.
Here is a version of the quadratic program that uses Python's exception mechanism to catch potential
errors in the math.sqrt function.
# quadratic5.py
import math
def main():
print "This program finds the real solutions to a quadratic\n"
try:
a, b, c = input("Please enter the coefficients (a, b, c): ")
discRoot = math.sqrt(b * b - 4 * a * c)
root1 = (-b + discRoot) / (2 * a)
root2 = (-b - discRoot) / (2 * a)
print "\nThe solutions are:", root1, root2
except OverflowError:
print "\nNo real roots"
Notice that this is basically the very first version of the quadratic program with the addition of a try...except
around the heart of the program. A try statement has the general form:
try:
<body>
except <ErrorType>:
<handler>
When Python encounters a try statement, it attempts to execute the statements inside the body. If these
statements execute without error, control then passes to the next statement after the try...except. If an
error occurs somewhere in the body, Python looks for an except clause with a matching error type. If a
suitable except is found, the handler code is executed.
The original program without the exception-handling produced the following error.7.4. EXCEPTION HANDLING
111
Traceback (innermost last):
File "<stdin>", line 1, in ?
File "quadratic.py", line 13, in ?
discRoot = math.sqrt(b * b - 4 * a * c)
OverflowError: math range error
The last line of this error message indicates the type of error that was generated, namely an OverflowError.
The updated version of the program provides an except clause to catch the OverflowError.
Here is the error handling version in action:
This program finds the real solutions to a quadratic
Please enter the coefficients (a, b, c): 1,2,3
No real roots
Instead of crashing, the exception handler catches the error and prints a message indicating that the equation
does not have real roots.
The nice thing about the try...except statement is that it can be used to catch any kind of error, even
ones that might be difficult to test for, and hopefully, provide a graceful exit. For example, in the quadratic
solver, there are lots of other things that could go wrong besides having a bad set of coefficients. If the user
fails to type the correct number of inputs, the program generates a ValueError. If the user accidently
types an identifier instead of a number, the program generates a NameError. If the user types in a valid
Python expression that produces non-numeric results, the program generates a TypeError. A single try
statement can have multiple except clauses to catch various possible classes of errors.
Here's one last version of the program designed to robustly handle any possible errors in the input.
# quadratic6.py
import math
def main():
print "This program finds the real solutions to a quadratic\n"
try:
a, b, c = input("Please enter the coefficients (a, b, c): ")
discRoot = math.sqrt(b * b - 4 * a * c)
root1 = (-b + discRoot) / (2 * a)
root2 = (-b - discRoot) / (2 * a)
print "\nThe solutions are:", root1, root2
except OverflowError:
print "\nNo real roots"
except ValueError:
print "\nYou didn't give me three coefficients."
except NameError:
print "\nYou didn't enter three numbers"
except TypeError:
print "\nYour inputs were not all numbers"
except:
print "\nSomething went wrong, sorry!"
The multiple excepts are similar to elifs. If an error occurs, Python will try each except in turn
looking for one that matches the type of error. The bare except at the bottom acts like an else and will
be used if none of the others match. If there is no default at the bottom and none of the except types match
the error, then the program crashes and Python reports the error.
You can see how the try...except statement allows us to write really bullet-proof programs. Whether
you need to go to this much trouble depends on the type of program that you are writing. In your beginningCHAPTER 7. CONTROL STRUCTURES, PART 1
112
programs, you might not worry too much about bad input; however, professional quality software should do
whatever is feasible to shield users from unexpected results.
7.5 Study in Design: Max of Three
Now that we have decisions that can alter the control flow of a program, our algorithms are liberated from
the monotony of step-by-step, strictly sequential processing. This is both a blessing and a curse. The positive
side is that we can now develop more sophisticated algorithms, as we did for our quadratic solver. The
negative side is that designing these more sophisticated algorithms is much harder. In this section, we'll step
through the design of a more difficult decision problem to illustrate some of the challenge and excitement of
the design process.
Suppose we need an algorithm to find the largest of three numbers. This algorithm could be part of a
larger problem such as determining grades or computing taxes, but we are not interested in the final details,
just the crux of the problem. That is, how can a computer determine which of three user inputs is the largest?
Here is a program outline. We need to fill in the missing part.
def main():
x1, x2, x3 = input("Please enter three values: ")
# missing code sets max to the value of the largest
print "The largest value is", max
Before reading the following analysis, you might want to try your hand at solving this problem.
7.5.1 Strategy 1: Compare Each to All
Obviously, this program presents us with a decision problem. We need a sequence of statements that sets the
value of max to the largest of the three inputs x1, x2, and x3. At first glance, this looks like a three-way
decision; we need to execute one of the following assignments.
max = x1
max = x2
max = x3
It would seem we just need to preface each one with the appropriate condition(s), so that it is executed only
in the proper situation.
Let's consider the first possibility, that x1 is the largest. To see that x1 is actually the largest, we just
need to check that it is at least as large as the other two. Here is a first attempt:
if x1 >= x2 >= x3:
max = x1
Your first concern here should be whether this statement is syntactically correct. The condition x1
x2
x3 does not match the template for conditions shown above. Most computer languages would not
accept this as a valid expression. It turns out that Python does allow this compound condition, and it behaves
exactly like the mathematical relations x1 x2 x3. That is, the condition is true when x1 is at least as large
as x2 and x2 is at least as large as x3. So, Python has no problem with this condition.
Whenever you write a decision, you should ask yourself two crucial questions. First, when the condition
is true, are you absolutely certain that executing the body of the decision is the right action to take? In this
case, the condition clearly states that x1 is at least as large as x2 and x3, so assigning its value to max should
be correct. Always pay particular attention to borderline values. Notice that our condition includes equal as
well as greater. We should convince ourselves that this is correct. Suppose that x1, x2, and x3 are all the
same; this condition will return true. That's OK because it doesn't matter which we choose, the first is at least
as big as the others, and hence, the max.7.5. STUDY IN DESIGN: MAX OF THREE
113
The second question to ask is the converse of the first. Are we certain that this condition is true in all
cases where x1 is the max? Unfortunately, our condition does not meet this test. Suppose the values are 5,
2, and 4. Clearly, x1 is the largest, but our condition returns false since the relationship 5 2 4 does not
hold. We need to fix this.
We want to ensure that x1 is the largest, but we don't care about the relative ordering of x2 and x3.
What we really need is two separate tests to determine that x1 >= x2 and that x2 >= x3. Python allows
us to test multiple conditions like this by combining them with the keyword and. We'll discuss the exact
semantics of and in Chapter 8. Intuitively, the following condition seems to be what we are looking for:
if x1 >= x2 and x1 >= x3:
max = x1
# x1 is greater than each of the others
To complete the program, we just need to implement analogous tests for the other possibilities.
if x1 >= x2 and x1 >= x3:
max = x1
elif x2 >= x1 and x2 >= x3:
max = x2
else:
max = x3
Summing up this approach, our algorithm is basically checking each possible value against all the others to
determine if it is the largest.
With just three values the result is quite simple. But how would this solution look if we were trying to find
the max of five values? Then we would need four Boolean expressions, each consisting of four conditions
anded together. The complex expressions result from the fact that each decision is designed to stand on its
own; information from one test is ignored in the following. To see what I mean, look back at our simple max
of three code. Suppose the first decision discovers that x1 is greater than x2, but not greater than x3. At
this point, we know that x3 must be the max. Unfortunately, our code ignores this; Python will go ahead and
evaluate the next expression, discover it to be false and finally execute the else.
7.5.2 Strategy 2: Decision Tree
One way to avoid the redundant tests of the previous algorithm is to use a decision tree approach. Suppose
we start with a simple test x1
x2. This knocks either x1 or x2 out of contention to be the max. If
the condition is true, we just need to see which is larger, x1 or x3. Should the initial condition be false,
the result boils down to a choice between x2 and x3. As you can see, the first decision (#)branches(+) into two
possibilities, each of which is another decision. Hence the name, decision tree. Figure 7.5 shows the situation
in a flowchart. This flowchart translates easily into nested if-else statements.
if x1 >= x2:
if x1 >= x3:
max = x1
else:
max = x3
else:
if x2 >= x3:
max = x2
else:
max = x3
The strength of this approach is its efficiency. No matter what the ordering of the three values, this
algorithm will make exactly two comparisons and assign the correct value to max. However, the structure of
this approach is more complicated than the first, and it suffers a similar complexity explosion, should we try
this design with more than three values. As a challenge, you might see if you can design a decision tree to
find the max of four values. (You will need if-elses nested three levels deep leading to eight assignment
statements.)CHAPTER 7. CONTROL STRUCTURES, PART 1
114
yes
no
x1 >= x2
yes
max = x1
x1 >= x3
no
max = x3
yes
max = x2
x2 > =x3
no
max = x3
Figure 7.5: Flowchart of the decision tree approach to max of three
7.5.3 Strategy 3: Sequential Processing
So far, we have designed two very different algorithms, but neither one seems particularly elegant. Perhaps
there is yet a third way. When designing an algorithm, a good starting place is to ask yourself how you would
solve the problem if you were asked to do the job. For finding the max of three numbers, you probably don't
have a very good intuition about the steps you go through. You'd just look at the numbers and know which is
the largest. But what if you were handed a book containing hundreds of numbers in no particular order. How
would you find the largest in this collection?
When confronted with the larger problem, most people develop a simple strategy. Scan through the
numbers until you find a big one, and put your finger on it. Continue scanning; if you find a number bigger
than the one your finger is on, move your finger to the new one. When you get to the end of the list, your
finger will remain on the largest value. In a nutshell, this strategy has us look through the list sequentially,
keeping track of the largest number seen so far.
A computer doesn't have fingers, but we can use a variable to keep track of the max so far. In fact, the
easiest approach is just to use max to do this job. That way, when we get to the end, max automatically
contains the value of the largest. A flowchart depicting this strategy for the max of three problem is shown in
Figure 7.6. Here is the translation into Python code:
max = x1
if x2 > max:
max = x2
if x3 > max:
max = x3
Clearly, the sequential approach is the best of our three algorithms. The code itself is quite simple,
containing only two simple decisions, and the sequencing is easier to understand than the nesting used in the
previous algorithm. Furthermore, the idea scales well to larger problems; adding a fourth item adds only one
more statement.
max = x1
if x2 > max:
max = x2
if x3 > max:
max = x3
if x4 > max:
max = x47.5. STUDY IN DESIGN: MAX OF THREE
115
max = x1
x2 > max
max = x2
x3 > max
max = x3
Figure 7.6: Flowchart of a sequential approach to the max of three problem.
It should not be surprising that the last solution scales to larger problems; we invented the algorithm
by explicitly considering how to solve a more complex problem. In fact, you can see that the code is very
repetitive. We can easily write a program that allows the user to find the largest of n numbers by folding our
algorithm into a loop. Rather than having separate variables for x1, x2, x3, etc., we can just get the values
one at a time and keep reusing a single variable x. Each time, we compare the newest x against the current
value of max to see if it is larger.
# program: maxn.py
#
Finds the maximum of a series of numbers
def main():
n = input("How many numbers are there? ")
# Set max to be the first value
max = input("Enter a number >> ")
# Now compare the n-1 successive values
for i in range(n-1):
x = input("Enter a number >> ")
if x > max:
max = x
print "The largest value is", max
main()
This code uses a decision nested inside of a loop to get the job done. On each iteration of the loop, max
contains the largest value seen so far.CHAPTER 7. CONTROL STRUCTURES, PART 1
116
7.5.4 Strategy 4: Use Python
Before leaving this problem, I really should mention that none of the algorithm development we have so
painstakingly pursued was necessary. Python actually has a built-in function called max that returns the
largest of its parameters. Here is the simplest version of our program.
def main():
x1, x2, x3 = input("Please enter three values: ")
print "The largest value is", max(x1, x2, x3)
Of course, this version didn't require any algorithm development at all, which rather defeats the point of the
exercise! Sometimes Python is just too simple for our own good....
7.5.5 Some Lessons
The max of three problem is not particularly earth shattering, but the attempt to solve this problem has
illustrated some important ideas in algorithm and program design.
There is more than one way to do it. For any non-trivial computing problem, there are many ways to
approach the problem. While this may seem obvious, many beginning programmers do not really take
this point to heart. What does this mean for you? Don't rush to code up the first idea that pops into your
head. Think about your design, ask yourself if there is a better way to approach the problem. Once
you have written the code, ask yourself again if there might be a better way. Your first task is to find
a correct algorithm. After that, strive for clarity, simplicity, efficiency, scalability and elegance. Good
algorithms and programs are like poems of logic. They are a pleasure to read and maintain.
Be the computer. Especially for beginning programmers, one of the best ways to formulate an algorithm
is to simply ask yourself how you would solve the problem. There are other techniques for designing
good algorithms (see Chapter 13); however, the straightforward approach is often simple, clear and
efficient enough.
Generality is good. We arrived at the best solution to the max of three problem by considering the more
general max of n problem. It is not unusual that consideration of a more general problem can lead to
a better solution for some special case. Don't be afraid to step back and think about the overarching
problem. Similarly, when designing programs, you should always have an eye toward making your
program more generally useful. If the max of n program is just as easy to write as max of three, you
may as well write the more general program because it is more likely to be useful in other situations.
That way you get the maximum utility from your programming effort.
Don't reinvent the wheel. Our fourth solution was to use Python's max function. You may think that
was cheating, but this example illustrates an important point. A lot of very smart programmers have
designed countless good algorithms and programs. If the problem you are trying to solve seems to be
one that lots of others must have encountered, you might begin by finding out if the problem has already
been solved for you. As you are learning to program, designing from scratch is great experience. Truly
expert programmers, however, know when to borrow.
7.6 Exercises
1. Explain the following patterns in your own words.
(a) simple decision
(b) two-way decision
(c) multi-way decision
2. The following is a (silly) decision structure.7.6. EXERCISES
117
a, b, c = input(/%-Enter three numbers: "%*)
if a > b:
if b > c:
print "Spam Please!"
else:
print "It's a late parrot!"
elif b > c:
print "Cheese Shoppe"
if a >= c:
print "Cheddar"
elif a < b:
print "Gouda"
elif c == b:
print "Swiss"
else:
print "Trees"
if a == b:
print "Chestnut"
else:
print "Larch"
print "Done"
Show the output that would result from each of the following possible inputs.
(a) 3, 4, 5
(b) 3, 3, 3
(c) 5, 4, 3
(d) 3, 5, 2
(e) 5, 4, 7
(f) 3, 3, 2
3. Many companies pay time-and-a-half for any hours worked above 40 in a given week. Write a program
to input the number of hours worked and the hourly rate and calculate the total wages for the week.
4. A certain CS professor gives 5-point quizzes that are graded on the scale 5-A, 4-B, 3-C, 2-D, 1-F, 0-F.
Write a program that accepts a quiz score as an input and uses a decision structure to calculate the
corresponding grade.
5. A certain CS professor gives 100-point exams that are graded on the scale 90"%,100:A, 80.!&89:B, 70$)&
79:C, 60(/$69:D, 60:F. Write a program that accepts an exam score as input and uses a decision struc-
ture to calculate the corresponding grade.
6. A certain college classifies students according to credits earned. A student with less than 7 credits is a
Freshman. At least 7 credits are required to be a Sophomore, 16 to be a Junior and 26 to be classified
as a Senior. Write a program that calculates class standing from the number of credits earned.
7. The body mass index (BMI) is calculated as a person's weight (in pounds) times 720, divided by the
square of the person's height (in inches). A BMI in the range 19(-)25, inclusive, is considered healthy.
Write a program that calculates a person's BMI and prints a message telling whether they are above,
within or below the healthy range.
8. The speeding ticket fine policy in Podunksville is $50 plus $5 for each mph over the limit plus a penalty
of $200 for any speed over 90 mph. Write a program that accepts a speed limit and a clocked speed
and either prints a message indicating the speed was legal or prints the amount of the fine, if the speed
is illegal.CHAPTER 7. CONTROL STRUCTURES, PART 1
118
9. A babysitter charges $2.50 an hour until 9:00 PM when the rate drops to $1.75 an hour (the children
are in bed). Write a program that accepts a starting time and ending time in hours and minutes and
calculates the total babysitting bill. You may assume that the starting and ending times are in a single
24 hour period. Partial hours should be appropriately prorated.
10. A person is eligible to be a US senator if they are at least 30 years old and have been a US citizen for
at least 9 years. To be a US representative these numbers are 25 and 7, respectively. Write a program
that accepts a person's age and years of citizenship as input and outputs their eligibility for the Senate
and House.
11. A formula for computing Easter in the years 1982'&-2048, inclusive, is as follows: let a year%19,
b year%4, c year%7, d
19a 24 %30, e
2b 4c 6d 5 %7. The date of Easter is March
22 d e (which could be in April). Write a program that inputs a year, verifies that it is in the proper
range and then prints out the date of Easter that year.
12. The formula for Easter in the previous problem works for every year in the range 1900*&'2099 except
for 1954, 1981, 2049 and 2076. For these 4 years it produces a date that is one week too late. Modify
the above program to work for the entire range 1900$-)2099.
13. A year is a leap year if it is divisible by 4, unless it is a century year that is not divisible by 400. (1800
and 1900 are not leap years while 1600 and 2000 are.) Write a program that calculates whether a year
is a leap year.
14. Write a program that accepts a date in the form month/day/year and outputs whether or not the date is
valid. For example 5/24/1962 is valid, but 9/31/2000 is not. (September has only 30 days.)
15. The days of the year are often numbered from 1 to through 365 (or 366). This number can be computed
in three steps using int arithmetic:
(a) dayNum
31 month
1
day
(b) if the month is after February subtract 4month
23 10
(c) if it's a leap year and after February 29, add 1
Write a program that accepts a date as month/day/year, verifies that it is a valid date (see previous
problem) and then calculates the corresponding day number.
16. Take a favorite programming problem from a previous chapter and add decisions and/or exception
handling as required to make it truly robust (will not crash on any inputs).
17. Archery Scorer. Write a program that draws an archery target (see exercises from Chapter 5) and
allows the user to click 5 times to represent arrows shot at the target. Using 5-band scoring, a bulls-eye
(yellow) is worth 9 points and each successive ring is worth 2 fewer points down to 1 for white. The
program should output a score for each click and keep track of a running sum for the entire series.Chapter 8
Control Structures, Part 2
In Chapter 7, we looked in detail at the Python if statement and its use in implementing design patterns such
as one-way, two-way and multi-way decisions. In this chapter, we'll wrap up our tour of control structures
with a detailed look at loops and Boolean expressions.
8.1 For Loops: A Quick Review
You already know that the Python for statement provides a kind of loop. It allows us to iterate through a
sequence of values.
for <var> in <sequence>:
<body>
The loop index variable var takes on each successive value in the sequence, and the statements in the body
of the loop are executed once for each value.
Suppose we want to write a program that can compute the average of a series of numbers entered by the
user. To make the program general, it should work for any size set of numbers. You know that an average
is calculated by summing up the numbers and dividing by the count of how many numbers there are. We
don't need to keep track of all the numbers that have been entered; we just need a running sum so that we can
calculate the average at the end.
This problem description should start some bells ringing in your head. It suggests the use of some design
patterns you have seen before. We are dealing with a series of numbers$$-that will be handled by some form
of loop. If there are n numbers, the loop should execute n times; we can use the counted loop pattern. We
also need a running sum; that calls for a loop accumulator. Putting the two ideas together, we can generate a
design for this problem.
Input the count of the numbers, n
Initialize sum to 0
Loop n times
Input a number, x
Add x to sum
Output average as sum / n
Hopefully, you see both the counted loop and accumulator patterns integrated into this design.
We can translate this design almost directly into a Python implementation.
# average1.py
def main():
n = input("How many numbers do you have? ")
sum = 0.0
for i in range(n):
119CHAPTER 8. CONTROL STRUCTURES, PART 2
120
x = input("Enter a number >> ")
sum = sum + x
print "\nThe average of the numbers is", sum / n
The running sum starts at 0, and each number is added in turn. Notice that sum is initialized to a float 0.0.
This ensures that the division sum / n on the last line returns a float even if all the input values were ints.
Here is the program in action.
How many numbers do you have? 5
Enter a number >> 32
Enter a number >> 45
Enter a number >> 34
Enter a number >> 76
Enter a number >> 45
The average of the numbers is 46.4
Well, that wasn't too bad. Knowing a couple of common patterns, counted loop and accumulator, got
us to a working program with minimal difficulty in design and implementation. Hopefully, you can see the
worth of committing these sorts of programming clich (&es to memory.
8.2 Indefinite Loops
Our averaging program is certainly functional, but it doesn't have the best user interface. It begins by asking
the user how many numbers there are. For a handful of numbers this is OK, but what if I have a whole page
of numbers to average? It might be a significant burden to go through and count them up.
It would be much nicer if the computer could take care of counting the numbers for us. Unfortunately, as
you no doubt recall, the for loop is a definite loop, and that means the number of iterations is determined
when the loop starts. We can't use a definite loop unless we know the number of iterations ahead of time, and
we can't know how many iterations this loop needs until all of the numbers have been entered. We seem to
be stuck.
The solution to this dilemma lies in another kind of loop, the indefinite or conditional loop. An indefinite
loop keeps iterating until certain conditions are met. There is no guarantee ahead of time regarding how many
times the loop will go around.
In Python, an indefinite loop is implemented using a while statement. Syntactically, the while is very
simple.
while <condition>:
<body>
Here condition is a Boolean expression, just like in if statements. The body is, as usual, a sequence of
one or more statements.
The semantics of while is straightforward. The body of the loop executes repeatedly as long as the
condition remains true. When the condition is false, the loop terminates. Figure 8.1 shows a flowchart for the
while. Notice that the condition is always tested at the top of the loop, before the loop body is executed.
This kind of structure is called a pre-test loop. If the loop condition is initially false, the loop body will not
execute at all.
Here is an example of a simple while loop that counts from 0 to 10:
i = 0
while i <= 10:
print i
i = i + 1
This code will have the same output as if we had written a for loop like this:8.3. COMMON LOOP PATTERNS
121
<condition>?
no
yes
<body>
Figure 8.1: Flowchart of a while loop.
for i in range(11):
print i
Notice that the while version requires us to take care of initializing i before the loop and incrementing i at
the bottom of the loop body. In the for loop, the loop variable is handled automatically.
The simplicity of the while statement makes it both powerful and dangerous. Because it is less rigid, it
is more versatile; it can do more than just iterate through sequences. But it is also a common source of errors.
Suppose we forget to increment i at the bottom of the loop body in the counting example.
i = 0
while i <= 10:
print i
What will the output from this program be? When Python gets to the loop, i will be 0, which is less than
10, so the loop body executes, printing a 0. Now control returns to the condition; i is still 0, so the loop
body executes again, printing a 0. Now control returns to the condition; i is still 0, so the loop body executes
again, printing a 0....
You get the picture. This is an example of an infinite loop. Usually, infinite loops are a bad thing. Clearly
this version of the program does nothing useful. That reminds me, did you hear about the computer scientist
who died of exhaustion while washing his hair? The instructions on the bottle said: "*'Lather. Rinse. Repeat.&&-
As a beginning programmer, it would surprising if you did not accidently write a few programs with
infinite loops-+!it's a rite of passage for programmers. Even more experienced programmers have been known
to do this from time to time. Usually, you can break out of a loop by pressing Ctrl   -c (holding down the
Ctrl   key and pressing .(/c-$.). If your loop is really tight, this might not work, and you'll have to resort to
more drastic means (such as Ctrl   - Alt   - Delete   on a PC). If all else fails, there is always the trusty
reset button on your computer. The best idea is to avoid writing infinite loops in the first place.
8.3 Common Loop Patterns
8.3.1 Interactive Loops
One good use of the indefinite loop is to write interactive loops. The idea behind an interactive loop is that
it allows the user to repeat certain portions of a program on demand. Let's take a look at this loop pattern in
the context of our number averaging problem.CHAPTER 8. CONTROL STRUCTURES, PART 2
122
Recall that the previous version of the program forced the user to count up how many numbers there were
to be averaged. We want to modify the program so that it keeps track of how many numbers there are. We
can do this with another accumulator, call it count, that starts at zero and increases by 1 each time through
the loop.
To allow the user to stop at any time, each iteration of the loop will ask whether there is more data to
process. The general pattern for an interactive loop looks like this:
set moredata to "yes"
while moredata is "yes"
get the next data item
process the item
ask user if there is moredata
Combining the interactive loop pattern with accumulators for the sum and count yields this algorithm for
the averaging program.
initialize sum to 0.0
initialize count to 0
set moredata to "yes"
while moredata is "yes"
input a number, x
add x to sum
add 1 to count
ask user if there is moredata
output sum / count
Notice how the two accumulators are interleaved into the basic structure of the interactive loop.
Here is the corresponding Python program:
# average2.py
def main():
sum = 0.0
count = 0
moredata = "yes"
while moredata[0] == "y":
x = input("Enter a number >> ")
sum = sum + x
count = count + 1
moredata = raw_input("Do you have more numbers (yes or no)? ")
print "\nThe average of the numbers is", sum / count
Notice this program uses string indexing (moredata[0]) to look just at the first letter of the user's input.
This allows for varied responses such as ",-yes,(!' %/*y,)(& ---yeah,#.' etc. All that matters is that the first letter is a !,-y.-!/
Also note the use of raw input to get this value. Remember you should use raw input to get string data.
Here is sample output from this program.
Enter a number >> 32
Do you have more numbers
Enter a number >> 45
Do you have more numbers
Enter a number >> 34
Do you have more numbers
Enter a number >> 76
Do you have more numbers
Enter a number >> 45
Do you have more numbers
(yes or no)? yes
(yes or no)? y
(yes or no)? y
(yes or no)? y
(yes or no)? nope8.3. COMMON LOOP PATTERNS
123
The average of the numbers is 46.5
In this version, the user doesn't have to count the data values, but the interface is still not good. The user
will almost certainly be annoyed by the constant prodding for more data. The interactive loop has many good
applications; this is not one of them.
8.3.2 Sentinel Loops
A better solution to the number averaging problem is to employ a pattern commonly known as a sentinel
loop. A sentinel loop continues to process data until reaching a special value that signals the end. The special
value is called the sentinel. Any value may be chosen for the sentinel. The only restriction is that it be
distinguishable from actual data values. The sentinel is not processed as part of the data.
Here is a general pattern for designing sentinel loops:
get the first data item
while item is not the sentinel
process the item
get the next data item
Notice how this pattern avoids processing the sentinel item. The first item is retrieved before the loop starts.
This is sometimes called the priming read, as it gets the process started. If the first item is the sentinel, the
loop immediately terminates and no data is processed. Otherwise, the item is processed and the next one is
read. The loop test at the top ensures this next item is not the sentinel before processing it. When the sentinel
is reached, the loop terminates.
We can apply the sentinel pattern to our number averaging problem. The first step is to pick a sentinel.
Suppose we are using the program to average exam scores. In that case, we can safely assume that no score
will be below 0. The user can enter a negative number to signal the end of the data. Combining the sentinel
loop with the two accumulators from the interactive loop version yields this program.
# average3.py
def main():
sum = 0.0
count = 0
x = input("Enter a number (negative to quit) >> ")
while x >= 0:
sum = sum + x
count = count + 1
x = input("Enter a number (negative to quit) >> ")
print "\nThe average of the numbers is", sum / count
I have changed the prompt so that the user knows how to signal the end of the data. Notice that the prompt is
identical at the priming read and the bottom of the loop body.
Now we have a useful form of the program. Here it is in action:
Enter
Enter
Enter
Enter
Enter
Enter
a
a
a
a
a
a
number
number
number
number
number
number
(negative
(negative
(negative
(negative
(negative
(negative
to
to
to
to
to
to
quit)
quit)
quit)
quit)
quit)
quit)
>>
>>
>>
>>
>>
>>
32
45
34
76
45
-1
The average of the numbers is 46.4
This version provides the ease of use of the interactive loop without the hassle of having to type &.(yes%$+ all the
time. The sentinel loop is a very handy pattern for solving all sorts of data processing problems. It's another
clich +%e that you should commit to memory.CHAPTER 8. CONTROL STRUCTURES, PART 2
124
This sentinel loop solution is quite good, but there is still a limitation. The program can't be used to
average a set of numbers containing negative as well as positive values. Let's see if we can't generalize the
program a bit. What we need is a sentinel value that is distinct from any possible valid number, positive or
negative. Of course, this is impossible as long as we restrict ourselves to working with numbers. No matter
what number or range of numbers we pick as a sentinel, it is always possible that some data set may contain
such a number.
In order to have a truly unique sentinel, we need to broaden the possible inputs. Suppose that we get the
input from the user as a string. We can have a distinctive, non-numeric string that indicates the end of the
input; all others would be converted into numbers and treated as data. One simple solution is to have the
sentinel value be an empty string. Remember, an empty string is represented in Python as "" (quotes with
no space between). If the user types a blank line in response to a raw input (just hits Enter   ), Python
returns an empty string. We can use this as a simple way to terminate input. The design looks like this:
Initialize sum to 0.0
Initialize count to 0
Input data item as a string, xStr
while xStr is not empty
Convert xStr to a number, x
Add x to sum
Add 1 to count
Input next data item as a string, xStr
Output sum / count
Comparing this to the previous algorithm, you can see that converting the string to a number has been added
to the processing section of the sentinel loop.
Translating into Python yields this program:
# average4.py
def main():
sum = 0.0
count = 0
xStr = raw_input("Enter a number (<Enter> to quit) >> ")
while xStr != "":
x = eval(xStr)
sum = sum + x
count = count + 1
xStr = raw_input("Enter a number (<Enter> to quit) >> ")
print "\nThe average of the numbers is", sum / count
This code makes use of eval (from Chapter 4) to convert the input string into a number.
Here is an example run, showing that it is now possible to average arbitrary sets of numbers:
Enter
Enter
Enter
Enter
Enter
Enter
Enter
a
a
a
a
a
a
a
number
number
number
number
number
number
number
(<Enter>
(<Enter>
(<Enter>
(<Enter>
(<Enter>
(<Enter>
(<Enter>
to
to
to
to
to
to
to
quit)
quit)
quit)
quit)
quit)
quit)
quit)
>>
>>
>>
>>
>>
>>
>>
34
23
0
-25
-34.4
22.7
The average of the numbers is 3.38333333333
We finally have an excellent solution to our original problem. You should study this solution so that you can
incorporate these techniques into your own programs.8.3. COMMON LOOP PATTERNS
125
8.3.3 File Loops
One disadvantage of all the averaging programs presented so far is that they are interactive. Imagine you are
trying to average 87 numbers and you happen to make a typo near the end. With our interactive program, you
will need to start all over again.
A better approach to the problem might be to type all of the numbers into a file. The data in the file can
be perused and edited before sending it to a program that generates a report. This file-oriented approach is
typically used for data processing applications.
Back in Chapter 4, we looked at reading data from files using the Python readlines method and a for
loop. We can apply this technique directly to the number averaging problem. Assuming that the numbers are
typed into a file one per line, we can compute the average with this program.
# average5.py
def main():
fileName = raw_input("What file are the numbers in? ")
infile = open(fileName,.($r/.()
sum = 0.0
count = 0
for line in infile.readlines():
sum = sum + eval(line)
count = count + 1
print "\nThe average of the numbers is", sum / count
In this code, readlines reads the entire file into memory as a sequence of strings. The loop variable line
then iterates through this sequence; each line is converted to a number and added to the running sum.
One potential problem with this kind of file processing loop is that the entire contents of the file are first
read into main memory via the readlines method. As you know from Chapter 1, secondary memory
where files reside is usually much larger than the primary memory. It's possible that a large data file may
not fit into memory all at one time. In that case, this approach to file processing will be very inefficient and,
perhaps, not work at all.
With very large data files, it is better to read and process small sections of the file at a time. In the case of
text files, a simple approach is to process the file one line at a time. This is easily accomplished by a sentintel
loop and the Python readline method on files. Recall, the readline method gets the next line from a
file as a string. When we come to the end of the file, readline returns an empty string, which we can use
as a sentinel value. Here is a general pattern for an end-of-file loop in Python.
line = infile.readline()
while line != "":
# process line
line = infile.readline()
At first glance, you may be concerned that this loop stops prematurely if it encounters an empty line in
the file. This is not the case. Remember, a blank line in a text file contains a single newline character (" n"),
and the readline method includes the newline character in its return value. Since " n" != "", the loop
will continue.
Here is the code that results from applying the end-of-file sentinel loop to our number averaging problem.
# average6.py
def main():
fileName = raw_input("What file are the numbers in? ")
infile = open(fileName,&!"r-&.)
sum = 0.0
count = 0CHAPTER 8. CONTROL STRUCTURES, PART 2
126
line = infile.readline()
while line != "":
sum = sum + eval(line)
count = count + 1
line = infile.readline()
print "\nThe average of the numbers is", sum / count
Obviously, this version is not quite as concise as the version using readlines and a for loop. If the
file sizes are known to be relatively modest, that approach is probably better. When file sizes are quite large,
however, an end-of-file loop is invaluable.
8.3.4 Nested Loops
In the last chapter, you saw how control structures such as decisions and loops could be nested inside one
another to produce sophisticated algorithms. One particularly useful, but somewhat tricky technique is the
nesting of loops.
Let's take a look at an example program. How about one last version of our number averaging problem?
Honest, I promise this is the last time I'll use this example. 1 Suppose we modify the specification of our file
averaging problem slightly. This time, instead of typing the numbers into the file one-per-line, we'll allow
any number of values on a line. When multiple values appear on a line, they will be separated by commas.
At the top level, the basic algorithm will be some sort of file-processing loop that computes a running
sum and count. For practice, let's use an end-of-file loop. Here is the code comprising the top-level loop.
sum = 0.0
count = 0
line = infile.readline()
while line != "":
# update sum and count for values in line
line = infile.readline()
print "\nThe average of the numbers is", sum / count
Now we need to figure out how to update the sum and count in the body of the loop. Since each
individual line of the file contains one or more numbers separated by commas, we can split the line into
substrings, each of which represents a number. Then we need to loop through these substrings, convert each
to a number, and add it to sum. We also need to add 1 to count for each number. Here is a code fragment
that processes a line:
for xStr in string.split(line,","):
sum = sum + eval(xStr)
count = count +1
Notice that the iteration of the for loop in this fragment is controlled by the value of line, which just
happens to be the loop-control variable for the file-processing loop we outlined above.
Knitting these two loops together, here is our program.
# average7.py
import string
def main():
fileName = raw_input("What file are the numbers in? ")
infile = open(fileName,**(r!"/)
sum = 0.0
count = 0
line = infile.readline()
while line != "":
1 until
Chapter 11...8.4. COMPUTING WITH BOOLEANS
127
# update sum and count for values in line
for xStr in string.split(line):
sum = sum + eval(xStr)
count = count + 1
line = infile.readline()
print "\nThe average of the numbers is", sum / count
As you can see, the loop that processes the numbers in a line is indented inside of the file processing loop.
The outer while loop iterates once for each line of the file. On each iteration of the outer loop, the inner
for loop iterates as many times as there are numbers on that line. When the inner loop finishes, the next line
of the file is read, and the outer loop goes through its next iteration.
The individual fragments of this problem are not complex when taken separately, but the final result is
fairly intricate. The best way to design nested loops is to follow the process we did here. First design the
outer loop without worrying about what goes inside. Then design what goes inside, ignoring the outer loop(s).
Finally, put the pieces together, taking care to preserve the nesting. If the individual loops are correct, the
nested result will work just fine; trust it. With a little practice, you'll be implementing double-, even triple-
nested loops with ease.
8.4 Computing with Booleans
We now have two control structures, if and while, that use conditions, which are Boolean expressions.
Conceptually, a Boolean expression evaluates to one of two values: false or true. In Python, these values are
represented by the ints 0 and 1. So far, we have used simple Boolean expressions that compare two values
(e.g., while x >= 0).
8.4.1 Boolean Operators
Sometimes the simple conditions that we have been using do not seem expressive enough. For example,
suppose you need to determine whether two point objects are in the same position$&%that is, they have equal x
coordinates and equal y coordinates. One way of handling this would be a nested decision.
if p1.getX() == p2.getX():
if p1.getY() == p2.getY():
# points are the same
else:
# points are different
else:
# points are different
You can see how awkward this is.
Instead of working around this problem with a decision structure, another approach would be to construct
a more complex expression using Boolean operations. Like most programming languages, Python provides
three Boolean operators: and, or and not. Let's take a look at these three operators and then see how they
can be used to simplify our problem.
The Boolean operators and and or are used to combine two Boolean expressions and produce a Boolean
result.
<expr> and <expr>
<expr> or <expr>
The and of two expressions is true exactly when both of the expressions are true. We can represent this
definition in a truth table.CHAPTER 8. CONTROL STRUCTURES, PART 2
128
P
T
T
F
F
Q
T
F
T
F
P and Q
T
F
F
F
In this table, P and Q represent smaller Boolean expressions. Since each expression has two possible values,
there are four possible combinations of values, each shown as one row in the table. The last column gives the
value of P and Q for each possible combination. By definition, the and is true only in the case where both
P and Q are true.
The or of two expressions is true when either expression is true. Here is the truth table defining or:
P
T
T
F
F
Q
T
F
T
F
P or Q
T
T
T
F
The only time the or is false is when both expressions are false. Notice especially that or is true when both
expressions are true. This is the mathematical definition of or, but the word $%"or*$- is sometimes used in an
exclusive sense in everyday English. If your mom said that you could have cake or cookies for dessert, she
would probably scold you for taking both.
The not operator computes the opposite of a Boolean expression. It is a unary operator, meaning that it
operates on a single expression. The truth table is very simple.
P
T
F
not P
F
T
Using Boolean operators, it is possible to build arbitrarily complex Boolean expressions. As with arith-
metic operators, the exact meaning of a complex expression depends on the precedence rules for the operators.
Consider this expression.
a or not b and c
How should this be evaluated?
Python follows a standard convention that the order of precedence is not, followed by and, followed by
or. So the expression would be equivalent to this parenthesized version.
(a or ((not b) and c))
Unlike arithmetic, however, most people don't tend to know or remember the precedence rules for Booleans.
I suggest that you always parenthesize your complex expressions to prevent confusion.
Now that we have some Boolean operators, we are ready to return to our example problem. To test for
the co-location of two points, we could use an and operation.
if p1.getX() == p2.getX() and p2.getY() == p1.getY():
# points are the same
else:
# points are different
Here the entire expression will only be true when both of the simple conditions are true. This ensures that
both the x and y coordinates have to match for the points to be the same. Obviously, this is much simpler and
clearer than the nested ifs from the previous version.
Let's look at a slightly more complex example. In the next chapter, we will develop a simulation for the
game of racquetball. Part of the simulation will need to determine when a game has ended. Suppose that
scoreA and scoreB represent the scores of two racquetball players. The game is over as soon as either of
the players has reached 15 points. Here is a Boolean expression that is true when the game is over:8.4. COMPUTING WITH BOOLEANS
129
scoreA == 15 or scoreB == 15
When either score reaches 15, one of the two simple conditions becomes true, and, by definition of or, the
entire Boolean expression is true. As long as both conditions remain false (neither player has reached 15) the
entire expression is false.
Our simulation will need a loop that continues as long as the game is not over. We can construct an
appropriate loop condition by taking the negation of the game-over condition:
while not (scoreA == 15 or scoreB == 15):
# continue playing
We can also construct more complex Boolean expressions that reflect different possible stopping condi-
tions. Some racquetball players play shutouts (sometimes called a skunk). For these players, a game also
ends when one of the players reaches 7 and the other has not yet scored a point. For brevity, I'll use a for
scoreA and b for scoreB. Here is an expression for game-over when shutouts are included:
a == 15 or b == 15 or (a == 7 and b == 0) or (b == 7 and a == 0)
Do you see how I have added two more situations to the original condition? The new parts reflect the two
possible ways a shutout can occur, and each requires checking both scores. The result is a fairly complex
expression.
While we're at it, let's try one more example. Suppose we were writing a simulation for volleyball, rather
than racquetball. Volleyball does not have shutouts, but it requires a team to win by at least two points. If the
score is 15 to 14, or even 21 to 20, the game continues.
Let's write a condition that computes when a volleyball game is over. Here's one approach.
(a >= 15 and a - b >= 2) or (b >= 15 and b - a >= 2)
Do you see how this expression works? It basically says the game is over when team A has won (scored at
least 15 and leading by at least 2) or when team B has won.
Here is another way to do it.
(a >= 15 or b >= 15) and abs(a - b) >= 2
This version is a bit more succinct. It states that the game is over when one of the teams has reached a
winning total and the difference in the scores is at least 2. Remember that abs returns the absolute value of
an expression.
8.4.2 Boolean Algebra
All decisions in computer programs boil down to appropriate Boolean expressions. The ability to formulate,
manipulate and reason with these expressions is an important skill for programmers and computer scientists.
Boolean expressions obey certain algebraic laws similar to those that apply to numeric operations. These
laws are called Boolean logic or Boolean algebra.
Let's look at a few examples. The following table shows some rules of algebra with their correlates in
Boolean algebra.
Algebra
a   0 0
a   1 a
a 0 a
Boolean algebra
a and false == false
a and true == a
a or false == a
From these examples, you can see that and has similarities to multiplication, and or has similarities to
addition; while 0 and 1 correspond to false and true.
Here are some other interesting properties of Boolean operations. Anything ored with true is just true.
a or true == true
Both and and or distribute over each other.CHAPTER 8. CONTROL STRUCTURES, PART 2
130
a or (b and c) == (a or b) and (a or c)
a and (b or c) == (a and b) or (a and c)
A double negative cancels out.
not(not a) == a
The next two identities are known as DeMorgan's laws.
not(a or b) == (not a) and (not b)
not(a and b) == (not a) or (not b)
Notice how the operator changes between and and or when the not is pushed into an expression.
One application of Boolean algebra is the analysis and simplification of Boolean expressions inside of
programs. For example, let's go back to the racquetball game one more time. Above, we developed a loop
condition for continuing the game that looked like this:
while not (scoreA == 15 or scoreB == 15):
# continue playing
You can read this condition as something like: While it is not the case that player A has 15 or player B has 15,
continue playing. We're pretty sure that's correct, but negating complex conditions like this can be somewhat
awkward, to say the least. Using a little Boolean algebra, we can transform this result.
Applying DeMorgan's law, we know that the expression is equivalent to this.
(not scoreA == 15)
and
(not scoreB == 15)
Remember, we have to change the or to and when %&(distributing)%/ the not. This condition is no better than
the first, but we can go one step farther by pushing the nots into the conditions themselves.
while scoreA != 15 and scoreB != 15:
# continue playing
Now we have a version that is much easier to understand. This reads simply as while player A has not reached
15 and player B has not reached 15, continue playing.
This particular example illustrates a generally useful approach to loop conditions. Sometimes it's easier
to figure out when a loop should stop, rather than when the loop should continue. In that case, simply write
the loop termination condition and then put a not in front of it. An application or two of DeMorgan's laws
can then get you to a simpler but equivalent version suitable for use in a while statement.
8.5 Other Common Structures
Taken together, the decision structure (if) along with a pre-test loop (while) provide a complete set of
control structures. This means that every algorithm can be expressed using just these. Once you've mastered
the while and the if, there is no algorithm that you cannot write, in principle. However, for certain
kinds of problems, alternative structures can sometimes be convenient. This section outlines some of those
alternatives.
8.5.1 Post-Test Loop
Suppose you are writing an input algorithm that is supposed to get a nonnegative number from the user. If the
user types an incorrect input, the program asks for another value. It continues to reprompt until the user enters
a valid value. This process is called input validation. Well-engineered programs validate inputs whenever
possible.
Here is a simple algorithm.
repeat
get a number from the user
until number is >= 08.5. OTHER COMMON STRUCTURES
131
The idea here is that the loop keeps getting inputs until the value is acceptable. The flowchart depicting this
design in shown in Figure 8.2. Notice how this algorithm contains a loop where the condition test comes after
the loop body. This is a post-test loop. A post-test loop must always execute the body of the loop at least
once.
Get a number
number < 0 ?
yes
no
Figure 8.2: Flowchart of a post-test loop.
Unlike some other languages, Python does not have a statement that directly implements a post-test loop.
However, this algorithm can be implemented with a while by %+&seeding,!& the loop condition for the first
iteration.
number = -1 # Start with an illegal value to get into the loop.
while number < 0:
number = input("Enter a positive number: ")
This forces the loop body to execute at least once and is equivalent to the post-test algorithm. You might
notice that this is similar to the structure given earlier for the interactive loop pattern. Interactive loops are
naturally suited to a post-test implementation.
Some programmers prefer to simulate a post-test loop more directly by using a Python break statement.
Executing break causes Python to immediately exit the enclosing loop. Often a break statement is used
to leave what looks syntactically like an infinite loop.
Here is the same algorithm implemented with a break.
while 1:
number = input("Enter a positive number: ")
if x >= 0: break # Exit loop if number is valid.
The first line may look a bit strange to you. Remember that conditions in Python evaluate to either a 0 for false
or a 1 for true. The heading while 1 appears to be an infinite loop, since the expression always evaluates
to 1 (i.e., it is always true). However, when the value of x is nonnegative, the break statement executes,
which terminates the loop. Notice the break is placed on the same line as the if. This is legal when the
body of the if only contains one statement. It's common to see a one-line if-break combination used as
a loop exit.
Even this small example can be improved. It would be nice if the program issued a warning explaining
why the input was invalid. In the while version of the post-test loop, this is a bit awkward. We need to add
an if so that the warning is not displayed for valid inputs.132
CHAPTER 8. CONTROL STRUCTURES, PART 2
number = -1 # Start with an illegal value to get into the loop.
while number < 0:
number = input("Enter a positive number: ")
if number < 0:
print "The number you entered was not positive"
See how the validity check gets repeated in two places?
Adding a warning to the version using break only requires adding an else to the existing if.
while 1:
number = input("Enter a positive number: ")
if x >= 0:
break # Exit loop if number is valid.
else:
print "The number you entered was not positive"
8.5.2 Loop and a Half
Some programmers would solve the warning problem from the previous section using a slightly different
style.
while 1:
number = input("Enter a positive number: ")
if x >= 0: break
# Loop exit
print "The number you entered was not positive"
Here the loop exit is actually in the middle of the loop body. This is called a loop and a half. Some purists
frown on exits in the midst of a loop like this, but the pattern can be quite handy.
The loop and a half is an elegant way to avoid the priming read in a sentinel loop. Here is the general
pattern of a sentinel loop implemented as a loop and a half.
while 1:
Get next data item
if the item is the sentinel: break
process the item
Figure 8.3 shows a flowchart of this approach to sentinel loops. You can see that this implementation is
faithful to the first rule of sentinel loops: avoid processing the sentinel value.
The choice of whether to use break statements or not is largely a matter of taste. Either style is accept-
able. One temptation that should generally be avoided is peppering the body of a loop with multiple break
statements. The logic of a loop is easily lost when there are multiple exits. However, there are times when
even this rule should be broken to provide the most elegant solution to a problem.
8.5.3 Boolean Expressions as Decisions
So far, we have talked about Boolean expressions only within the context of other control structures. Some-
times, Boolean expressions themselves can act as control structures. In fact, Boolean expressions are so
flexible in Python that they can sometimes lead to subtle programming errors.
Consider writing an interactive loop that keeps going as long as the user response starts with a %%#y.*/, To
allow the user to type either an upper or lower case response, you could use a loop like this:
while response[0] == "y" or response[0] == "Y":
You must be be careful not to abbreviate this condition as you might think of it in English: )'%While the first
letter is )**y%%' or &."Y#*(#$$. The following form does not work.
while response[0] == "y" or "Y":8.5. OTHER COMMON STRUCTURES
133
Get next Data item
Item is the sentinel ?
yes
no
Process the item
Figure 8.3: Loop-and-a-half implementation of sentinel loop pattern
In fact, this is an infinite loop. Understanding why this condition is always true requires digging into some
idiosyncrasies of Python Boolean expressions.
You already know that Python does not have any special Boolean type. We have been using the int values
0 and 1 to represent the Boolean values false and true, respectively. The Python condition operators (i.e.,
==) always evaluate to either 0 or 1. However, Python is actually very flexible about what can be a Boolean
expression. Any built-in type can be interpreted as a Boolean. For numbers (ints, floats and long ints) a zero
value is considered as false, anything other than zero is taken as true. Other types can also be used in Boolean
expressions. For example, Python interprets an empty string as false and any nonempty string as true.
The flexibility of Python Booleans extends to the Boolean operators. Although the main use of these
operators is forming Boolean expressions, they have operational definitions that make them useful for other
purposes as well. This table summarizes the behavior of these operators.
operator
x and y
x or y
not x
operational definition
If x is false, return x. Otherwise, return y.
If x is false, return y. Otherwise, return x.
If x is false, return 1. Otherwise, return 0.
The definition of not is straightforward. It might take a bit of thinking to convince yourself that these
descriptions of and and or faithfully reflect the truth tables you saw at the beginning of the chapter.
Consider the expression x and y. In order for this to be true, both expressions x and y must be true. As
soon as one of them is discovered to be false, the party is over. Python looks at the expressions left-to-right.
If x is false, Python should return a false result. Whatever the false value of x was, that is what is returned.
If x turns out to be true, then the truth or falsity of the whole expression turns on the result of y. Simply
returning y guarantees that if y is true, the whole result is true, and if y is false, the whole result is false.
Similar reasoning can be used to show that the description of or is faithful to the logical definition of or
given in the truth table.
These operational definitions show that Python's Boolean operators are short-circuit operators. That
means that a true or false value is returned as soon as the result is known. In an and where the first expression
is false and in an or where the first expression is true, Python will not even evaluate the second expression.
Now let's take a look at our infinite loop problem.134
CHAPTER 8. CONTROL STRUCTURES, PART 2
response[0] == "y" or "Y"
Treated as a Boolean expression, this will always evaluate to true. The first thing to notice is that the Boolean
operator is combining two expressions; the first is a simple condition, and the second is a string. Here is an
equivalent parenthesized version:
(response[0] == "y") or ("Y"):
By the operational description of or, this expression returns either 1 (returned by == when response[0]
is "(.y'+&) or "Y" (when response[0] is not a $!*y-*!). Either of these results is interpreted by Python as true.
A more logic-oriented way to think about this is to simply look at the second expression. It is a nonempty
string, so Python will always interpret it as true. Since at least one of the two expressions is always true, the
or of the expressions must always be true as well.
So, the strange behavior of this example is due to some quirks in the definitions of the Boolean operators.
This is one of the few places where the design of Python has a potential pitfall for the beginning programmer.
You may wonder about the wisdom of this design, yet the flexibility of Python allows for certain succinct
programming idioms that many programmers find useful. Let's look at an example.
Frequently, programs prompt users for information but offer a default value for the response. The default
value, sometimes listed in square brackets, is used if the user simply hits the Enter   key. Here is an example
code fragment:
ans = raw_input("What flavor do you want [vanilla]: ")
if ans != "":
flavor = ans
else:
flavor = "vanilla"
Exploiting the fact that the string in ans can be treated as a Boolean, the condition in this code can be
simplified as follows.
ans = raw_input("What flavor do you want [vanilla]: ")
if ans:
flavor = ans
else:
flavor = "vanilla"
Here a Boolean condition is being used to decide how to set a string variable. If the user just hits Enter   ,
ans will be an empty string, which Python interprets as false. In this case, the empty string will be replaced
by "vanilla" in the else clause.
The same idea can be succinctly coded by treating the strings themselves as Booleans and using an or.
ans = raw_input("What flavor do you want [vanilla]: ")
flavor = ans or "vanilla"
The operational definition of or guarantees that this is equivalent to the if-else version. Remember, any
nonempty answer is interpreted as *+'true.&+(
In fact, this task can easily be accomplished in a single line of code.
flavor = raw_input("What flavor do you want [vanilla]: ") or "vanilla"
I don't know whether it's really worthwhile to save a few lines of code using Boolean operators this way. If
you like this style, by all means, feel free to use it. Just make sure that your code doesn't get so tricky that
others (or you) have trouble understanding it.
8.6 Exercises
1. Compare and contrast the following pairs of terms.8.6. EXERCISES
135
(a) Definite loop vs. Indefinite loop
(b) For loop vs. While loop
(c) Interactive loop vs. Sentinel loop
(d) Sentinel loop vs. End-of-file loop
2. Give a truth table that shows the (Boolean) value of each of the following Boolean expressions, for
every possible combination of (/-input&,# values. Hint: including columns for '.-intermediate&(( expressions
is helpful.
(a) not (P and Q)
(b) (not P) and Q
(c) (not P) or (not Q)
(d) (P and Q) or R
(e) (P or R) and (Q or R)
3. Write a while loop fragment that calculates the following values.
(a) Sum of the first n counting numbers: 1
(b) Sum of the first n odd numbers: 1
3
2
5
3
2n
n
1
(c) Sum of a series of numbers entered by the user until the value 999 is entered. Note: 999 should
not be part of the sum.
(d) The number of times a whole number n can be divided by 2 (using integer division) before reach-
ing 1 (i.e., log 2 n).
4. The Fibonacci sequence starts 1 )*/ 1 .(" 2 $$" 3 .!$ 5 .". 8 -() . Each number in the sequence (after the first two) is the
sum of the previous two. Write a program that computes and outputs the nth Fibonacci number, where
n is a value entered by the user.
5. The National Weather Service computes the windchill index using the following formula.
35 75 V 0 16
35 74
0 6215T
0 4275T V 0 16
Where T is the temperature in degrees Fahrenheit, and V is the wind speed in miles per hour.
Write a program that prints a nicely formatted table of windchill values. Rows should represent wind
speed for 0 to 50 in 5 mph increments, and the columns represent temperatures from -20 to +60 in
10-degree increments.
6. Write a program that uses a while loop to determine how long it takes for an investment to double
at a given interest rate. The input will be an annualized interest rate, and the output is the number of
years it takes an investment to double. Note: the amount of the initial investment does not matter; you
can use $1.
7. The Syracuse (also called Collatz or Hailstone) sequence is generated by starting with a natural number
and repeatedly applying the following function until reaching 1.
syr x
x 2
if x is even
3x 1 if x is odd
For example, the Syracuse sequence starting with 5 is: 5 %// 16 ",+ 8 ,#! 4 ))) 2 !)* 1. It is an open question in mathe-
matics whether this sequence will always go to 1 for every possible starting value.
Write a program that gets a starting value from the user and then prints the Syracuse sequence for that
starting value.CHAPTER 8. CONTROL STRUCTURES, PART 2
136
8. A postive whole number n   2 is prime if no number between 2 and n (inclusive) evenly divides n.
Write a program that accepts a value of n as input and determines if the value is prime. If n is not
prime, your program should quit as soon as it finds a value that evenly divides n.
9. Modify the previous program to find every prime number less than or equal to n.
10. The greatest common divisor (GCD) of two values can be computed using Euclid's algorithm. Starting
with the values m and n, we repeatedly apply the formula: n, m = m, n%m until m is 0. At that
point, n is the GCD of the original m and n. Write a program that finds the GCD of two numbers using
this algorithm.
11. Write a program that computes the fuel efficiency of a multi-leg journey. The program will first prompt
for the starting odometer reading and then get information about a series of legs. For each leg, the
user enters the current odometer reading and the amount of gas used (separated by a space). The user
signals the end of the trip with a blank line. The program should print out the miles per gallon achieved
on each leg and the total MPG for the trip.
12. Modify the previous program to get its input from a file.
13. Heating and cooling degree-days are measures used by utility companies to estimate energy require-
ments. If the average temperature for a day is below 60, then the number of degrees below 60 is added
to the heating degree-days. If the temperature is above 80, the amount over 80 is added to the cooling
degree-days. Write a program that accepts a sequence of average daily temps and computes the running
total of cooling and heating degree-days. The program should print these two totals after all the data
has been processed.
14. Modify the previous program to get its input from a file.
15. Write a program that graphically plots a regression line, that is, the line with the best fit through a
collection of points. First ask the user to specify the data points by clicking on them in a graphics
window. To find the end of input, place a small rectangle labelled '("Done(+, in the lower left corner of
the window; the program will stop gathering points when the user clicks inside that rectangle.
The regression line is the line with the following equation:
y
 "! y
where
m x
 -, x
'." x i y i n  $- x  */ y
$!) x 2 i n  /+ x 2
m
 %* x is the mean of the x-values and  +% y is the mean of the y-values.
As the user clicks on points, the program should draw them in the graphics window and keep track of
the count of input values and the running sum of x, y, x 2 and xy values. When the user clicks inside the
#+,Done#%* rectangle, the program then computes value of y (using the equations above) correponding to
the x values at the left and right edges of the window to compute the endpoints of the regression line
spanning the window. After the line is drawn, the program will pause for another mouse click before
closing the window and quitting.Chapter 9
Simulation and Design
You may not realize it, but you have reached a significant milestone in the journey to becoming a computer
scientist. You now have all the tools to write programs that solve interesting problems. By interesting, I mean
problems that would be difficult or impossible to solve without the ability to write and implement computer
algorithms. You are probably not yet ready to write the next great killer application, but you can do some
nontrivial computing.
One particularly powerful technique for solving real-world problems is simulation. Computers can model
real-world processes to provide otherwise unobtainable information. Computer simulation is used every
day to perform myriad tasks such as predicting the weather, designing aircraft, creating special effects for
movies, and entertaining video game players, to name just a few. Most of these applications require extremely
complex programs, but even relatively modest simulations can sometimes shed light on knotty problems.
In this chapter we are going to develop a simple simulation of the game of racquetball. Along the way,
you will learn some important design and implementation strategies that will help you in tackling your own
problems.
9.1 Simulating Racquetball
9.1.1 A Simulation Problem
Suzie Programmer's friend, Denny Dibblebit, plays racquetball. Over years of playing, he has noticed a
strange quirk in the game. He often competes with players who are just a little bit better than he is. In the
process, he always seems to get thumped, losing the vast majority of matches. This has led him to question
what is going on. On the surface, one would think that players who are slightly better should win slightly
more often, but against Denny, they seem to win the lion's share.
One obvious possibility is that Denny Dibblebit's problem is in his head. Maybe his mental game isn't
up to par with his physical skills. Or perhaps the other players are really much better than he is, and he just
refuses to see it.
One day, Denny was discussing racquetball with Suzie, when she suggested another possibility. Maybe it
is the nature of the game itself that small differences in ability lead to lopsided matches on the court. Denny
was intrigued by the idea; he didn't want to to waste money on an expensive sports psychologist if it wasn't
going to help. But how could he figure out if the problem was mental or just part of the game?
Suzie suggested she could write a computer program to simulate certain aspects of racquetball. Using the
simulation, they could let the computer model thousands of games between players of differing skill levels.
Since there would not be any mental aspects involved, the simulation would show whether Denny is losing
more than his share of matches.
Let's write our own racquetball simulation and see what Suzie and Denny discovered.
137CHAPTER 9. SIMULATION AND DESIGN
138
9.1.2 Program Specification
Racquetball is a sport played between two players using racquets to strike a ball in a four-walled court. It
has aspects similar to many other ball and racquet games such as tennis, volleyball, badminton, squash, table
tennis, etc. We don't need to understand all the rules of racquetball to write the program, just the basic outline
of the game.
To start the game, one of the players puts the ball into play*."this is called serving. The players then
alternate hitting the ball to keep it in play; this is a rally. The rally ends when one of the players fails to hit a
legal shot. The player who misses the shot loses the rally. If the loser is the player who served, then service
passes to the other player. If the server wins the rally, a point is awarded. Players can only score points during
their service. The first player to reach 15 points wins the game.
In our simulation, the ability-level of the players will be represented by the probability that the player
wins the rally when he or she serves. Thus, players with a 0.6 probability win a point on 60% of their serves.
The program will prompt the user to enter the service probability for both players and then simulate multiple
games of racquetball using those probabilities. The program will then print a summary of the results.
Here is a detailed specification:
Input The program first prompts for and gets the service probabilities of the two players (called -**Player A-'&
and +-'Player B&"(). Then the program prompts for and gets the number of games to be simulated.
Output The program will provide a series of initial prompts such as the following:
What is the prob. player A wins a serve?
What is the prob. player B wins a serve?
How many games to simulate?
The program will print out a nicely formatted report showing the number of games simulated and the
number of wins and winning percentage for each player. Here is an example:
Games Simulated: 500
Wins for A: 268 (53.6%)
Wins for B: 232 (46.4%)
Notes: All inputs are assumed to be legal numeric values, no error or validity checking is required.
In each simulated game, player A serves first.
9.2 Random Numbers
Our simulation program will have to deal with uncertain events. When we say that a player wins 50% of the
serves, that does not mean that every other serve is a winner. It's more like a coin toss. Overall, we expect
that half the time the coin will come up heads and half the time it will come up tails, but there is nothing to
prevent a run of five tails in a row. Similarly, our racquetball player should win or lose rallies randomly. The
service probability provides a likelihood that a given serve will be won, but there is no set pattern.
Many simulations share this property of requiring events to occur with a certain likelihood. A driving
simulation must model the unpredictability of other drivers; a bank simulation has to deal with the random
arrival of customers. These sorts of simulations are sometimes called Monte Carlo algorithms, because the
results depend on &&(chance.,* probabilities. Of course, you know that there is nothing random about computers;
they are instruction-following machines. How can computer programs model seemingly random happenings?
Simulating randomness is a well-studied problem in computer science. Remember the chaos program
from Chapter 1? The numbers produced by that program seemed to jump around randomly between zero and
one. This apparent randomness came from repeatedly applying a function to generate a sequence of numbers.
A similar approach can be used to generate random (actually pseudorandom) numbers.
A pseudorandom number generator works by starting with some seed value. This value is fed to a function
to produce a *&&random./( number. The next time a random number is needed, the current value is fed back into9.2. RANDOM NUMBERS
139
the function to produce a new number. With a carefully chosen function, the resulting sequence of values
looks essentially random. Of course, if you start the process over again with the same seed value, you end up
with exactly the same sequence of numbers. It's all determined by the generating function and the value of
the seed.
Python provides a library module that contains a number of useful functions for generating pseudorandom
numbers. The functions in this module derive an initial seed value from the date and time when the module
is loaded, so you get a different seed value each time the program is run. This means that you will also get a
unique sequence of pseudorandom values. The two functions of greatest interest to us are randrange and
random.
The randrange function is used to select a pseudorandom int from a given range. It can be used
with one, two or three parameters to specify a range exactly as with the range function. For example,
randrange(1,6) returns some number from the range [1,2,3,4,5], and randrange(5,105,5)
returns a multiple of 5 between 5 and 100, inclusive. (Remember, ranges go up to, but not including, the
stopping value.)
Each call to randrange generates a new pseudorandom int. Here is an interactive session that shows
randrange in action.
>>>
>>>
3
>>>
3
>>>
5
>>>
5
>>>
5
>>>
1
>>>
5
>>>
4
>>>
2
from random import randrange
randrange(1,6)
randrange(1,6)
randrange(1,6)
randrange(1,6)
randrange(1,6)
randrange(1,6)
randrange(1,6)
randrange(1,6)
randrange(1,6)
Notice it took ten calls to randrange to eventually generate every number in the range 1"#-5. The value 5
came up almost half of the time. This shows the probabilistic nature of random numbers. Over the long haul,
this function produces a uniform distribution, which means that all values will appear an (approximately)
equal number of times.
The random function can be used to generate pseudorandom floating point values. It requires no param-
eters and returns values uniformly distributed between 0 and 1 (including 0, but excluding 1). Here are some
interactive examples.
>>> from random import random
>>> random()
0.545146406725
>>> random()
0.221621655814
>>> random()
0.928877335157
>>> random()
0.258660828538
>>> random()
0.859346793436CHAPTER 9. SIMULATION AND DESIGN
140
The name of the module (random) is the same as the name of the function, which gives rise to the funny-
looking import line.
Our racquetball simulation can make use of the random function to determine whether or not a player
wins a serve. Let's look at a specific example. Suppose a player's service probability is 0.70. This means that
they should win 70% of their serves. You can imagine a decision in the program something like this:
if <player wins serve>:
score = score + 1
We need to insert a probabilistic condition that will succeed 70% of the time.
Suppose we generate a random value between 0 and 1. Exactly 70% of the interval 0 1 is to the left of
0.7. So 70% of the time the random number will be 0.7, and it will be 0.7 the other 30% of the time. (The
goes on the upper end, because the random generator can produce a 0, but never a 1.) In general, if prob
represents the probability that the player wins a serve, the condition random() < prob will succeed with
just the right probability. Here is how the decision will look:
if random() < prob:
score = score + 1
9.3 Top-Down Design
Now you have the complete specification for our simulation and the necessary knowledge of random numbers
to get the job done. Go ahead and take a few minutes to write up the program; I'll wait.
OK, seriously, this is a more complicated program than you've probably attempted so far. You may
not even know where to begin. If you're going to make it through with minimal frustration, you'll need a
systematic approach.
One proven technique for tackling complex problems is called top-down design. The basic idea is to start
with the general problem and try to express a solution in terms of smaller problems. Then each of the smaller
problems is attacked in turn using the same technique. Eventually the problems get so small that they are
trivial to solve. Then you just put all the pieces back together and, voil`a, you've got a program.
9.3.1 Top-Level Design
Top-down design is easier to illustrate than it is to define. Let's give it a try on our racquetball simulation
and see where it takes us. As always, a good start is to study the program specification. In very broad brush
strokes, this program follows the basic Input-Process-Output pattern. We need to get the simulation inputs
from the user, simulate a bunch of games, and print out a report. Here is a basic algorithm.
Print an Introduction
Get the inputs: probA, probB, n
Simulate n games of racquetball using probA and probB
Print a report on the wins for playerA and playerB
Now that we've got an algorithm, we're ready to write a program. I know what you're thinking: this
design is too high-level; you don't have any idea yet how it's all going to work. That's OK. Whatever we
don't know how to do, we'll just ignore for now. Imagine that all of the components you need to implement
the algorithm have already been written for you. Your job is to finish this top-level algorithm using those
components.
First we have to print an introduction. I think I know how to do this. It just requires a few print statements,
but I don't really want to bother with it right now. It seems an unimportant part of the algorithm. I'll
procrastinate and pretend that someone else will do it for me. Here's the beginning of the program.
def main():
printInstructions()9.3. TOP-DOWN DESIGN
141
Do you see how this works. I'm just assuming there is a printInstructions function that takes care of
printing the instructions. That step was easy! Let's move on.
Next, I need to get some inputs from the user. I also know how to do that+,+I just need a few input
statements. Again, that doesn't seem very interesting, and I feel like putting off the details. Let's assume that
a component already exists to solve that problem. We'll call the function getInputs. The point of this
function is to get values for variables probA, probB and n. The function must return these values for the
main program to use. Here is our program so far:
def main():
printInstructions()
probA, probB, n = getInputs()
We're making progress, let's move on to the next line.
Here we've hit the crux of the problem. We need to simulate n games of racquetball using the values of
probA, and probB. This time, I really don't have a very good idea how that will even be accomplished.
Let's procrastinate again and push the details off into a function. (Maybe we can get someone else to write
that part for us later.) But what should we put into main? Let's call our function simNGames. We need to
figure out what the call of this function looks like.
Suppose you were asking a friend to actually carry out a simulation of n games. What information would
you have to give him? Your friend would need to know how many games he was supposed to simulate and
what the values of probA and probB should be for those simulations. These three values will, in a sense,
be inputs to the function.
What information do you need to get back from your friend? Well, in order to finish out the program
(print a report) you need to know how many games were won by player A and how many games were won by
Player B. These must be outputs from the simNGames function. Remember in the discussion of functions
in Chapter 6, I said that parameters were used as function inputs, and return values serve as function outputs.
Given this analysis, we now know how the next step of the algorithm can be coded.
def main():
printInstructions()
probA, probB, n = getInputs()
winsA, winsB = simNGames(n, probA, probB)
Are you getting the hang of this? The last step is to print a report. If you told your friend to type up the
report, you would have to tell him how many wins there were for each player; these values are inputs to the
function. Here's the complete program.
def main():
printInstructions()
probA, probB, n = getInputs()
winsA, winsB = simNGames(n, probA, probB)
printSummary(winsA, winsB)
That wasn't very hard. The main function is only five lines long, and the program looks like a more precise
formulation of the rough algorithm.
9.3.2 Separation of Concerns
Of course, the main function alone won't do very much; we've put off all of the interesting details. In fact,
you may think that we have not yet accomplished anything at all, but that is far from true.
We have broken the original problem into four independent tasks: printInstructions, getInputs,
simNGames and printSummary. Further, we have specified the name, parameters and expected return
values of the functions that perform these tasks. This information is called the interface or signature of a
function.
Having signatures allows us to tackle pieces independently. For the purposes of main, we don't care how
simNGames does its job. The only concern is that, when given the number of games to simulate and the twoCHAPTER 9. SIMULATION AND DESIGN
142
probabilities, it must hand back the correct number of wins for each player. The main function only cares
what each (sub-)function does.
Our work so far can be represented as a structure chart (also called a module hierarchy chart). Figure 9.1
illustrates. Each component in the design is a rectangle. A line connecting two rectangles indicates that the
one above uses the one below. The arrows and annotations show the interfaces between the components in
terms of information flow.
main
winsA
winsB
probA
probB
n
printIntro
getInputs
probA
probB
n
winsA
winsB
simNGames
printSummary
Figure 9.1: First-level structure chart for racquetball simulation.
At each level of a design, the interface tells us which details of the lower level are important. Anything
else can be ignored (for the moment). The general process of determining the important characteristics of
something and ignoring other details is called abstraction. Abstraction is the fundamental tool of design. You
might view the entire process of top-down design as a systematic method for discovering useful abstractions.
9.3.3 Second-Level Design
Now all we need to do is repeat the design process for each of the remaining components. Let's take them
in order. The printIntro function should print an introduction to the program. Let's compose a suitable
sequence of print statements.
def printIntro():
print "This program simulates a game of racquetball between two"
print $!%players called "A" and "B". The abilities of each player is.&$
print "indicated by a probability (a number between 0 and 1) that"
print "the player wins the point when serving. Player A always"
print "has the first serve."
Notice the second line. I wanted to put double quotes around +!(A*.) and )$&B,")# so the entire string is enclosed in
apostrophes. This function comprises only primitive Python instructions. Since we didn't introduce any new
functions, there is no change to our structure chart.
Now let's tackle getInputs. We need to prompt for and get three values, which are returned to the
main program. Again, this is simple to code.
def getInputs():
# RETURNS the three simulation parameters probA, probB and n
a = input("What is the prob. player A wins a serve? ")
b = input("What is the prob. player B wins a serve? ")
n = input("How many games to simulate? ")
return a, b, n
Notice that I have taken some shortcuts with the variable names. Remember, variables inside of a function
are local to that function. This function is so short, it's very easy to see what the three values represent. The
main concern here is to make sure the values are returned in the correct order to match with the interface we
established between getInputs and main.9.3. TOP-DOWN DESIGN
143
9.3.4 Designing simNGames
Now that we are getting some experience with the top-down design technique, we are ready to try our hand at
the real problem, simNGames. This one requires a bit more thought. The basic idea is to simulate n games
and keep track of how many wins there are for each player. Well, +*(simulate n games((( sounds like a counted
loop, and tracking wins sounds like the job for a couple of accumulators. Using our familiar patterns, we can
piece together an algorithm.
Initialize winsA and winsB to 0
loop n times
simulate a game
if playerA wins
Add one to winsA
else
Add one to winsB
It's a pretty rough design, but then so was our top-level algorithm. We'll fill in the details by turning it into
Python code.
Remember, we already have the signature for our function.
def simNGames(n, probA, probB):
# Simulates n games and returns winsA and winsB
We'll add to this by initializing the two accumulator variables and adding the counted loop heading.
def simNGames(n, probA, probB):
# Simulates n games and returns winsA and winsB
winsA = 0
winsB = 0
for i in range(n):
The next step in the algorithm calls for simulating a game of racquetball. I'm not quite sure how to do
that, so as usual, I'll put off the details. Let's just assume there's a function called simOneGame to take care
of this.
We need to figure out what the interface for this function will be. The inputs for the function seem
straightforward. In order to accurately simulate a game, we need to know what the probabilities are for each
player. But what should the output be? In the next step of the algorithm, we need to know who won the game.
How do you know who won? Generally, you look at the final score.
Let's have simOneGame return the final scores for the two players. We can update our structure chart
to reflect these decisions. The result is shown in Figure 9.2. Translating this structure into code yields this
nearly completed function:
def simNGames(n, probA, probB):
# Simulates n games and returns winsA and winsB
winsA = 0
winsB = 0
for i in range(n):
scoreA, scoreB = simOneGame(probA, probB)
Finally, we need to check the scores to see who won and update the appropriate accumulator. Here is the
result.
def simNGames(n, probA, probB):
winsA = winsB = 0
for i in range(n):
scoreA, scoreB = simOneGame(probA, probB)
if scoreA > scoreB:
winsA = winsA + 1CHAPTER 9. SIMULATION AND DESIGN
144
main
winsA
winsB
probA
probB
n
printIntro
getInputs
probA
probB
n
winsA
winsB
simNGames
printSummary
probA
probB
scoreA
scoreB
simOneGame
Figure 9.2: Level 2 structure chart for racquetball simulation.
else:
winsB = winsB + 1
return winsA, winsB
9.3.5 Third-Level Design
Everything seems to be coming together nicely. Let's keep working on the guts of the simulation. The
next obvious point of attack is simOneGame. Here's where we actually have to code up the logic of the
racquetball rules. Players keep doing rallies until the game is over. That suggests some kind of indefinite
loop structure; we don't know how many rallies it will take before one of the players gets to 15. The loop just
keeps going until the game is over.
Along the way, we need to keep track of the score(s), and we also need to know who is currently serving.
The scores will probably just be a couple of int-valued accumulators, but how do we keep track of who's
serving? It's either player A or player B. One approach is to use a string variable that stores either "A" or
"B". It's also an accumulator of sorts, but to update its value, we just switch it from one value to the other.
That's enough analysis to put together a rough algorithm. Let's try this:
Initialize scores to 0
Set serving to "A"
Loop while game is not over:
Simulate one serve of whichever player is serving
update the status of the game
Return scores
It's a start, at least. Clearly there's still some work to be done on this one.
We can quickly fill in the first couple steps of the algorithm to get the following.
def simOneGame(probA, probB):
scoreA = 0
scoreB = 0
serving = "A"
while <condition>:
The question at this point is exactly what the condition will be. We need to keep looping as long as the
game is not over. We should be able to tell if the game is over by looking at the scores. We discussed a9.3. TOP-DOWN DESIGN
145
number of possibilities for this condition in the previous chapter, some of which were fairly complex. Let's
hide the details in another function, gameOver, that looks at the scores and returns true (1) if the game is
over, and false (0) if it is not. That gets us on to the rest of the loop for now.
Figure 9.3 shows the structure chart with our new function. The code for simOneGame now looks like
this:
def simOneGame(probA, probB):
scoreA = 0
scoreB = 0
serving = "A"
while not gameOver(scoreA, scoreB):
main
winsA
winsB
probA
probB
n
printIntro
getInputs
probA
probB
n
winsA
winsB
simNGames
printSummary
probA
probB
scoreA
scoreB
simOneGame
scoreA
scoreB
true|false
gameOver
Figure 9.3: Level 3 structure chart for racquetball simulation.
Inside the loop, we need to do a single serve. Remember, we are going to compare a random number to a
probability in order to determine if the server wins the point (random() < prob). The correct probability
to use is determined by the value of serving. We will need a decision based on this value. If A is serving,
then we need to use A's probability, and, based on the result of the serve, update either A's score or change
the service to B. Here is the code:
if serving == "A":
if random() < probA: # A wins the serve
scoreA = scoreA + 1
else:
# A loses the serve
serving = "B"
Of course, if A is not serving, we need to do the same thing, only for B. We just need to attach a mirror
image else clause.
if serving == "A":
if random() < probA:
scoreA = scoreA + 1
# A wins the serveCHAPTER 9. SIMULATION AND DESIGN
146
else:
serving = "B"
else:
if random() < probB:
scoreB = scoreB + 1
else:
serving = "A"
# A loses serve
# B wins the serve
# B loses the serve
That pretty much completes the function. It got a bit complicated, but seems to reflect the rules of the
simulation as they were laid out. Putting the function together, here is the result.
def simOneGame(probA, probB):
scoreA = 0
scoreB = 0
serving = "A"
while gameNotOver(scoreA, scoreB):
if serving == "A":
if random() < probA:
scoreA = scoreA + 1
else:
serving = "B"
else:
if random() < probB:
scoreB = scoreB + 1
else:
serving = "A"
return scoreA, scoreB
9.3.6 Finishing Up
Whew! We have just one more troublesome function left, gameOver. Here is what we know about it so far.
def gameOver(a,b):
# a and b represent scores for a racquetball game
# RETURNS true if the game is over, false otherwise.
According to the rules for our simulation, a game is over when either player reaches a total of 15. We can
check this with a simple Boolean condition.
def gameOver(a,b):
# a and b represent scores for a racquetball game
# RETURNS true if the game is over, false otherwise.
return a==15 or b==15
Notice how this function directly computes and returns the Boolean result all in one step.
We've done it! Except for printSummary, the program is complete. Let's fill in the missing details
and call it a wrap. Here is the complete program from start to finish:
# rball.py
from random import random
def main():
printIntro()
probA, probB, n = getInputs()
winsA, winsB = simNGames(n, probA, probB)
printSummary(winsA, winsB)9.3. TOP-DOWN DESIGN
147
def printIntro():
print "This program simulates a game of racquetball between two"
print !)"players called "A" and "B". The abilities of each player is%+-
print "indicated by a probability (a number between 0 and 1) that"
print "the player wins the point when serving. Player A always"
print "has the first serve."
def getInputs():
# Returns the three simulation parameters
a = input("What is the prob. player A wins a serve? ")
b = input("What is the prob. player B wins a serve? ")
n = input("How many games to simulate? ")
return a, b, n
def simNGames(n, probA, probB):
# Simulates n games of racquetball between players whose
#
abilities are represented by the probability of winning a serve.
# RETURNS number of wins for A and B
winsA = winsB = 0
for i in range(n):
scoreA, scoreB = simOneGame(probA, probB)
if scoreA > scoreB:
winsA = winsA + 1
else:
winsB = winsB + 1
return winsA, winsB
def simOneGame(probA, probB):
# Simulates a single game or racquetball between players whose
#
abilities are represented by the probability of winning a serve.
# RETURNS final scores for A and B
serving = "A"
scoreA = 0
scoreB = 0
while not gameOver(scoreA, scoreB):
if serving == "A":
if random() < probA:
scoreA = scoreA + 1
else:
serving = "B"
else:
if random() < probB:
scoreB = scoreB + 1
else:
serving = "A"
return scoreA, scoreB
def gameOver(a, b):
# a and b represent scores for a racquetball game
# RETURNS true if the game is over, false otherwise.
return a==15 or b==15
def printSummary(winsA, winsB):
# Prints a summary of wins for each player.CHAPTER 9. SIMULATION AND DESIGN
148
n = winsA + winsB
print "\nGames simulated:", n
print "Wins for A: %d (%0.1f%%)" % (winsA, float(winsA)/n*100)
print "Wins for B: %d (%0.1f%%)" % (winsB, float(winsB)/n*100)
if __name__ == /..__main__+$+: main()
You might take notice of the string formatting in printSummary. Since a percent sign normally marks the
beginning of a slot specifier, to get a normal percent sign at the end, I had to use a double percent %%.
9.3.7 Summary of the Design Process
You have just seen an example of top-down design in action. Now you can really see why it's called top-down
design. We started at the highest level of our structure chart and worked our way down. At each level, we
began with a general algorithm and then gradually refined it into precise code. This approach is sometimes
called step-wise refinement. The whole process can be summarized in four steps:
1. Express the algorithm as a series of smaller problems.
2. Develop an interface for each of the small problems.
3. Detail the algorithm by expressing it in terms of its interfaces with the smaller problems.
4. Repeat the process for each smaller problem.
Top-down design is an invaluable tool for developing complex algorithms. The process may seem easy,
since I've walked you through it step-by-step. When you first try it out for yourself, though, things probably
won't go quite so smoothly. Stay with it&'+the more you do it, the easier it will get. Initially, you may think
writing all of those functions is a lot of trouble. The truth is, developing any sophisticated system is virtually
impossible without a modular approach. Keep at it, and soon expressing your own programs in terms of
cooperating functions will become second nature.
9.4 Bottom-Up Implementation
Now that we've got a program in hand, your inclination might be to run off, type the whole thing in, and give
it a try. If you do that, the result will probably be disappointment and frustration. Even though we have been
very careful in our design, there is no guarantee that we haven't introduced some silly errors. Even if the code
is flawless, you'll probably make some mistakes when you enter it. Just as designing a program one piece at
a time is easier than trying to tackle the whole problem at once, implementation is best approached in small
doses.
9.4.1 Unit Testing
A good way to approach the implementation of a modest size program is to start at the lower levels of the
structure chart and work your way up, testing each component as you complete it. Looking back at the
structure chart for our simulation, we could start with the gameOver function. Once this function is typed
into a module file, we can immediately import the file and test it. Here is a sample session testing out just this
function.
>>>
>>>
0
>>>
0
>>>
1
import rball
rball1.gameOver(0,0)
rball1.gameOver(5,10)
rball1.gameOver(15,3)9.4. BOTTOM-UP IMPLEMENTATION
149
>>> rball1.gameOver(3,15)
1
I have selected test data that exercise all the important cases for the function. The first time it is called, the
score will be 0 to 0. The function correctly responds with 0 (false); the game is not over. As the game
progresses, the function will be called with intermediate scores. The second example shows that the function
again responded that the game is still in progress. The last two examples show that the function correctly
identifies that the game is over when either player reaches 15.
Having confidence that gameOver is functioning correctly, now we can go back and implement the
simOneGame function. This function has some probabilistic behavior, so I'm not sure exactly what the
output will be. The best we can do in testing it is to see that it behaves reasonably. Here is a sample session.
>>> import rball
>>> rball1.simOneGame(.5,.5)
(13, 15)
>>> rball1.simOneGame(.5,.5)
(15, 11)
>>> rball1.simOneGame(.3,.3)
(15, 11)
>>> rball1.simOneGame(.3,.3)
(11, 15)
>>> rball1.simOneGame(.4,.9)
(4, 15)
>>> rball1.simOneGame(.4,.9)
(1, 15)
>>> rball1.simOneGame(.9,.4)
(15, 3)
>>> rball1.simOneGame(.9,.4)
(15, 0)
>>> rball1.simOneGame(.4,.6)
(9, 15)
>>> rball1.simOneGame(.4,.6)
(6, 15)
Notice that when the probabilities are equal, the scores are close. When the probabilities are farther apart, the
game is a rout. That squares with how we think this function should behave.
We can continue this piecewise implementation, testing out each component as we add it into the code.
Software engineers call this process unit testing. Testing each function independently makes it easier to
spot errors. By the time you get around to testing the entire program, chances are that everything will work
smoothly.
Separating concerns through a modular design makes it possible to design sophisticated programs. Sep-
arating concerns through unit testing makes it possible to implement and debug sophisticated programs. Try
these techniques for yourself, and you'll see that you are getting your programs working with less overall
effort and far less frustration.
9.4.2 Simulation Results
Finally, we can take a look at Denny Dibblebit's question. Is it the nature of racquetball that small differences
in ability lead to large differences in the outcome? Suppose Denny wins about 60% of his serves and his
opponent is 5% better. How often should Denny win the game? Here's an example run where Denny's
opponent always serves first.
This program simulates a game of racquetball between two
players called "A" and "B". The abilities of each player is
indicated by a probability (a number between 0 and 1) that
the player wins the point when serving. Player A always150
CHAPTER 9. SIMULATION AND DESIGN
has the first serve.
What is the prob. player A wins a serve? .65
What is the prob. player B wins a serve? .6
How many games to simulate? 5000
Games simulated: 5000
Wins for A: 3360 (67.2%)
Wins for B: 1640 (32.8%)
Even though there is only a small difference in ability, Denny should win only about one in three games. His
chances of winning a three- or five-game match are pretty slim. Apparently Denny is winning his share. He
should skip the shrink and work harder on his game.
Speaking of matches, expanding this program to compute the probability of winning multi-game matches
would be a great exercise. Why don't you give it a try?
9.5 Other Design Techniques
Top-down design is a very powerful technique for program design, but it is not the only way to go about
creating a program. Sometimes you may get stuck at a step and not know how to go about refining it. Or the
original specification might be so complicated that refining it level-by-level is just too daunting.
9.5.1 Prototyping and Spiral Development
Another approach to design is to start with a simple version of a program or program component and then
try to gradually add features until it meets the full specification. The initial stripped-down version is called
a prototype. Prototyping often leads to a sort of spiral development process. Rather than taking the entire
problem and proceeding through specification, design, implementation and testing, we first design, implement
and test a prototype. Then new features are designed, implemented and tested. We make many mini-cycles
through the development process as the prototype is incrementally expanded into the final program.
As an example, consider how we might have approached the racquetball simulation. The very essence of
the problem is simulating a game of racquetball. We might have started with just the simOneGame function.
Simplifying even further, our prototype could assume that each player has a 50-50 chance of winning any
given point and just play a series of 30 rallies. That leaves the crux of the problem, which is handling the
awarding of points and change of service. Here is an example prototype:
from random import random
def simOneGame():
scoreA = 0
scoreB = 0
serving = "A"
for i in range(30):
if serving == "A":
if random() < .5:
scoreA = scoreA + 1
else:
serving = "B"
else:
if random() < .5:
scoreB = scoreB + 1
else:
serving = "A"
print scoreA, scoreB9.5. OTHER DESIGN TECHNIQUES
151
if __name__ == %!)__main__&)$: simOneGame()
You can see that I have added a print statement at the bottom of the loop. Printing out the scores as we go
along allows us to see that the prototype is playing a game. Here is some example output.
1 0
1 0
1 0
2 0
2 0
2 1
2 1
3 1
3 1
3 1
3 1
3 2
...
7 6
7 7
7 8
It's is not pretty, but it shows that we have gotten the scoring and change of service working.
We could then work on augmenting the program in phases. Here's a project plan.
Phase 1 Initial prototype. Play 30 rallies where the server always has a 50% chance of winning. Print out
the scores after each rally.
Phase 2 Add two parameters to represent different probabilities for the two players.
Phase 3 Play the game until one of the players reaches 15 points. At this point, we have a working simulation
of a single game.
Phase 4 Expand to play multiple games. The output is the count of games won by each player.
Phase 5 Build the complete program. Add interactive inputs and a nicely formatted report of the results.
Spiral development is particularly useful when dealing with new or unfamiliar features or technologies.
It's helpful to +"$get your hands dirty%%- with a quick prototype just to see what you can do. As a novice
programmer, everything may seem new to you, so prototyping might prove useful. If full-blown top-down
design does not seem to be working for you, try some spiral development.
9.5.2 The Art of Design
It is important to note that spiral development is not an alternative to top-down design. Rather, they are com-
plementary approaches. When designing the prototype, you will still use top-down techniques. In Chapter 12,
you will see yet another approach called object-oriented design.
There is no -$,one true way,+, of design. The truth is that good design is as much a creative process as a
science. Designs can be meticulously analyzed after the fact, but there are no hard and fast rules for producing
a design. The best software designers seem to employ a variety of techniques. You can learn about techniques
by reading books like this one, but books can't teach how and when to apply them. That you have to learn for
yourself through experience. In design as in almost anything, the key to success is practice.CHAPTER 9. SIMULATION AND DESIGN
152
9.6 Exercises
1. Draw the top levels of a structure chart for a program having the following main function.
def main():
printIntro()
length, width = getDimensions()
amtNeeded = computeAmount(length,width)
printReport(length, width, amtNeeded)
2. Write an expression using either random or randrange to calculate the following.
A random int in the range 0-/'10
A random float in the range -0.5"&&0.5
A random number representing the roll of a six-sided die
A random number representing the sum resulting from rolling two six-sided dice
A random float in the range -10.0')!10.0
3. Revise the racquetball simulation so that it keeps track of results for best of n game matches.
4. Revise the racquetball simulation to take shutouts into account. Your updated version should report for
both players the number of wins, percentage of wins, number of shutouts, and percentage of wins that
are shutouts.
5. Design and implement a simulation of the game of volleyball. Normal volleyball is played like rac-
quetball, in that a team can only score points when it is serving. Games are played to 15, but must be
won by at least two points.
6. College volleyball is now played using rally scoring. In this system, the team that wins a rally is
awarded a point, even if they were not the serving team. Games are played to a score of 21. Design
and implement a simulation of volleyball using rally scoring.
7. Design and implement a system that compares regular volleyball games to those using rally scoring.
Your program should be able to investigate whether rally scoring magnifies, reduces, or has no effect
on the relative advantage enjoyed by the better team.
8. Design and implement a simulation of some other racquet sport (e.g. tennis or table tennis).
9. Craps is a dice game played at many casinos. A player rolls a pair of normal six-sided dice. If the
initial roll is 2, 3 or 12, the player loses. If the roll is 7 or 11, the player wins. Any other initial roll
causes the player to "&'roll for point.%+' That is, the player keeps rolling the dice until either rolling a 7 or
re-rolling the value of the initial roll. If the player re-rolls the initial value before rolling a 7, it's a win.
Rolling a 7 first is a loss.
Write a program to simulate multiple games of craps and estimate the probability that the player wins.
For example, if the player wins 249 out of 500 games, then the estimated probability of winning is
249 500 0 498
10. Blackjack (twenty-one) is a casino game played with cards. The goal of the game to draw cards that
total as close to 21 points as possible without going over. All face cards count as 10 points, aces count
as 1 or 11, and all other cards count their numeric value.
The game is played against a dealer. The player tries to get closer to 21 (without going over) than
the dealer. If the dealer busts (goes over 21) the player automatically wins (provided the player had
not already busted). The dealer must always take cards according to a fixed set of rules. The dealer
takes cards until he or she achieves a total of at least 17. If the dealer's hand contains an ace, it will be
counted as 11 when that results in a total between 17 and 21 inclusive; otherwise, the ace is counted as
1.9.6. EXERCISES
153
Write a program that simulates multiple games of blackjack and estimates the probability that the dealer
will bust.
11. A blackjack dealer always starts with one card showing. It would be useful for a player to know the
dealer's bust probability (see previous problem) for each possible starting value. Write a simulation
program that runs multiple hands of blackjack for each possible starting value (ace%!(10) and estimates
the probability that the dealer busts for each starting value.
12. Monte Carlo techniques can be used to estimate the value of pi. Suppose you have a round dart board
that just fits inside of a square cabinet. If you throw darts randomly, the proportion that hit the dart
board vs. those that hit the cabinet (in the corners not covered by the board) will be determined by the
relative area of the dart board and the cabinet. If n is the total number of darts randomly thrown (that
land within the confines of the cabinet), and h is the number that hit the board, it is easy to show that
)#
4
h
n
Write a program that accepts the !$(number of darts%"% as an input and then performs a simulation to
estimate !- . Hint: you can use 2*random() - 1 to generate the x and y coordinates of a random
point inside a 2x2 square centered at 0 (+* 0 . The point lies inside the inscribed circle if x 2 y 2 1.
13. Write a program that performs a simulation to estimate the probability of rolling five-of-a-kind in a
single roll of five six-sided dice.
14. A random walk is a particular kind of probablistic simulation that models certain statistical systems
such as the Brownian motion of molecules. You can think of a one-dimensional random walk in terms
of coin flipping. Suppose you are standing on a very long straight sidewalk that extends both in front
of and behind you. You flip a coin. If it comes up heads, you take a step forward; tails means to take a
step backward.
Suppose you take a random walk of n steps. On average, how many steps away from the starting point
will you end up? Write a program to help you investigate this question.
15. Suppose you are doing a random walk (see previous problem) on the blocks of a city street. At each
,#!step-(- you choose to walk one block (at random) either forward, backward, left or right. In n steps,
how far do you expect to be from your starting point? Write a program to help answer this question.
16. Write a graphical program to trace a random walk (see previous two problems) in two dimensions.
In this simulation you should allow the step to be taken in any direction. You can generate a random
direction as an angle off of the x axis.
angle = random() * 2 * math.pi
The new x and y positions are then given by these formulas.
x = x + cos(angle)
y = y + sin(angle)
The program should take the number of steps as an input. Start your walker at the center of a 100x100
grid and draw a line that traces the walk as it progresses.
17. (Advanced) Here is a puzzle problem that can be solved with either some fancy analytic geometry
(calculus) or a (relatively) simple simulation.
Suppose you are located at the exact center of a cube. If you could look all around you in every
direction, each wall of the cube would occupy 6 1 of your field of vision. Suppose you move toward one
of the walls so that you are now half-way between it and the center of the cube. What fraction of your
field of vision is now taken up by the closest wall? Hint: use a Monte Carlo simulation that repeatedly
,(.looks-.% in a random direction and counts how many times it sees the wall.154
CHAPTER 9. SIMULATION AND DESIGNChapter 10
Defining Classes
In the last three chapters, we have developed techniques for structuring the computations of a program. In
the next few chapters, we will take a look at techniques for structuring the data that our programs use. You
already know that objects are one important tool for managing complex data. So far, our programs have made
use of objects created from pre-defined classes such as Circle. In this chapter, you will learn how to write
your own classes so that you can create novel objects.
10.1 Quick Review of Objects
Remember back in Chapter 5, I defined an object as an active data type that knows stuff and can do stuff.
More precisely, an object consists of
1. A collection of related information.
2. A set of operations to manipulate that information.
The information is stored inside the object in instance variables. The operations, called methods, are func-
tions that )!$live.!+ inside the object. Collectively, the instance variables and methods are called the attributes of
an object.
To take a now familiar example, a Circle object will have instance variables such as center, which
remembers the center point of the circle, and radius, which stores the length of the circle's radius. The
methods of the circle will need this data to perform actions. The draw method examines the center and
radius to decide which pixels in a window should be colored. The move method will change the value of
center to reflect the new position of the circle.
Recall that every object is said to be an instance of some class. The class of the object determines what
attributes the object will have. Basically a class is a description of what its instances will know and do. New
objects are created from a class by invoking a constructor. You can think of the class itself as a sort of factory
for stamping out new instances.
Consider making a new circle object:
myCircle = Circle(Point(0,0), 20)
Circle, the name of the class, is used to invoke the constructor. This statement creates a new Circle
instance and stores a reference to it in the variable myCircle. The parameters to the constructor are used
to initialize some of the instance variables (namely center and radius) inside of myCircle. Once the
instance has been created, it is manipulated by calling on its methods:
myCircle.draw(win)
myCircle.move(dx, dy)
...
155CHAPTER 10. DEFINING CLASSES
156
10.2 Example Program: Cannonball
Before launching into a detailed discussion of how to write your own classes, let's take a short detour to see
how useful new classes can be.
10.2.1 Program Specification
Suppose we want to write a program that simulates the flight of a cannonball (or any other projectile such as
a bullet, baseball or shot put). We are particularly interested in finding out how far the cannonball will travel
when fired at various launch angles and initial velocities. The input to the program will be the launch angle
(in degrees), the initial velocity (in meters per second) and the initial height (in meters). The output will be
the distance that the projectile travels before striking the ground (in meters).
If we ignore the effects of wind resistance and assume that the cannon ball stays close to earth's surface
(i.e., we're not trying to put it into orbit), this is a relatively simple classical physics problem. The acceleration
of gravity near the earth's surface is about 9.8 meters per second per second. That means if an object is thrown
upward at a speed of 20 meters per second, after one second has passed, its upward speed will have slowed to
20 9 8 10 2 meters per second. After another second, the speed will be only 0 4 meters per second, and
shortly thereafter it will start coming back down.
For those who know a little bit of calculus, it's not hard to derive a formula that gives the position of our
cannonball at any given moment in its flight. Rather than take the calculus approach, however, our program
will use simulation to track the cannonball moment by moment. Using just a bit of simple trigonometry to
get started, along with the obvious relationship that the distance an object travels in a given amount of time
is equal to its rate times the amount of time (d rt), we can solve this problem algorithmically.
10.2.2 Designing the Program
Let's start by desigining an algorithm for this problem. Given the problem statement, it's clear that we need
to consider the flight of the cannonball in two dimensions: height, so we know when it hits the ground, and
distance, to keep track of how far it goes. We can think of the position of the cannonball as a point x .#+ y in a
2D graph where the value of y gives the height and the value of x gives the distance from the starting point.
Our simulation will have to update the position of the cannonball to account for its flight. Suppose the ball
starts at position 0 "*( 0 , and we want to check its position, say, every tenth of a second. In that interval, it will
have moved some distance upward (positive y) and some distance forward (positive x). The exact distance in
each dimension is determined by its velocity in that direction.
Separating out the x and y components of the velocity makes the problem easier. Since we are ignoring
wind resistance, the x velocity remains constant for the entire flight. However, the y velocity changes over
time due to the influence of gravity. In fact, the y velocity will start out being positive and then become
negative as the cannonball starts back down.
Given this analysis, it's pretty clear what our simulation will have to do. Here is a rough outline:
Input the simulation parameters: angle, velocity, height, interval.
Calculate the initial position of the cannonball: xpos, ypos
Calculate the initial velocities of the cannonball: xvel, yvel
While the cannonball is still flying:
update the values of xpos, ypos, and yvel for interval seconds
further into the flight
Output the distance traveled as xpos
Let's turn this into a program using stepwise refinement.
The first line of the algorithm is straightforward. We just need an appropriate sequence of input state-
ments. Here's a start:
def main():
angle = input("Enter the launch angle (in degrees): ")
vel = input("Enter the initial velocity (in meters/sec): ")10.2. EXAMPLE PROGRAM: CANNONBALL
157
h0 = input("Enter the initial height (in meters): ")
time = input("Enter the time interval between position calculations: ")
Calculating the initial position for the cannonball is also easy. It will start at distance 0 and height h0.
We just need a couple assignment statements.
xpos = 0.0
ypos = h0
Next we need to calculate the x and y components of the initial velocity. We'll need a little high-school
trigonometry. (See, they told you you'd use that some day.) If we consider the initial velocity as consisting of
some amount of change in y and and some amount of change in x, then these three components (velocity, x-
velocity and y-velocity) form a right triangle. Figure 10.1 illustrates the situation. If we know the magnitude
of the velocity and the launch angle (labeled theta, because the Greek letter *& is often used as the measure
of angles), we can easily calculate the magnitude of xvel by the equation xvel velocity costheta. A similar
formula (using sintheta) provides yvel.
ty
oci
l
e
v
theta
yvel = velocity * sin(theta)
xvel = velocity * cos(theta)
Figure 10.1: Finding the x and y components of velocity.
Even if you don't completely understand the trigonometry, the important thing is that we can translate
these formulas into Python code. There's still one subtle issue to consider. Our input angle is in degrees, and
the Python math library uses radian measures. We'll have to /(% convert our angle before applying the formulas.
angle
There are 2 ") radians in a circle (360 degrees); so theta   !$ 180
. These three formulas give us the code for
computing the initial velocities:
theta = math.pi * angle / 180.0
xvel = velocity * math.cos(theta)
yvel = velocity * math.sin(theta)
That brings us to the main loop in our program. We want to keep updating the position and velocity of
the cannonball until it reaches the ground. We can do this by examining the value of ypos.
while ypos >= 0.0:
I used   as the relationship so that we can start with the cannon ball on the ground (= 0) and still get the
loop going. The loop will quit as soon as the value of ypos dips just below 0, indicating the cannonball has
embedded itself slightly in the ground.
Now we arrive at the crux of the simulation. Each time we go through the loop, we want to update the
state of the cannonball to move it time seconds farther in its flight. Let's start by considering movement in
the horizontal direction. Since our specification says that we can ignore wind resistance, the horizontal speed
of the cannonball will remain constant and is given by the value of xvel.
As a concrete example, suppose the ball is traveling at 30 meters per second and is currently 50 meters
from the firing point. In another second, it will go 30 more meters and be 80 meters from the firing point. If
the interval is only 0.1 second (rather than a full second), then the cannonball will only fly another 0 !&$ 1 ."# 30 $&!(/!  3
meters and be at a distance of 53 meters. You can see that the new distance traveled is always given by time
* xvel. To update the horizontal position, we need just one statement.
xpos = xpos + time * xvelCHAPTER 10. DEFINING CLASSES
158
The situation for the vertical component is slightly more complicated, since gravity causes the y-velocity
to change over time. Each second, yvel must decrease by 9.8 meters per second, the acceleration of gravity.
In 0.1 seconds the velocity will decrease by 0 1 9 8
0 98 meters per second. The new velocity at the end
of the interval is calculated as
yvel1 = yvel - time * 9.8
To calculate how far the cannonball travels during this interval, we need to know its average vertical
velocity. Since the acceleration due to gravity is constant, the average velocity will just be the average of the
starting and ending velocities: (yvel+yvel1)/2.0. Multiplying this average velocity by the amount of
time in the interval gives us the change in height.
Here is the completed loop:
while yvel >= 0.0:
xpos = xpos + time * xvel
yvel1 = yvel - time * 9.8
ypos = ypos + time * (yvel + yvel1)/2.0
yvel = yvel1
Notice how the velocity at the end of the time interval is first stored in the temporary variable yvel1. This is
done to preserve the initial yvel so that the average velocity can be computed from the two values. Finally,
the value of yvel is assigned its value at the end of the loop. This represents the correct vertical velocity of
the cannonball at the end of the interval.
The last step of our program simply outputs the distance traveled. Adding this step gives us the complete
program.
# cball1.py
from math import pi, sin, cos
def main():
angle = input("Enter the launch angle (in degrees): ")
vel = input("Enter the initial velocity (in meters/sec): ")
h0 = input("Enter the initial height (in meters): ")
time = input("Enter the time interval between position calculations: ")
# convert angle to radians
theta = (angle * pi)/180.0
# set the intial position and velocities in x and y directions
xpos = 0
ypos = h0
xvel = vel * cos(theta)
yvel = vel * sin(theta)
# loop until the ball hits the ground
while ypos >= 0:
# calculate position and velocity in time seconds
xpos = xpos + time * xvel
yvel1 = yvel - time * 9.8
ypos = ypos + time * (yvel + yvel1)/2.0
yvel = yvel1
print "\nDistance traveled: %0.1f meters." % (xpos)10.3. DEFINING NEW CLASSES
159
10.2.3 Modularizing the Program
You may have noticed during the design discussion that I employed stepwise refinement (top-down design)
to develop the program, but I did not divide the program into separate functions. We are going to modularize
the program in two different ways. First, we'll use functions (a la top-down design).
While the final program is not too long, it is fairly complex for its length. One cause of the complexity is
that it uses ten variables, and that is a lot for the reader to keep track of. Let's try dividing the program into
functional pieces to see if that helps. Here's a version of the main algorithm using helper functions:
def main():
angle, vel, h0, time = getInputs()
xpos, ypos = 0, h0
xvel, yvel = getXYComponents(velocity, angle)
while ypos >= 0:
xpos, ypos, yvel = updateCannonBall(time, xpos, ypos, xvel, yvel)
print "\nDistance traveled: %0.1f meters." % (xpos)
It should be obvious what each of these functions does based on their names and the original program code.
You might take a couple of minutes to code up the three helper functions.
This second version of the main algorithm is certainly more concise. The number of variables has been
reduced to eight, since theta and yvel1 have been eliminated from the main algorithm. Do you see where
they went? The value of theta is only needed locally inside of getXYComponents. Similarly, yvel1 is
now local to updateCannonBall. Being able to hide some of the intermediate variables is a major benefit
of the separation of concerns provided by top-down design.
Even this version seems overly complicated. Look especially at the loop. Keeping track of the state of
the cannonball requires four pieces of information, three of which must change from moment to moment.
All four variables along with the value of time are needed to compute the new values of the three that
change. That results in an ugly function call having five parameters and three return values. An explosion of
parameters is often an indication that there might be a better way to organize a program. Let's try another
approach.
The original problem specification itself suggests a better way to look at the variables in our program.
There is a single real-world cannonball object, but describing it in the current program requires four pieces
of information: xpos, ypos, xvel and yvel. Suppose we had a Projectile class that +%(understood-*#
the physics of objects like cannonballs. Using such a class, we could express the main algorithm in terms
of creating and updating a suitable object stored in a single variable. Using this object-based approach, we
might write main like this.
def main():
angle, vel, h0, time = getInputs()
cball = Projectile(angle, vel, h0)
while cball.getY() >= 0:
cball.update(time)
print "\nDistance traveled: %0.1f meters." % (cball.getX())
Obviously, this is a much simpler and more direct expression of the algorithm. The initial values of
angle, vel and h0 are used as parameters to create a Projectile called cball. Each time through
the loop, cball is asked to update its state to account for time. We can get the position of cball at
any moment by using its getX and getY methods. To make this work, we just need to define a suitable
Projectile class that implements the methods update, getX, and getY.
10.3 Defining New Classes
Before designing a Projectile class, let's take an even simpler example to examine the basic ideas.CHAPTER 10. DEFINING CLASSES
160
10.3.1 Example: Multi-Sided Dice
You know that a normal die (the singular of dice) is a cube and each face shows a number from one to six.
Some games employ nonstandard dice that may have fewer (e.g., four) or more (e.g., thirteen) sides. Let's
design a general class MSDie to model multi-sided dice. 1 We could use such an object in any number of
simulation or game programs.
Each MSDie object will know two things.
1. How many sides it has.
2. Its current value.
When a new MSDie is created, we specify how many sides it will have, n. We can then operate on the
die through three provided methods: roll, to set the die to a random value between 1 and n, inclusive;
setValue, to set the die to a specific value (i.e., cheat); and getValue, to see what the current value is.
Here is an interactive example showing what our class will do:
>>>
>>>
1
>>>
>>>
4
>>>
>>>
1
>>>
>>>
12
>>>
>>>
8
die1 = MSDie(6)
die1.getValue()
die1.roll()
die1.getValue()
die2 = MSDie(13)
die2.getValue()
die2.roll()
die2.getValue()
die2.setValue(8)
die2.getValue()
Do you see how this might be useful? I can define any number of dice having arbitrary numbers of sides.
Each die can be rolled independently and will always produce a random value in the proper range determined
by the number of sides.
Using our object-oriented terminology, we create a die by invoking the MSDie constructor and providing
the number of sides as a parameter. Our die object will keep track of this number internally using an instance
variable. Another instance variable will be used to store the current value of the die. Initially, the value of
the die will be set to be 1, since that is a legal value for any die. The value can be changed by the roll and
setRoll methods and returned from the getValue method.
Writing a definition for the MSDie class is really quite simple. A class is a collection of methods, and
methods are just functions. Here is the class definition for MSDie:
# msdie.py
Class definition for an n-sided die.
#
from random import randrange
class MSDie:
def __init__(self, sides):
self.sides = sides
self.value = 1
1 Obviously, the name MSDie is short for !#$Multi-Sided Die/-" and is not intended as a comment on any software giant, real or fictional,
which may or may not employ unfair monopolostic trade practices to the detriment of consumers.10.3. DEFINING NEW CLASSES
161
def roll(self):
self.value = randrange(1,self.sides+1)
def getValue(self):
return self.value
def setValue(self, value):
self.value = value
As you can see, a class definition has a simple form:
class <class-name>:
<method-definitions>
Each method definition looks like a normal function definition. Placing the function inside a class makes it a
method of that class, rather than a stand-alone function.
Let's take a look at the three methods defined in this class. You'll notice that each method has a first
parameter named self. The first parameter of a method is special.%&it always contains a reference to the
object on which the method is acting. As usual, you can use any name you want for this parameter, but the
traditional name is self, so that is what I will always use.
An example might be helpful in making sense of self. Suppose we have a main function that executes
die1.setValue(8). A method invocation is a function call. Just as in normal function calls, Python
executes a four-step sequence:
1. The calling program (main) suspends at the point of the method application. Python locates the
approriate method defintion inside the class of the object to which the method is being applied. In this
case, control is transferring to the setValue method in the MSDie class, since die1 is an instance
of MSDie.
2. The formal parameters of the method get assigned the values supplied by the actual parameters of the
call. In the case of a method call, the first formal parameter corresponds to the object. In our example,
it is as if the following assignments are done before executing the method body:
self = die1
value = 8
3. The body of the method is executed.
4. Control returns to the point just after where the method was called, in this case, the statement immedi-
ately following die1.setValue(8).
Figure 10.2 illustrates the method-calling sequence for this example. Notice how the method is called with
one parameter (the value), but the method definition has two parameters, due to self. Generally speaking,
we would say setValue requires one parameter. The self parameter in the definition is a bookkeeping
detail. Some languages do this implicitly; Python requires us to add the extra parameter. To avoid confusion,
I will always refer to the first formal parameter of a method as the self parameter and any others as normal
parameters. So, I would say setValue uses one normal parameter.
class MSDie:
def main():
...
die1 = MSDie(12)
self=die1; value=8 def setValue(self,value):
die1.setValue(8)
self.value = value
print die1.getValue()
Figure 10.2: Flow of control in call: die1.setValue(8).CHAPTER 10. DEFINING CLASSES
162
OK, so self is a parameter that represents an object. But what exactly can we do with it? The main
thing to remember is that objects contain their own data. Instance variables provide storage locations inside
of an object. Just as with regular variables, instance variables are accessed by name. We can use our familiar
dot notation: object   . instance-var   . Look at the definition of setValue; self.value refers to
the instance variable value that is stored inside the object. Each instance of a class has its own instance
variables, so each MSDie object has its very own value.
Certain methods in a class have special meaning to Python. These methods have names that begin and
end with two underscores. The special method init is the object constructor. Python calls this method
to initialize a new MSDie. The role of init is to provide initial values for the instance variables of an
object.
From outside the class, the constructor is referred to by the class name.
die1 = MSDie(6)
When executing this statement, Python creates a new MSDie and executes init on that object. The net
result is that die1.sides is set to 6 and die1.value is set to 1.
The power of instance variables is that we can use them to remember the state of a particular object, and
this information then gets passed around the program as part of the object. The values of instance variables
can be referred to again in other methods or even in successive calls to the same method. This is different
from regular local function variables whose values disappear once the function terminates.
Here is a simple illustration:
>>>
>>>
1
>>>
>>>
8
die1 = Die(13)
print die1.getValue()
die1.setValue(8)
print die1.getValue()
The call to the constructor sets the instance variable die1.value to 1. The next line prints out this value.
The value set by the constructor persists as part of the object, even though the constructor is over and done
with. Similarly, executing die1.setValue(8) changes the object by setting its value to 8. When the
object is asked for its value the next time, it responds with 8.
That's just about all there is to know about defining new classes in Python. Now it's time to put this new
knowledge to use.
10.3.2 Example: The Projectile Class
Returning to the cannonball example, we want a class that can represent projectiles. This class will need a
contructor to initialize instance variables, an update method to change the state of the projectile, and getX
and getY methods so that we can find the current position.
Let's start with the constructor. In the main program, we will create a cannonball from the initial angle,
velocity and height.
cball = Projectile(angle, vel, h0)
The Projectile class must have an init method that uses these values to initialize the instance
variables of cball. But what should the instance variables be? Of course, they will be the four pieces of
information that characterize the flight of the cannonball: xpos, ypos, xvel and yvel. We will calculate
these values using the same formulas that were in the original program.
Here is how our class looks with the constructor:
class Projectile:
def __init__(self, angle, velocity, height):
self.xpos = 0.0
self.ypos = height10.3. DEFINING NEW CLASSES
163
theta = math.pi * angle / 180.0
self.xvel = velocity * math.cos(theta)
self.yvel = velocity * math.sin(theta)
Notice how we have created four instance variables inside the object using the self dot notation. The value
of theta is not needed after init terminates, so it is just a normal (local) function variable.
The methods for accessing the position of our projectiles are straightforward; the current position is given
by the instance variables xpos and ypos. We just need a couple methods that return these values.
def getX(self):
return self.xpos
def getY(self):
return self.ypos
Finally, we come to the update method. This method takes a single normal parameter that represents
an interval of time. We need to update the state of the projectile to account for the passage of that much time.
Here's the code:
def update(self, time):
self.xpos = self.xpos + time * self.xvel
yvel1 = self.yvel - time * 9.8
self.ypos = self.ypos + time * (self.yvel + yvel1)/2.0
self.yvel = yvel1
Basically, this is the same code that we used in the original program updated to use and modify instance
variables. Notice the use of yvel1 as a temporary (ordinary) variable. This new value is saved by storing it
into the object in the last line of the method.
That completes our projectile class. We now have a complete object-based solution to the cannonball
problem.
# cball3.py
from math import pi, sin, cos
class Projectile:
def __init__(self, angle, velocity, height):
self.xpos = 0.0
self.ypos = height
theta = pi * angle / 180.0
self.xvel = velocity * cos(theta)
self.yvel = velocity * sin(theta)
def update(self, time):
self.xpos = self.xpos + time * self.xvel
yvel1 = self.yvel - 9.8 * time
self.ypos = self.ypos + time * (self.yvel + yvel1) / 2.0
self.yvel = yvel1
def getY(self):
return self.ypos
def getX(self):
return self.xpos
def getInputs():CHAPTER 10. DEFINING CLASSES
164
a = input("Enter
v = input("Enter
h = input("Enter
t = input("Enter
return a,v,h,t
the
the
the
the
launch angle (in degrees): ")
initial velocity (in meters/sec): ")
initial height (in meters): ")
time interval between position calculations: ")
def main():
angle, vel, h0, time = getInputs()
cball = Projectile(angle, vel, h0)
while cball.getY() >= 0:
cball.update(time)
print "\nDistance traveled: %0.1f meters." % (cball.getX())
10.4 Objects and Encapsulation
10.4.1 Encapsulating Useful Abstractions
Hopefully, you can see how defining new classes can be a good way to modularize a program. Once we
identify some objects that might be useful in solving a particular problem, we can write an algorithm as if we
had those objects available and push the implementation details into a suitable class definition. This gives us
the same kind of separation of concerns that we had using functions in top-down design. The main program
only has to worry about what objects can do, not about how they are implemented.
Computer scientists call this separation of concerns encapsulation. The implementation details of an
object are encapsulated in the class defintion, which insulates the rest of the program from having to deal
with them. This is another application of abstraction (ignoring irrelevant details), which is the essence of
good design.
I should mention that encapsulation is only a programming convention in Python. It is not enforced by the
language, per se. In our Projectile class we included two short methods, getX and getY, that simply
returned the values of instance variables xpos and ypos, respectively. Strictly speaking, these methods are
not absolutely necessary. In Python, you can access the instance variables of any object with the regular dot
notation. For example, we could test the constructor for the Projectile class interactively by creating an
object and then directly inspecting the values of the instance variables.
>>> c = Projectile(60, 50, 20)
>>> c.xpos
0.0
>>> c.ypos
20
>>> c.xvel
25.0
>>> c.yvel
43.301270
Accessing the instance variables of an object like this is very handy for testing purposes, but it is generally
considered poor practice to this in programs. One of the main reasons for using objects is to insulate programs
that use those objects from the internal details of how they are implemented. References to instance variables
should remain inside the class definition with the rest of the implementation details. From outside the class,
our interaction with an object should take place using the interface provided by its methods. As you design
classes of your own, you should strive to provide a complete set of methods to make your class useful. That
way other programs do not need to know about or manipulate internal details like instance variables.
10.4.2 Putting Classes in Modules
Often a well-defined class or set of classes provide(s) useful abstractions that can be leveraged in many
different programs. We might want to turn our projectile class into its own module file so that it can be used10.4. OBJECTS AND ENCAPSULATION
165
in other programs. In doing so, it would be a good idea to add documentation that describes how the class
can be used so that programmers who want to use the module don't have to study the code to figure out (or
remember) what the class and its methods do.
You are already familiar with one way of documenting programs, namely comments. It's always a good
idea to provide comments explaining the contents of a module and its uses. In fact, comments of this sort
are so important that Python incorporates a special kind of commenting convention called a docstring. You
can insert a plain string literal as the first line of a module, class or function to document that component.
The advantage of docstrings is that, while ordinary comments are simply ignored by Python, docstrings are
actually carried along during execution in a special attribute called doc . These strings can be examined
dynamically.
Most of the Python library modules have extensive docstrings that you can use to get help on using the
module or its contents. For example, if you can't remember how to use the randrange function, you can
print its docstring like this:
>>> import random
>>> print random.randrange.__doc__
Choose a random item from range(start, stop[, step]).
Here is a version of our Projectile class as a module file with docstrings included:
# projectile.py
"""projectile.py
Provides a simple class for modeling the flight of projectiles."""
from math import pi, sin, cos
class Projectile:
"""Simulates the flight of simple projectiles near the earth's
surface, ignoring wind resistance. Tracking is done in two
dimensions, height (y) and distance (x)."""
def __init__(self, angle, velocity, height):
"""Create a projectile with given launch angle, initial
velocity and height."""
self.xpos = 0.0
self.ypos = height
theta = pi * angle / 180.0
self.xvel = velocity * cos(theta)
self.yvel = velocity * sin(theta)
def update(self, time):
"""Update the state of this projectile to move it time seconds
farther into its flight"""
self.xpos = self.xpos + time * self.xvel
yvel1 = self.yvel - 9.8 * time
self.ypos = self.ypos + time * (self.yvel + yvel1) / 2.0
self.yvel = yvel1
def getY(self):
"Returns the y position (height) of this projectile."
return self.ypos
def getX(self):CHAPTER 10. DEFINING CLASSES
166
"Returns the x position (distance) of this projectile."
return self.xpos
You might notice that many of the docstrings in this code are enclosed in triple quotes ('%.+%$&#,). This is a
third way that Python allows string literals to be delimited. Triple quoting allows us to directly type multi-line
strings. Here is an example of how the docstrings appear when they are printed.
>>> print projectile.Projectile.__doc__
Simulates the flight of simple projectiles near the earth's
surface, ignoring wind resistance. Tracking is done in two
dimensions, height (y) and distance (x).
Our main program could now simply import this module in order to solve the original problem.
# cball4.py
from projectile import Projectile
def getInputs():
a = input("Enter
v = input("Enter
h = input("Enter
t = input("Enter
return a,v,h,t
the
the
the
the
launch angle (in degrees): ")
initial velocity (in meters/sec): ")
initial height (in meters): ")
time interval between position calculations: ")
def main():
angle, vel, h0, time = getInputs()
cball = Projectile(angle, vel, h0)
while cball.getY() >= 0:
cball.update(time)
print "\nDistance traveled: %0.1f meters." % (cball.getX())
In this version, details of projectile motion are now hidden in the projectile module file.
10.5 Widget Objects
One very common use of objects is in the design of graphical user interfaces (GUIs). Back in Chapter 5, we
talked about GUIs being composed of visual interface objects called widgets. The Entry object defined in
our graphics library is one example of a widget. Now that we know how to define new classes, we can
create our own custom widgets.
10.5.1 Example Program: Dice Roller
Let's try our hand at building a couple useful widgets. As an example application, consider a program that
rolls a pair of standard (six-sided) dice. The program will display the dice graphically and provide two
buttons, one for rolling the dice and one for quitting the program. Figure 10.3 shows a snapshot of the user
interface.
You can see that this program has two kinds of widgets: buttons and dice. We can start by developing
suitable classes. The two buttons will be instances of a Button class, and the class that provides a graphical
view of the value of a die will be DieView.
10.5.2 Building Buttons
Buttons, of course, are standard elements of virtually every GUI these days. Modern buttons are very so-
phisticated, usually having a 3-dimensional look and feel. Our simple graphics package does not have the
machinery to produce buttons that appear to depress as they are clicked. The best we can do is find out where10.5. WIDGET OBJECTS
167
Figure 10.3: Snapshot of dice roller in action.
the mouse was clicked after the click has already completed. Nevertheless, we can make a useful, if less
pretty, button class.
Our buttons will be rectangular regions in a graphics window where user clicks can influence the behavior
of the running application. We will need to create buttons and determine when they have been clicked. In
addition, it is also nice to be able to activate and deactivate individual buttons. That way, our applications can
signal which options are available to the user at any given moment. Typically, an inactive button is grayed-out
to show that it is not available.
Summarizing this description, our buttons will support the following methods:
constructor Create a button in a window. We will have to specify the window in which the button will be
displayed, the location/size of the button, and the label that will be on the button.
activate Set the state of the button to active.
deactivate Set the state of the button to inactive.
clicked Indicate if the button was clicked. If the button is active, this method will determine if the point
clicked is inside the button region. The point will have to be sent as a parameter to the method.
getLabel Returns the label string of the button. This is provided so that we can identify a particular button.
In order to support these operations, our buttons will need a number of instance variables. For example,
the button itself will be drawn as a rectangle with some text centered in it. Invoking the activate and
deactivate methods will change the appearance of the button. Saving the Rectangle and Text objects
as instance variables will allow us to change the width of the outline and the color of the label. We might
start by implementing the various methods to see what other instance variables might be needed. Once we
have identified the relevant variables, we can write a constructor that initializes these values.
Let's start with the activate method. We can signal that the button is active by making the outline
thicker and making the label text black. Here is the code (remember the self parameter refers to the button
object):
def activate(self):
"Sets this button to (&"active!&(."
self.label.setFill(!($black!&-)
self.rect.setWidth(2)
self.active = 1CHAPTER 10. DEFINING CLASSES
168
As I mentioned above, in order for this code to work, our constructor will have to initialize self.label
as an approprate Text object and self.rect as a Rectangle object. In addition, the self.active
instance variable stores a Boolean value (1 for true, 0 for false) to remember whether or not the button is
currently active.
Our deactivate method will do the inverse of activate. It looks like this:
def deactivate(self):
"Sets this button to #-!inactive-,%."
self.label.setFill(."!darkgrey%(%)
self.rect.setWidth(1)
self.active = 0
Of course, the main point of a button is being able to determine if it has been clicked. Let's try to write
the clicked method. As you know, the graphics package provides a getMouse method that returns
the point where the mouse was clicked. If an application needs to get a button click, it will first have to call
getMouse and then see which active button (if any) the point is inside of. We could imagine the button
processing code looking something like the following:
pt = win.getMouse()
if button1.clicked(pt):
# Do button1 stuff
elif button2.clicked(pt):
# Do button2 stuff
elif button2.clicked(pt)
# Do button3 stuff
...
The main job of the clicked method is to determine whether a given point is inside the rectangular
button. The point is inside the rectangle if its x and y coordinates lie between the extreme x and y values
of the rectangle. This would be easiest to figure out if we just assume that the button object has instance
variables that record the min and max values of x and y.
Assuming the existence of instance variables xmin, xmax, ymin, and ymax, we can implement the
clicked method with a single Boolean expression.
def clicked(self, p):
"RETURNS true if button is active and p is inside"
return self.active and \
self.xmin <= p.getX() <= self.xmax and \
self.ymin <= p.getY() <= self.ymax
Here we have a single large Boolean expression composed by anding together three simpler expressions; all
three must be true for the function to return a true value. Recall that the backslash at the end of a line is used
to extend a statement over multiple lines.
The first of the three subexpressions simply retrieves the value of the instance variable self.active.
This ensures that only active buttons will report that they have been clicked. If self.active is false, then
clicked will return false. The second two subexpressions are compound conditions to check that the x and
y values of the point fall between the edges of the button rectangle. (Remember, x <= y <= z means the
same as the mathematical expression x y z (section 7.5.1)).
Now that we have the basic operations of the button ironed out, we just need a constructor to get all the
instance variables properly initialized. It's not hard, but it is a bit tedious. Here is the complete class with a
suitable constructor.
# button.py
from graphics import *
class Button:10.5. WIDGET OBJECTS
169
"""A button is a labeled rectangle in a window.
It is activated or deactivated with the activate()
and deactivate() methods. The clicked(p) method
returns true if the button is active and p is inside it."""
def __init__(self, win, center, width, height, label):
""" Creates a rectangular button, eg:
qb = Button(myWin, Point(30,25), 20, 10, *#)Quit-/$) """
w,h = width/2.0, height/2.0
x,y = center.getX(), center.getY()
self.xmax, self.xmin = x+w, x-w
self.ymax, self.ymin = y+h, y-h
p1 = Point(self.xmin, self.ymin)
p2 = Point(self.xmax, self.ymax)
self.rect = Rectangle(p1,p2)
self.rect.setFill(!(!lightgray)(&)
self.rect.draw(win)
self.label = Text(center, label)
self.label.draw(win)
self.deactivate()
def clicked(self, p):
"RETURNS true if button active and p is inside"
return self.active and \
self.xmin <= p.getX() <= self.xmax and \
self.ymin <= p.getY() <= self.ymax
def getLabel(self):
"RETURNS the label string of this button."
return self.label.getText()
def activate(self):
"Sets this button to )/.active,/+."
self.label.setFill(")(black)'$)
self.rect.setWidth(2)
self.active = 1
def deactivate(self):
"Sets this button to -,,inactive-($."
self.label.setFill("".darkgrey*&-)
self.rect.setWidth(1)
self.active = 0
You should study the constructor in this class to make sure you understand all of the instance variables
and how they are initialized. A button is positioned by providing a center point, width and height. Other
instance variables are calculated from these parameters.
10.5.3 Building Dice
Now we'll turn our attention to the DieView class. The purpose of this class is to display the value of a die
in a graphical fashion. The face of the die will be a square (via Rectangle) and the pips will be circles.
Our DieView will have the following interface:
constructor Create a die in a window. We will have to specify the window, the center point of the die, andCHAPTER 10. DEFINING CLASSES
170
the size of the die as parameters.
setValue Change the view to show a given value. The value to display will be passed as a parameter.
Obviously, the heart of DieView is turning various pips %&,on&'$ and +/+off!+" to indicate the current value of
the die. One simple approach is to pre-place circles in all the possible locations where a pip might be and
then turn them on or off by changing their colors.
Using the standard position of pips on a die, we will need seven circles: three down the left edge, three
down the right edge, and one in the center. The constructor will create the background square and the seven
circles. The setValue method will set the colors of the circles based on the value of the die.
Without further ado, here is the code for our DieView class. The comments will help you to follow how
it works.
class DieView:
""" DieView is a widget that displays a graphical representation
of a standard six-sided die."""
def __init__(self, win, center, size):
"""Create a view of a die, e.g.:
d1 = GDie(myWin, Point(40,50), 20)
creates a die centered at (40,50) having sides
of length 20."""
# first define some standard values
self.win = win
# save this for drawing pips later
self.background = "white" # color of die face
self.foreground = "black" # color of the pips
self.psize = 0.1 * size
# radius of each pip
hsize = size / 2.0
# half the size of the die
offset = 0.6 * hsize
# distance from center to outer pips
# create a square for the face
cx, cy = center.getX(), center.getY()
p1 = Point(cx-hsize, cy-hsize)
p2 = Point(cx+hsize, cy+hsize)
rect = Rectangle(p1,p2)
rect.draw(win)
rect.setFill(self.background)
# Create 7 circles for standard pip locations
self.pip1 = self.__makePip(cx-offset, cy-offset)
self.pip2 = self.__makePip(cx-offset, cy)
self.pip3 = self.__makePip(cx-offset, cy+offset)
self.pip4 = self.__makePip(cx, cy)
self.pip5 = self.__makePip(cx+offset, cy-offset)
self.pip6 = self.__makePip(cx+offset, cy)
self.pip7 = self.__makePip(cx+offset, cy+offset)
# Draw an initial value
self.setValue(1)
def __makePip(self, x, y):
"Internal helper method to draw a pip at (x,y)"
pip = Circle(Point(x,y), self.psize)
pip.setFill(self.background)10.5. WIDGET OBJECTS
171
pip.setOutline(self.background)
pip.draw(self.win)
return pip
def setValue(self, value):
"Set this die to display value."
# turn all pips off
self.pip1.setFill(self.background)
self.pip2.setFill(self.background)
self.pip3.setFill(self.background)
self.pip4.setFill(self.background)
self.pip5.setFill(self.background)
self.pip6.setFill(self.background)
self.pip7.setFill(self.background)
# turn correct pips on
if value == 1:
self.pip4.setFill(self.foreground)
elif value == 2:
self.pip1.setFill(self.foreground)
self.pip7.setFill(self.foreground)
elif value == 3:
self.pip1.setFill(self.foreground)
self.pip7.setFill(self.foreground)
self.pip4.setFill(self.foreground)
elif value == 4:
self.pip1.setFill(self.foreground)
self.pip3.setFill(self.foreground)
self.pip5.setFill(self.foreground)
self.pip7.setFill(self.foreground)
elif value == 5:
self.pip1.setFill(self.foreground)
self.pip3.setFill(self.foreground)
self.pip4.setFill(self.foreground)
self.pip5.setFill(self.foreground)
self.pip7.setFill(self.foreground)
else:
self.pip1.setFill(self.foreground)
self.pip2.setFill(self.foreground)
self.pip3.setFill(self.foreground)
self.pip5.setFill(self.foreground)
self.pip6.setFill(self.foreground)
self.pip7.setFill(self.foreground)
There are a couple of things worth noticing in this code. First, in the constructor, I have defined a set of
values that determine various aspects of the die such as its color and the size of the pips. Calculating these
values in the constructor and then using them in other places allows us to easily tweak the appearance of the
die without having to search through the code to find all the places where those values are used. I actually
figured out the specific calculations (such as the pip size being one-tenth of the die size) through a process of
trial and error.
Another important thing to notice is that I have added an extra method makePip that was not part
of the original specification. This method is just a helper function that executes the four lines of code nec-
essary to draw each of the seven pips. Since this is a function that is only useful within the DieView
class, it is appropriate to make it a class method. Inside the constructor, it is invoked by lines such as:
self. makePip(cx, cy). Method names beginning with a single or double underscore are used inCHAPTER 10. DEFINING CLASSES
172
Python to indicate that a method is +$#private#,) to the class and not intended for use by outside programs.
10.5.4 The Main Program
Now we are ready to write our main program. The Button and Dieview classes are imported from their
respective modules. Here is the program that uses our new widgets.
# roller.py
# Graphics program to roll a pair of dice. Uses custom widgets
# Button and DieView.
from random import randrange
from graphics import GraphWin, Point
from button import Button
from dieview import DieView
def main():
# create the application window
win = GraphWin("Dice Roller")
win.setCoords(0, 0, 10, 10)
win.setBackground("green2")
# Draw the interface widgets
die1 = DieView(win, Point(3,7), 2)
die2 = DieView(win, Point(7,7), 2)
rollButton = Button(win, Point(5,4.5), 6, 1, "Roll Dice")
rollButton.activate()
quitButton = Button(win, Point(5,1), 2, 1, "Quit")
# Event loop
pt = win.getMouse()
while not quitButton.clicked(pt):
if rollButton.clicked(pt):
value1 = randrange(1,7)
die1.setValue(value1)
value2 = randrange(1,7)
die2.setValue(value2)
quitButton.activate()
pt = win.getMouse()
# close up shop
win.close()
Notice that near the top of the program I have built the visual interface by creating the two DieViews
and two Buttons. To demonstrate the activation feature of buttons, the roll button is initially active, but the
quit button is left deactivated. The quit button is activated inside the event loop below when the roll button is
clicked. This approach forces the user to roll the dice at least once before quitting.
The heart of the program is the event loop. It is just a sentinel loop that gets mouse clicks and processes
them until the user successfully clicks the quit button. The if inside the loop ensures that the rolling of the
dice only happens when the roll button is clicked. Clicking a point that is not inside either button causes the
loop to iterate, but nothing is actually done.10.6. EXERCISES
173
10.6 Exercises
1. Explain the similarities and differences between instance variables and -)%regular)&% function variables.
2. Show the output that would result from the following nonsense program.
class Bozo:
def __init__(self, value):
print "Creating a Bozo from:", value
self.value = 2 * value
def clown(self, x):
print "Clowning:", x
print x * self.value
return x + self.value
def main():
print "Clowning around now."
c1 = Bozo(3)
c2 = Bozo(4)
print c1.clown(3)
print c2.clown(c1.clown(2))
main()
3. Use the Button class discussed in this chapter to build a GUI for one (or more) of your projects from
previous chapters.
4. Write a modified Button class that creates circular buttons.
5. Write a shell game program using several different shapes of buttons. The program should draw at
least three shapes on the screen and -.&pick#), one of them at random. The user tries to guess which of the
shapes is the special one (by clicking in it). The user wins if he/she picks the right one.
6. Write a set of classes corresponding to the geometric solids: cube, rectangular prism (brick), sphere
and cylinder. Each class should have a constructor that allows for the creation of different sized objects
(e.g., a cube is specified by the length of its side) and methods that return the surface area and volume
of the solid.
7. Extend the previous problem to include a method, inside, that determines whether a particular point
lies within the solid. The method should accept three numbers representing the x, y and z coordinates
of a point and return true if the point is inside the object and false otherwise. You may assume that the
objects are always centered at 0 /%) 0 ,*/ 0 .
8. Here is a simple class that draws a (grim) face in a graphics window.
# face.py
from graphics import *
class Face:
def __init__(self, window, center, size):
eyeSize = 0.15 * size
eyeOff = size / 3.0
mouthSize = 0.8 * sizeCHAPTER 10. DEFINING CLASSES
174
mouthOff = size / 2.0
self.head = Circle(center, size)
self.head.draw(window)
self.leftEye = Circle(center, eyeSize)
self.leftEye.move(-eyeOff, -eyeOff)
self.rightEye = Circle(center, eyeSize)
self.rightEye.move(eyeOff, -eyeOff)
self.leftEye.draw(window)
self.rightEye.draw(window)
p1 = center.clone()
p1.move(-mouthSize/2, mouthOff)
p2 = center.clone()
p2.move(mouthSize/2, mouthOff)
self.mouth = Line(p1,p2)
self.mouth.draw(window)
(a) Use this class to write a program that draws three faces in a window.
(b) Add and test a move method so that faces can be moved like other graphics objects.
(c) Add and test a flinch method that causes a face's eyes to close. Also add and test an unflinch
to open them back up again.
(d) Write a complete program that draws a single face in a window and then animates it '&.bouncing
around."-" Start the face at a random location in the window and use a loop that moves it a small
increment in the x and y directions. When the face hits the edge of the window, it should flinch
and bounce off. You can do the bounce by simply reversing the sign of the x increment or the y
increment depending on whether the face hit a side- or top-/bottom-edge respectively. Write the
animation program to run for a certain (fixed) number of steps.
Note: You will need to flush the graphics window at the bottom of the loop to achieve the effect
of animation.
9. Create a Tracker class that displays a circle in a graphics window to show the current location of an
object. Here is a quick specification of the class:
class Tracker:
def __init__(self, window, objToTrack):
# window is a graphWin and objToTrack is an object whose
#
position is to be shown in the window. objToTrack must be
#
an object that has getX() and getY() methods that report its
#
current position.
# Creates a Tracker object and draws a circle in window at the
#
current position of objToTrack.
def update():
# Moves the circle in the window to the current position of the
#
object being tracked.
Use your new Tracker class in conjunction with the Projectile class to write a program that
graphically depicts the flight of a cannonball.
10. Add a Target class to the cannonball program from the previous problem. A target should be a
rectangle placed at a random position in the window. Allow the user to keep firing until they hit the
target.10.6. EXERCISES
175
11. Redo the regression problem from Chapter 8 using a Regression class. Your new class will keep
track of the various quantities that are needed to compute a line of regresion (the running sums of x, y,
x 2 and xy)The regression class should have the following methods.
init
Creates a new regression object to which points can be added.
addPoint Adds a point to the regression object.
predict Accepts a value of x as a parameter, and returns the value of the corresponding y on the line
of best fit.
Note: Your class might also use some internal helper methods to do such things as compute the slope
of the regression line.
12. Implement a card class that represents a playing card. Use your class to write a program that $)%deals&#"
a random hand of cards and displays them in a graphics window. You should be able to find a freely
available set of card images to display your cards by searching on the Internet.176
CHAPTER 10. DEFINING CLASSESChapter 11
Data Collections
As you saw in the last chapter, classes are one mechanism for structuring the data in our programs. Classes
alone, however, are not enough to satisfy all of our data-handling needs.
If you think about the kinds of data that most real-world programs manipulate, you will quickly realize
that many programs deal with large collections of similar information. A few examples of the collections that
you might find in a modern program include
Words in a document.
Students in a course.
Data from an experiment.
Customers of a business.
Graphics objects drawn on the screen.
Cards in a deck.
In this chapter, you will learn techniques for writing programs that manipulate collections like these.
11.1 Example Problem: Simple Statistics
Back in Chapter 8, we wrote a simple but useful program to compute the mean (average) of a set of numbers
entered by the user. Just to refresh your memory (as if you could forget it), here is the program again:
# average4.py
def main():
sum = 0.0
count = 0
xStr = raw_input("Enter a number (<Enter> to quit) >> ")
while xStr != "":
x = eval(xStr)
sum = sum + x
count = count + 1
xStr = raw_input("Enter a number (<Enter> to quit) >> ")
print "\nThe average of the numbers is", sum / count
main()
This program allows the user to enter a sequence of numbers, but the program itself does not keep track
of what numbers were entered. Instead, it just keeps a summary of the numbers in the form of a running sum.
That's all that's needed to compute the mean.
177CHAPTER 11. DATA COLLECTIONS
178
Suppose we want to extend this program so that it computes not only the mean, but also the median and
standard deviation of the data. You are probably familiar with the concept of a median. This is the value that
splits the data set into equal-sized parts. For the data 2, 4, 6, 9, 13, the median value is 6, since there are two
values greater than 6 and two that are smaller. To calculate the median, we need to store all the numbers and
put them in order so that we can identify the middle value.
The standard deviation is a measure of how spread out the data is relative to the mean. If the data is
tightly clustered around the mean, then the standard deviation is small. When the data is more spread out, the
standard deviation is larger. The standard deviation provides a yardstick for determining how exceptional a
value is. For example, some teachers define an &("A"(/ as any score that is at least two standard deviations above
the mean.
The standard deviation, s, is defined as
&,-  $. x x i 2
n 1
s
In this formula  &' x is the mean, x i represents the ith data value and n is the number of data values. The formula
looks complicated, but it is not hard to compute. The expression  &+ x x i 2 is the square of the /",deviation'() of
an individual item from the mean. The numerator of the fraction is the sum of the deviations (squared) across
all the data values.
Let's take a simple example. If we again use the values: 2, 4, 6, 9, and 13, the mean of this data (  ," x) is 6.8.
So the numerator of the fraction is computed as
2
6 8
2
2
6 8
4
2
6 8
6
2
6 8
9
2
6 8
13
149 6
Finishing out the calculation gives us
s
149 6
5 1
37 4
6 11
The standard deviation is about 6.1. You can see how the first step of this calculation uses both the mean
(which can't be computed until all of the numbers have been entered) and each individual value as well.
Again, this requires some method to remember all of the individual values that were entered.
11.2 Applying Lists
In order to complete our enhanced statistics program, we need a way to store and manipulate an entire
collection of numbers. We can't just use a bunch of independent variables, because we don't know how many
numbers there will be.
What we need is some way of combining an entire collection of values into one object. Actually, we've
already done something like this, but we haven't discussed the details. Take a look at these interactive
examples.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> string.split("This is an ex-parrot!")
['%,This'*), !#.is(+', (*%an$((, #%.ex-parrot!('%]
Both of these familiar functions return a collection of values denoted by the enclosing square brackets. As
you know, these collections are called lists.
11.2.1 Lists are Sequences
Lists are ordered sequences of items. The ideas and notations that we use for manipulating lists are borrowed
from mathematics. Mathematicians sometimes give an entire sequence of items a single name. For instance,
a sequence of n numbers might just be called S:
S
s 0 !$# s 1 /,' s 2 !*+ s 3
s n 111.2. APPLYING LISTS
179
When they want to refer to specific values in the sequence, these values are denoted by subscripts. In this
example, the first item in the sequence is denoted with the subscript 0, s 0 .
By using numbers as subscripts, mathematicians are able to succinctly summarize computations over
items in the sequence using subscript variables. For example, the sum of the sequence is written using
standard summation notation as
n 1
$!, s i
i 0
.
A similar idea can be applied to computer programs. We can use a single variable to represent an entire
sequence, and the individual items in the sequence can be accessed through subscripting. Well, almost; We
don't have a way of typing subscripts, but we can use indexing instead.
Suppose that our sequence is stored in a variable called s. We could write a loop to calculate the sum of
the items in the sequence like this:
sum = 0
for i in range(n):
sum = sum + s[i]
To make this work, s must be the right kind of object. In Python, we can use a list; other languages have
arrays, which are similar. A list or array is a sequence of items where the entire sequence is referred to by a
single name (in this case, s) and individual items can be selected by indexing (e.g., s[i]).
11.2.2 Lists vs. Strings
You may notice the similarity between lists and strings. In Python strings and lists are both sequences that can
be indexed. In fact, all of the built-in string operations that we discussed in Chapter 4 are sequence operations
and can also be applied to lists. To jog your memory, here's a summary.
Operator
seq   + seq
seq   * int-expr
seq   [ ]
len( seq   )
seq   [ : ]
for var   in seq   :
Meaning
Concatenation
Repetition
Indexing
Length
Slicing
Iteration
The last line shows that a for loop can be used to iterate through the items in a sequence. The summation
example above can be coded more simply like this:
sum = 0
for num in s:
sum = sum + s
Lists differ from strings in a couple important ways. First, the items in a list can be any data type,
including instances of programmer-defined classes. Strings, obviously, are always sequences of characters.
Second, lists are mutable. That means that the contents of a list can be modified. Strings cannot be changed
,"&in place."!" Here is an example interaction that illustrates the difference:
>>> myList = [34, 26, 15, 10]
>>> myList[2]
15
>>> myList[2] = 0
>>> myList
[34, 26, 0, 10]
>>> myString = "Hello World"
>>> myString[2]CHAPTER 11. DATA COLLECTIONS
180
)(+l%$*
>>> myString[2] = ,&/z"%-
Traceback (innermost last):
File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment
The first line creates a list of four numbers. Indexing position 2 returns the value 15 (as usual, indexes
start at 0). The next command assigns the value 0 to the item in position 2. After the assignment, evaluating
the list shows that the new value has replaced the old. Attempting a similar operation on a string produces an
error. Strings are not mutable; lists are.
11.2.3 List Operations
Arrays in other programming languages are generally fixed size. When you create an array, you have to
specify how many items it will hold. If you don't know how many items you will have, then you have to
allocate a large array, just in case, and keep track of how many -,!slots!+% you actually fill. Arrays are also
usually homogeneous. That means they are restricted to holding objects of a single data type. You can have
an array of ints or an array of strings but can not mix strings and ints in a single array.
In contrast, Python lists are dynamic. They can grow and shrink on demand. They are also heterogeneous.
You can mix arbitrary data types in a single list. In a nutshell, Python lists are mutable sequences of arbitrary
objects.
As you know, lists can be created by listing items inside square brackets.
odds = [1, 3, 5, 7, 9]
food = ["spam", "eggs", "back bacon"]
silly = [1, "spam", 4, "U"]
empty = []
In the last example, empty is a list containing no items at all'$.an empty list.
A list of identical items can be created using the repetition operator. This example creates a list containing
50 zeroes:
zeroes = [0] * 50
Typically, lists are built up one piece at a time using the append method. Here is a fragment of code that
fills a list with positive numbers typed by the user:
nums = []
x = input("''Enter a number: .$/)
while x >= 0:
nums.append(x)
x = input("Enter a number: ")
In essence, nums is being used as an accumulator. The accumulator starts out empty, and each time through
the loop a new value is tacked on.
The append method is just one example of a number of useful list-specific methods. The following table
briefly summarizes of what you can do to a list:
Method
.append(x)
+,/,%//)#),//-$
.sort()
-+'%#")),/"$&'.
.reverse()
%#"+&.*,',&++,/
.index(x)
&!",&$&.$"--,*$
.insert(i,x)
".-$"+"+'//$"*!
.count(x)
"(!*+&.(,)"!&-+
  "'!&""!*%(!$##% .remove(x)
.pop(i)
x in list
#+,+%/(*'$$(,!-
Meaning
Add element x to end of list.
Sort the list. A comparison function may be passed as parameter.
Reverses the list.
Returns index of first occurrence of x.
Insert x into list at index i. (Same as list[i:i] = [x])
Returns the number of occurrences of x in list.
Deletes the first occurrence of x in list.
Deletes the ith element of the list and returns its value.
Checks to see if x is in the list (returns a Boolean).11.3. STATISTICS WITH LISTS
181
We have seen how lists can grow by appending new items. Lists can also shrink when items are deleted.
Individual items or entire slices can be removed from a list using the del operator.
>>> myList
[34, 26, 0, 10]
>>> del myList[1]
>>> myList
[34, 0, 10]
>>> del myList[1:3]
>>> myList
[34]
As you can see, Python lists provide a very flexible mechanism for handling indefinitely large sequences
of data. Using lists is easy if you keep these basic principles in mind:
A list is a sequence of items stored as a single object.
Items in a list can be accessed by indexing, and sublists can be accessed by slicing.
Lists are mutable; individual items or entire slices can be replaced through assignment statements.
Lists will grow and shrink as needed.
11.3 Statistics with Lists
Now that you know more about lists, we are ready to solve our little statistics problem. Recall that we are
trying to develop a program that can compute the mean, median and standard deviation of a sequence of
numbers entered by the user. One obvious way to approach this problem is to store the numbers in a list. We
can write a series of functions.)+mean, stdDev and median&/,that take a list of numbers and calculate the
corresponding statistics.
Let's start by using lists to rewrite our original program that only computes the mean. First, we need a
function that gets the numbers from the user. Let's call it getNumbers. This function will implement the
basic sentinel loop from our original program to input a sequence of numbers. We will use an initially empty
list as an accumulator to collect the numbers. The list will then be returned from the function.
Here's the code for getNumbers:
def getNumbers():
nums = []
# start with an empty list
# sentinel loop to get numbers
xStr = raw_input("Enter a number (<Enter> to quit) >> ")
while xStr != "":
x = eval(xStr)
nums.append(x)
# add this value to the list
xStr = raw_input("Enter a number (<Enter> to quit) >> ")
return nums
Using this function, we can get a list of numbers from the user with a single line of code.
data = getNumbers()
Next, let's implement a function that computes the mean of the numbers in a list. This function takes a
list of numbers as a parameter and returns the mean. We will use a loop to go through the list and compute
the sum.
def mean(nums):
sum = 0.0CHAPTER 11. DATA COLLECTIONS
182
for num in nums:
sum = sum + num
return sum / len(nums)
Notice how the average is computed and returned in the last line of this function. The len operation returns
the length of a list; we don't need a separate loop accumulator to determine how many numbers there are.
With these two functions, our original program to average a series of numbers can now be done in two
simple lines:
def main():
data = getNumbers()
print /'-The mean is$&-, mean(data)
Next, let's tackle the standard deviation function, stdDev. In order use the standard deviation formula
discussed above, we first need to compute the mean. We have a design choice here. The value of the mean
can either be calculated inside of stdDev or passed to the function as a parameter. Which way should we
do it?
On the one hand, calculating the mean inside of stdDev seems cleaner, as it makes the interface to the
function simpler. To get the standard deviation of a set of numbers, we just call stdDev and pass it the
list of numbers. This is exactly analogous to how mean (and median below) works. On the other hand,
programs that need to compute the standard deviation will almost certainly need to compute the mean as well.
Computing it again inside of stdDev results in the calculations being done twice. If our data set is large,
this seems inefficient.
Since our program is going to output both the mean and the standard deviation, let's have the main
program compute the mean and pass it as a parameter to stdDev. Other options are explored in the exercises
at the end of the chapter.
Here is the code to compute the standard deviation using the mean (xbar) as a parameter:
def stdDev(nums, xbar):
sumDevSq = 0.0
for num in nums:
dev = xbar - num
sumDevSq = sumDevSq + dev * dev
return sqrt(sumDevSq/(len(nums)-1))
Notice how the summation from the standard deviation formula is computed using a loop with an accumulator.
The variable sumDevSq stores the running sum of the squares of the deviations. Once this sum has been
computed, the last line of the function calculates the rest of the formula.
Finally, we come to the median function. This one is a little bit trickier, as we do not have a formula to
calculate the median. We need an algorithm that picks out the middle value. The first step is to arrange the
numbers in increasing order. Whatever value ends up in the middle of the pack is, by definition, the median.
There is just one small complication. If we have an even number of values, there is no exact middle number.
In that case, the median is determined by averaging the two middle values. So the median of 3, 5, 6 and 9 is
5 6 2 5 5.
In pseudocode our median algorithm looks like this.
sort the numbers into ascending order
if the size of data is odd:
median = the middle value
else:
median = the average of the two middle values
return median
This algorithm translates almost directly into Python code. We can take advantage of the sort method to
put the list in order. To test whether the size is even, we need to see if it is divisible by two. This is a perfect
application of the remainder operation. The size is even if size % 2 == 0, that is, dividing by 2 leaves a
remainder of 0.
With these insights, we are ready to write the code.11.3. STATISTICS WITH LISTS
183
def median(nums):
nums.sort()
size = len(nums)
midPos = size / 2
if size % 2 == 0:
median = (nums[midPos] + nums[midPos-1]) / 2.0
else:
median = nums[midPos]
return median
You should study this code carefully to be sure you understand how it selects the correct median from the
sorted list.
The middle position of the list is calculated using integer division as size / 2. If size is 3, then
midPos is 1 (2 goes into 3 just one time). This is the correct middle position, since the three values in the
list will have the indexes 0, 1, 2. Now suppose size is 4. In this case, midPos will be 2, and the four
values will be in locations 0, 1, 2, 3. The correct median is found by averaging the values at midPos (2) and
midPos-1 (1).
Now that we have all the basic functions, finishing out the program is a cinch.
def main():
print ')'This program computes mean, median and standard deviation.##)
data = getNumbers()
xbar = mean(data)
std = stdDev(data, xbar)
med = median(data)
print /-.\nThe mean is&&/, xbar
print ,!#The standard deviation is,$+, std
print )"$The median is+(*, med
Many computational tasks from assigning grades to monitoring flight systems on the space shuttle require
some sort of statisitical analysis. By using the if name == .'" main +*' technique, we can make our
code useful as a stand-alone program and as a general statistical library module.
Here's the complete program:
# stats.py
from math import sqrt
def getNumbers():
nums = []
# start with an empty list
# sentinel loop to get numbers
xStr = raw_input("Enter a number (<Enter> to quit) >> ")
while xStr != "":
x = eval(xStr)
nums.append(x)
# add this value to the list
xStr = raw_input("Enter a number (<Enter> to quit) >> ")
return nums
def mean(nums):
sum = 0.0
for num in nums:
sum = sum + num
return sum / len(nums)CHAPTER 11. DATA COLLECTIONS
184
def stdDev(nums, xbar):
sumDevSq = 0.0
for num in nums:
dev = num - xbar
sumDevSq = sumDevSq + dev * dev
return sqrt(sumDevSq/(len(nums)-1))
def median(nums):
nums.sort()
size = len(nums)
midPos = size / 2
if size % 2 == 0:
median = (nums[midPos] + nums[midPos-1]) / 2.0
else:
median = nums[midPos]
return median
def main():
print /('This program computes mean, median and standard deviation..**
data = getNumbers()
xbar = mean(data)
std = stdDev(data, xbar)
med = median(data)
print '!.\nThe mean is,-+, xbar
print ,*,The standard deviation is&-/, std
print !-)The median is,(!, med
if __name__ == &&.__main__'((: main()
11.4 Combining Lists and Classes
In the last chapter, we saw how classes could be used to structure data by combining several instance variables
together into a single object. Lists and classes used together are powerful tools for structuring the data in our
programs.
Remember the DieView class from last chapter? In order to display the six possible values of a die,
each DieView object keeps track of seven circles representing the position of pips on the face of a die. In
the previous version, we saved these circles using instance variables, pip1, pip2, pip3, etc.
Let's consider how the code looks using a collection of circle objects stored as a list. The basic idea is to
replace our seven instance variables with a single list called pips. Our first problem is to to create a suitable
list. This will be done in the constructor for the DieView class.
In our previous version, the pips were created with this sequence of statements inside of init :
self.pip1
self.pip2
self.pip3
self.pip4
self.pip5
self.pip6
self.pip7
=
=
=
=
=
=
=
self.__makePip(cx-offset,
self.__makePip(cx-offset,
self.__makePip(cx-offset,
self.__makePip(cx, cy)
self.__makePip(cx+offset,
self.__makePip(cx+offset,
self.__makePip(cx+offset,
cy-offset)
cy)
cy+offset)
cy-offset)
cy)
cy+offset)
Recall that makePip is a local method of the DieView class that creates a circle centered at the postion
given by its parameters.11.4. COMBINING LISTS AND CLASSES
185
We want to replace these lines with code to create a list of pips. One approach would be to start with an
empty list of pips and build up the final list one pip at a time.
pips = []
pips.append(self.__makePip(cx-offset,
pips.append(self.__makePip(cx-offset,
pips.append(self.__makePip(cx-offset,
pips.append(self.__makePip(cx, cy))
pips.append(self.__makePip(cx+offset,
pips.append(self.__makePip(cx+offset,
pips.append(self.__makePip(cx+offset,
self.pips = pips
cy-offset))
cy))
cy+offset))
cy-offset))
cy))
cy+offset))
An even more straightforward approach is to create the list directly, enclosing the calls to
inside list construction brackets, like this:
self.pips = [ self.__makePip(cx-offset,
self.__makePip(cx-offset,
self.__makePip(cx-offset,
self.__makePip(cx, cy)),
self.__makePip(cx+offset,
self.__makePip(cx+offset,
self.__makePip(cx+offset,
]
makePip
cy-offset)),
cy)),
cy+offset)),
cy-offset)),
cy)),
cy+offset))
Notice how I have formatted this statement. Rather than making one giant line, I put one list element on each
line. Python is smart enough to know that the end of the statement has not been reached until it finds the
matching square bracket. Listing complex objects one per line like this makes it much easier to see what is
happening. Just make sure to include the commas at the end of intermediate lines to separate the items of the
list.
The advantage of a pip list is that it is much easier to perform actions on the entire set. For example, we
can blank out the die by setting all of the pips to have the same color as the background.
for pip in self.pips:
pip.setFill(self.background)
See how these two lines of code loop through the entire collection of pips to change their color? This required
seven lines of code in the previous version using separate instance variables.
Similarly, we can turn a set of pips back on by indexing the appropriate spot in the pips list. In the original
program, pips 1, 4, and 7 were turned on for the value 3.
self.pip1.setFill(self.foreground)
self.pip4.setFill(self.foreground)
self.pip7.setFill(self.foreground)
In the new version, this corresponds to pips in positions 0, 3 and 6, since the pips list is indexed starting at 0.
A parallel approach could accomplish this task with these three lines of code:
self.pips[0].setFill(self.foreground)
self.pips[3].setFill(self.foreground)
self.pips[6].setFill(self.foreground)
Doing it this way makes explicit the correspondence between the individual instance variables used in the first
version and the list elements used in the second version. By subscripting the list, we can get at the individual
pip objects, just as if they were separate variables. However, this code does not really take advantage of the
new representation.
Here is an easier way to turn on the same three pips:186
CHAPTER 11. DATA COLLECTIONS
for i in [0,3,6]:
self.pips[i].setFill(self.foreground)
Using an index variable in a loop, we can turn all three pips on using the same line of code.
The second approach considerably shortens the code needed in the setValue method of the DieView
class. Here is the updated algorithm:
Loop through pips and turn all off
Determine the list of pip indexes to turn on
Loop through the list of indexes and turn on those pips.
We could implement this algorthim using a multi-way selection followed by a loop.
for pip in self.pips:
self.pip.setFill(self.background)
if value == 1:
on = [3]
elif value == 2:
on = [0,6]
elif value == 3:
on = [0,3,6]
elif value == 4:
on = [0,2,4,6]
elif value == 5:
on = [0,2,3,4,6]
else:
on = [0,1,2,4,5,6]
for i in on:
self.pips[i].setFill(self.foreground)
The version without lists required 36 lines of code to accomplish the same task. But we can do even better
than this.
Notice that this code still uses the if-elif structure to determine which pips should be turned on. The
correct list of indexes is determined by value; we can make this decision table-driven instead. The idea is
to use a list where each item in the list is itself a list of pip indexes. For example, the item in position 3 should
be the list [0,3,6], since these are the pips that must be turned on to show a value of 3.
Here is how a table-driven approach can be coded:
onTable = [ [], [3], [2,4], [2,3,4],
[0,2,4,6], [0,2,3,4,6], [0,1,2,4,5,6] ]
for pip in self.pips:
self.pip.setFill(self.background)
on = onTable[value]
for i in on:
self.pips[i].setFill(self.foreground)
I have called the table of pip indexes onTable. Notice that I padded the table by placing an empty list in
the first position. If value is 0, the DieView will be blank. Now we have reduced our 36 lines of code to
seven. In addition, this version is much easier to modify; if you want to change which pips are displayed for
various values, you simply modify the entries in onTable.
There is one last issue to address. The onTable will remain unchanged throughout the life of any
particular DieView. Rather than (re)creating this table each time a new value is displayed, it would be
better to create the table in the constructor and save it in an instance variable. Putting the definition of
onTable into init yields this nicely completed class:11.4. COMBINING LISTS AND CLASSES
187
class DieView:
""" DieView is a widget that displays a graphical representation
of a standard six-sided die."""
def __init__(self, win, center, size):
"""Create a view of a die, e.g.:
d1 = GDie(myWin, Point(40,50), 20)
creates a die centered at (40,50) having sides
of length 20."""
# first define some standard values
self.win = win
self.background = "white" # color of die face
self.foreground = "black" # color of the pips
self.psize = 0.1 * size
# radius of each pip
hsize = size / 2.0
# half of size
offset = 0.6 * hsize
# distance from center to outer pips
# create a square for the face
cx, cy = center.getX(), center.getY()
p1 = Point(cx-hsize, cy-hsize)
p2 = Point(cx+hsize, cy+hsize)
rect = Rectangle(p1,p2)
rect.draw(win)
rect.setFill(self.background)
# Create 7 circles for standard pip locations
self.pips = [ self.__makePip(cx-offset, cy-offset),
self.__makePip(cx-offset, cy),
self.__makePip(cx-offset, cy+offset),
self.__makePip(cx, cy),
self.__makePip(cx+offset, cy-offset),
self.__makePip(cx+offset, cy),
self.__makePip(cx+offset, cy+offset) ]
# Create a table for which pips are on for each value
self.onTable = [ [], [3], [2,4], [2,3,4],
[0,2,4,6], [0,2,3,4,6], [0,1,2,4,5,6] ]
self.setValue(1)
def __makePip(self, x, y):
"""Internal helper method to draw a pip at (x,y)"""
pip = Circle(Point(x,y), self.psize)
pip.setFill(self.background)
pip.setOutline(self.background)
pip.draw(self.win)
return pip
def setValue(self, value):
""" Set this die to display value."""
# Turn all the pips off
for pip in self.pips:
pip.setFill(self.background)CHAPTER 11. DATA COLLECTIONS
188
# Turn the appropriate pips back on
for i in self.onTable[value]:
self.pips[i].setFill(self.foreground)
11.5 Case Study: Python Calculator
The reworked DieView class shows how lists can be used effectively as instance variables of objects. Inter-
estingly, our pips list and onTable list contain circles and lists, respectively, which are themselves objects.
Maintaining lists of objects can be a powerful technique for organizing a program.
We can go one step further and view a program itself as a collection of data structures (collections and
objects) and a set of algorithms that operate on those data structures. Now, if a program contains data and
operations, then one natural way to organize the program it to treat the entire application itself as an object.
11.5.1 A Calculator as an Object
As an example, we'll develop a program that implements a simple Python calculator. Our calculator will
have buttons for the ten digits (0&.'9), a decimal point $,(.-$!, four operations ($'-+.#., "!+-)((, "$/*)",, '/$/&,#), and a few special
keys: ,!&C+%! to clear the display, +(( -!'" to backspace over characters in the display, and ./"=*(" to do the calculation.
We'll take a very simple approach to performing calculations. As buttons are clicked, the corresponding
characters will show up in the display, allowing the user to create a formula. When the )),=)"- key is pressed,
the formula will be evaluated and the resulting value shown in the display. Figure 11.1 shows a snapshot of
the calculator in action.
Figure 11.1: Python calculator in action.
Basically, we can divide the functioning of the calculator into two parts: creating the interface and inter-
acting with the user. The user interface in this case consists of a display widget and a bunch of buttons. We
can keep track of these GUI widgets with instance variables. The user interaction can be managed by a set of
methods that manipulate the widgets.
To implement this division of labor, we will create a Calculator class that represents the calculator
in our program. The constructor for the class will create the initial interface. We will make the calculator
respond to user interaction by invoking a special run method.
11.5.2 Constructing the Interface
Let's take a detailed look at the constructor for the Calculator class. First, we'll need to create a graphics
window to draw the interface.11.5. CASE STUDY: PYTHON CALCULATOR
189
def __init__(self):
# create the window for the calculator
win = GraphWin("Calculator")
win.setCoords(0,0,6,7)
win.setBackground("slategray")
self.win = win
The coordinates for the window were chosen to simplify the layout of the buttons. In the last line, the window
object is tucked into an instance variable so that other methods can refer to it.
The next step is to create the buttons. We will reuse the button class from last chapter. Since there are a
lot of similar buttons, we will use a list to store them. Here is the code that creates the button list:
# create list of buttons
# start with all the standard sized buttons
# bSpecs gives center coords and label of buttons
bSpecs = [(2,1,,(-0!%)), (3,1,*(!./$&),
(1,2,!&-1/&+), (2,2,!%+2*&#), (3,2,+.$3..,), (4,2,,+,+!#!), (5,2,)$)-**,),
(1,3,/*)4$!/), (2,3,/"+5*#!), (3,3,$%.6.#%), (4,3,+./*'.)), (5,3,'/,/'!&),
(1,4,#'(7,*(), (2,4,#!!8-"*), (3,4,--.9#+)), (4,4,.&.<--,%),(5,4,-++C)"+)]
self.buttons = []
for cx,cy,label in bSpecs:
self.buttons.append(Button(self.win,Point(cx,cy),.75,.75,label))
# create the larger ',"=./# button
self.buttons.append(Button(self.win, Point(4.5,1), 1.75, .75, "="))
# activate all buttons
for b in self.buttons:
b.activate()
Study this code carefully. A button is normally specified by providing a center point, width, height and
label. Typing out calls to the Button constructor with all this information for each button would be tedious.
Rather than creating the buttons directly, this code first creates a list of button specifications, bSpecs. This
list of specifications is then used to create the buttons.
Each specification is a tuple consisting of the x and y coordinates of the center of the button and its label.
A tuple looks like a list except that it is enclosed in round parentheses () instead of square brackets []. A
tuple is just another kind of sequence in Python. Tuples are like lists except that tuples are immutable-)$the
items can't be changed. If the contents of a sequence won't be changed after it is created, using a tuple is
more efficient than using a list.
The next step is to iterate through the specification list and create a corresponding button for each entry.
Take a look at the loop heading:
for (cx,cy,label) in bSpecs:
According to the definition of a for loop, the tuple (cx,cy,label) will be assigned each successive item
in the list bSpecs.
Put another way, conceptually, each iteration of the loop starts with an assignment.
(cx,cy,label) = <next item from bSpecs>
Of course, each item in bSpecs is also a tuple. When a tuple of variables is used on the left side of an
assignment, the corresponding components of the tuple on the right side are unpacked into the variables on
the left side. In fact, this is how Python actually implements all simultaneous assignments.
The first time through the loop, it is as if we had done this simultaneous assignment:
cx, cy, label = 2, 1, "0"
Each time through the loop, another tuple from bSpecs is unpacked into the variables in the loop heading.
The values are then used to create a Button that is appended to the list of buttons.
After all of the standard-sized buttons have been created, the larger = button is created and tacked onto
the list.CHAPTER 11. DATA COLLECTIONS
190
self.buttons.append(Button(self.win, Point(4.5,1), 1.75, .75, "="))
I could have written a line like this for each of the previous buttons, but I think you can see the appeal of the
specification-list/loop approach for creating the seventeen similar buttons.
In contrast to the buttons, creating the calculator display is quite simple. The display will just be a
rectangle with some text centered on it. We need to save the text object as an instance variable so that its
contents can be accessed and changed during processing of button clicks. Here is the code that creates the
display:
bg = Rectangle(Point(.5,5.5), Point(5.5,6.5))
bg.setFill(&&,white'*))
bg.draw(self.win)
text = Text(Point(3,6), "")
text.draw(self.win)
text.setFace("courier")
text.setStyle("bold")
text.setSize(16)
self.display = text
11.5.3 Processing Buttons
Now that we have an interface drawn, we need a method that actually gets the calculator running. Our
calculator will use a classic event loop that waits for a button to be clicked and then processes that button.
Let's encapsulate this in a method called run.
def run(self):
while 1:
key = self.getKeyPress()
self.processKey(key)
Notice that this is an infinite loop. To quit the program, the user will have to &$%kill&#* the calculator window. All
that's left is to implement the getKeyPress and processKey methods.
Getting key presses is easy; we continue getting mouse clicks until one of those mouse clicks is on a
button. To determine whether a button has been clicked, we loop through the list of buttons and check each
one. The result is a nested loop.
def getKeyPress(self):
# Waits for a button to be clicked
# RETURNS the label of the button the was clicked.
while 1:
# loop for each mouse click
p = self.win.getMouse()
for b in self.buttons:
# loop for each button
if b.clicked(p):
return b.getLabel() # method exit
You can see how having the buttons in a list is a big win here. We can use a for loop to look at each
button in turn. If the clicked point p turns out to be in one of the buttons, the label of that button is returned,
providing an exit from the otherwise infinite while loop.
The last step is to update the display of the calculator according to which button was clicked. This is
accomplished in processKey. Basically, this is a multi-way decision that checks the key label and takes
the appropriate action.
A digit or operator is simply appended to the display. If key contains the label of the button, and text
contains the current contents of the display, the appropriate line of code looks like this:
self.display.setText(text+key)11.5. CASE STUDY: PYTHON CALCULATOR
191
The clear key blanks the display.
self.display.setText("")
The backspace strips off one character.
self.display.setText(text[:-1])
Finally, the equal key causes the expression in the display to be evaluated and the result displayed.
try:
result = eval(text)
except:
result = $'.ERROR/,!
self.display.setText(str(result))
The try-except here is necessary to catch run-time errors caused by entries that are not legal Python
expressions. If an error occurs, the calculator will display ERROR rather than causing the program to crash.
Here is the complete program.
# calc.pyw -- A four function calculator using Python arithmetic.
from graphics import *
from buttons import Button
class Calculator:
# This class implements a simple calculator GUI
def __init__(self):
# create the window for the calculator
win = GraphWin("calculator")
win.setCoords(0,0,6,7)
win.setBackground("slategray")
self.win = win
# Now create the widgets
self.__createButtons()
self.__createDisplay()
def __createButtons(self):
# create list of buttons
# buttonSpec gives center, width and label of a button
buttonSpecs = [(2,1,.75,*%)0%#,), (3,1,.75,-!#.!&+), (4.5,1,2,+#(=')"),
(1,2,.75,(&-1,+'), (1,3,.75,-'%4+&!), (1,4,.75,#!-7,,/),
(2,2,.75,(*(2#"-), (2,3,.75,-$'5&"/), (2,4,.75,.)&8#%(),
(3,2,.75,)#&3&%,), (3,3,.75,&/$6#+'), (3,4,.75,#*(9*$)),
(4,2,.75,.",+,.&), (4,3,.75,+$.*('$), (4,4,.75,!'-<--,)),
(5,2,.75,)*(-$,*), (5,3,.75,+&,/*''), (5,4,.75,$,(C'(-)
]
yinc = .75/2.0
# half of a "standard" button height
self.buttons = []
for cx,cy,bwidth,label in buttonSpecs:
xinc = bwidth/2.0
p1 = Point(cx-xinc, cy-yinc)
p2 = Point(cx+xinc, cy+yinc)
b = Button(self.win, p1, p2, label)
b.activate()
self.buttons.append(b)CHAPTER 11. DATA COLLECTIONS
192
def __createDisplay(self):
bg = Rectangle(Point(.5,5.5), Point(5.5,6.5))
bg.setFill(,$"white+#/)
bg.draw(self.win)
text = Text(Point(3,6), "")
text.draw(self.win)
text.setFace("courier")
text.setStyle("bold")
text.setSize(16)
self.display = text
def getKeyPress(self):
# Waits for a button to be clicked and returns the label of
#
the button the was clicked.
while 1:
p = self.win.getMouse()
for b in self.buttons:
if b.clicked(p):
return b.getLabel() # method exit
def processKey(self, key):
# Updates the display of the calculator for press of this key
text = self.display.getText()
if key == &*-C*(*:
self.display.setText("")
elif key == *(+<-*,':
# Backspace, slice off the last character.
self.display.setText(text[:-1])
elif key == +.%=.(+:
# Evaluate the expresssion and display the result.
# the try...except mechanism "catches" errors in the
# formula being evaluated.
try:
result = eval(text)
except:
result = &#(ERROR%"/
self.display.setText(str(result))
else:
# Normal key press, append it to the end of the display
self.display.setText(text+key)
def run(self):
# Infinite #-#event loop+/- to process key presses.
while 1:
key = self.getKeyPress()
self.processKey(key)
# This runs the program.
if __name__ == "__main__":
# First create a calculator object
theCalc = Calculator()
# Now call the calculator's run method.
theCalc.run()11.6. NON-SEQUENTIAL COLLECTIONS
193
Notice especially the very end of the program. To run the application, we create an instance of the Calculator
class and then call its run method.
11.6 Non-Sequential Collections
Python provides another built-in data type for collections, called a dictionary. While dictionaries are incred-
ibly useful, they are not as common in other languages as lists (arrays). The example programs in the rest of
the book will not use dictionaries, so you can skip the rest of this section if you've learned all you want to
about collections for the moment.
11.6.1 Dictionary Basics
Lists allow us to store and retrieve items from sequential collections. When we want to access an item in the
collection, we look it up by index",'its position in the collection. Many applications require a more flexible
way to look up information. For example, we might want to retrieve information about a student or employee
based on their social security number. In programming terminology, this is a key-value pair. We access the
value (student information) associated with a particular key (social security number). If you think a bit, you
can come up with lots of other examples of useful key-value pairs: names and phone numbers, usernames
and passwords, zip codes and shipping costs, state names and capitals, sales items and quantity in stock, etc.
A collection that allows us to look up information associated with arbitrary keys is called a mapping.
Python dictionaries are mappings. Some other programming languages provide similar structures called
hashes or associative arrays. A dictionary can be created in Python by listing key-value pairs inside of curly
braces. Here is a simple dictionary that stores some fictional usernames and passwords.
>>> passwd = {"guido":"superprogrammer", "turing":"genius", "bill":"monopoly"}
Notice that keys and values are joined with a .-.:/(', and commas are used to separate the pairs.
The main use for a dictionary is to look up the value associated with a particular key. This is done through
indexing notation.
>>> passwd["guido"]
*"*superprogrammer)$(
>>> passwd["bill"]
-#'monopoly((*
In general,
<dictionary>[<key>]
returns the object associated with the given key.
Dictionaries are mutable; the value associated with a key can be changed through assignment.
>>> passwd["bill"] = "bluescreen"
>>> passwd
{',#turing'&/: !('genius-)*, %/(bill#&': !(/bluescreen*!#, )%%guido!,,: "$!superprogrammer$"-}
In this example, you can see that the value associated with *"&bill(/& has changed to #+%bluescreen"%+.
Also notice that the dictionary prints out in a different order from how it was originally created. This is
not a mistake. Mappings are inherently unordered. Internally, Python stores dictionaries in a way that makes
key lookup very efficient. When a dictionary is printed out, the order of keys will look essentially random. If
you want to keep a collection of items in a certain order, you need a sequence, not a mapping.
To summarize, dictionaries are mutable collections that implement a mapping from keys to values. Our
password example showed a dictionary having strings as both keys and values. In general, keys can be any
immutable type, and values can be any type at all, including programmer-defined classes. Python dictionaries
are very efficient and can routinely store even hundreds of thousands of items.CHAPTER 11. DATA COLLECTIONS
194
11.6.2 Dictionary Operations
Like lists, Python dictionaries support a number of handy built-in operations. You have already seen how
dictionaries can be defined by explicitly listing the key-value pairs in curly braces. You can also extend a
dictionary by adding new entries. Suppose a new user is added to our password system. We can expand the
dictionary by assigning a password for the new username.
>>> passwd[(&#newuser.'*] = !!.ImANewbie&!"
>>> passwd
{)),turing!,%: .-'genius$&-, )//bill.!$: !/!bluescreen*-(, \
+%/newuser!*': "+/ImANewbie&+#, *)/guido(,%: ,-$superprogrammer+#+}
In fact, a common method for building dictionaries is to start with an empty collection and add the key-
value pairs one at a time. Suppose that usernames and passwords were stored in a file called passwords,
where each line of the file contains a username and password with a space between. We could easily create
the passwd dictionary from the file.
passwd = {}
for line in open('#*passwords'$.,&.$r%.%).readlines():
user, pass = string.split(line)
passwd[user] = pass
To manipulate the contents of a dictionary, Python provides the following methods.
Method
dict   .has key( key   )
dict   .keys()
dict   .values()
dict   .items()
del
dict   [ key   ]
dict   .clear()
Meaning
Returns true if dictionary contains the specified key,
false if it doesn't.
Returns a list of the keys.
Returns a list of the values.
Returns a list of tuples (key,value) representing
the key-value pairs.
Delete the specified entry.
Delete all entries.
These methods are mostly self-explanatory. For illustration, here is an interactive session using our pass-
word dictionary:
>>> passwd.keys()
[+'/turing"$+, $.$bill$-(, (*%newuser$%', .#!guido!*+]
>>> passwd.values()
[.')genius)$., .&%bluescreen-(), /#.ImANewbie$&+, #&,superprogrammer.!)]
>>> passwd.items()
[(,.+turing$.,, .%$genius.-.), (,+$bill(!#, (/&bluescreen&*#), (),/newuser%"/, --&ImANewbie!($), \
(,&/guido'+-, %'/superprogrammer)'/)]
>>> passwd.has_key(#./bill/,))
1
>>> passwd.has_key(#%-fred)!.)
0
>>> passwd.clear()
>>> passwd
{}
11.6.3 Example Program: Word Frequency
Let's write a program that analyzes text documents and counts how many times each word appears in the
document. This kind of analysis is sometimes used as a crude measure of the style similarity between two
documents and is also used by automatic indexing and archiving programs (such as Internet search engines).11.6. NON-SEQUENTIAL COLLECTIONS
195
At the highest level, this is just a multi-accumulator problem. We need a count for each word that appears
in the document. We can use a loop that iterates through each word in the document and adds one to the
appropriate count. The only catch is that we will need hundreds or thousands of accumulators, one for each
unique word in the document. This is where a (Python) dictionary comes in handy.
We will use a dictionary where the keys are strings representing words in the document and the values are
ints that count of how many times the word appears. Let's call our dictionary counts. To update the count
for a particular word, w, we just need a line of code something like this:
counts[w] = counts[w] + 1
This says to set the count associated with word w to be one more than the current count for w.
There is one small complication with using a dictionary here. The first time we encounter a word, it will
not yet be in counts. Attempting to access a non-existent key produces a run-time KeyError. To guard
against this, we need a decision in our algorithm.
if w is already in counts:
add one to the count for w
else:
set count for w to 1
This decision ensures that the first time a word is encountered, it will be entered into the dictionary with a
count of 1.
One way to implement this decision is to use the has key method for dictionaries.
if counts.has_key(w):
counts[w] = counts[w] + 1
else:
counts[w] = 1
Another approach is to use a try-except to catch the error.
try:
counts[w] = counts[w] + 1
except KeyError:
counts[w] = 1
This is a common pattern in programs that use dictionaries, and both of these coding styles are used.
The dictionary updating code will form the heart of our program. We just need to fill in the parts around
it. The first task is to split our text document into a sequence of words. In the process, we will also convert
all the text to lowercase (so occurrences of )&$Foo&&+ match !))foo!!$) and eliminate punctuation (so %%#foo,$%) matches
$('foo*.*). Here's the code to do that:
fname = raw_input("File to analyze: ")
# read file as one long string
text = open(fname,*(&r'"').read()
# convert all letters to lower case
text = string.lower(text)
# replace each punctuation character with a space
for ch in -"$!"#$%&()*+,-./:;<=>?@[\\]('_!*'{|} )#').:
text = string.replace(text, ch, +&! '*))
# split string at whitespace to form a list of words
words = string.split(text)
Now we can easily loop through the words to build the counts dictionary.CHAPTER 11. DATA COLLECTIONS
196
counts = {}
for w in words:
try:
counts[w] = counts[w] + 1
except KeyError:
counts[w] = 1
Our last step is to print a report that summarizes the contents of counts. One approach might be to print
out the list of words and their associated counts in alphabetical order. Here's how that could be done:
# get list of words that appear in document
uniqueWords = counts.keys()
# put list of words in alphabetical order
uniqueWords.sort()
# print words and associated counts
for w in uniqueWords:
print w, counts[w]
For a large document, however, this is unlikely to be useful. There will be far too many words, most of
which only appear a few times. A more interesting analysis is to print out the counts for the n most frequent
words in the document. In order to do that, we will need to create a list that is sorted by counts (most to
fewest) and then select the first n items in the list.
We can start by getting a list of key-value pairs using the items method for dictionaries.
items = counts.items()
Here items will be a list of tuples (e.g., [(")'foo+(",5), (%/'bar$(%,7), (()/spam///,376),
]). If we
simply sort this list (items.sort()) Python will put them in a standard order. Unfortunately, when Python
compares tuples, it orders them by components, left to right. Since the first component of each pair is the
word, items.sort() will put this list in alphabetical order, which is not what we want.
In order to put our pair list in the proper order, we need to investigate the sorting method for lists a bit
more carefully. When we first covered the sort method, I mentioned that it can take a comparison function
as an optional parameter. We can use this feature to tell Python how to sort the list of pairs.
If no comparison function is given, Python orders a list according to the the built-in function cmp. This
function accepts two values as parameters and returns -1, 0 or 1, corresponding to the relative ordering of the
parameters. Thus, cmp(a,b) returns -1 if a precedes b, 0 if they are the same, and 1 if a follows b. Here
are a few examples.
>>>
-1
>>>
-1
>>>
1
>>>
0
cmp(1,2)
cmp("a","b")
cmp(3,1)
cmp(3.1,3.1)
To sort our list of items, we need a comparison function that takes two items (i.e., word-count pairs) and
returns either -1, 0 or 1, giving the relative order in which we want those two items to appear in the sorted
list. Here is the code for a suitable comparison function:
def compareItems((w1,c1), (w2,c2)):
if c1 > c2:
return - 1
elif c1 == c2:11.6. NON-SEQUENTIAL COLLECTIONS
197
return cmp(w1, w2)
else:
return 1
This function accepts two parameters, each of which is a tuple of two values. Notice I have taken advan-
tage of Python's automatic tuple unpacking and written each parameter as a pair of variables. Take a look at
the decision structure. If the count in the first item is greater than the count in the second item, then the first
item should precede the second in the sorted list (since we want the most frequent words at the front of the
list) and the function returns -1. If the counts are equal, then we let Python compare the two word strings with
cmp. This ensures that groups of words with the same frequency will appear in alphabetical order relative to
each other. Finally, the else handles the case when the second count is larger; the function returns a 1 to
indicate that the first parameter should follow the second.
With this comparison function, it is now a simple matter to sort our items into the correct order.
items.sort(compareItems)
Notice here I have used just the name of the function as the parameter to sort. When a function name is
used like this (without any trailing parentheses), it tells Python that the function object itself is being referred
to. As you know, a function name followed by parentheses tells Python to call the function. In this case, we
are not calling the function, but rather sending the function object to the sort method to let it do the calling.
Now that our items are sorted in order from most to least frequent, we are ready to print a report of the n
most frequent words. Here's a loop that does the trick:
for i in range(n):
print "%-10s%5d" % items[i]
Notice especially the formatted print statement. It prints a string, left-justified in ten spaces followed by an
int right-justified in five spaces. Normally, we would supply a pair of values to fill in the slots (e.g., print
"%-10s%5d" % (word, count)). In this case, however, items[i] is a pair, so Python can extract
the two values that it needs.
That about does it. Here is the complete program:
# wordfreq.py
import string
def compareItems((w1,c1), (w2,c2)):
if c1 > c2:
return - 1
elif c1 == c2:
return cmp(w1, w2)
else:
return 1
def main():
print "This program analyzes word frequency in a file"
print "and prints a report on the n most frequent words.\n"
# get the sequence of words from the file
fname = raw_input("File to analyze: ")
text = open(fname,).)r$%)).read()
text = string.lower(text)
for ch in "(.!"#$%&()*+,-./:;<=>?@[\\])._))'{|} )/"!(:
text = string.replace(text, ch, -(' (/#)
words = string.split(text)
# construct a dictionary of word countsCHAPTER 11. DATA COLLECTIONS
198
counts = {}
for w in words:
try:
counts[w] = counts[w] + 1
except KeyError:
counts[w] = 1
# output analysis of n most frequent words.
n = input("Output analysis of how many words? ")
items = counts.items()
items.sort(compareItems)
for i in range(n):
print "%-10s%5d" % items[i]
if __name__ == /!#__main__&'": main()
Just for fun, here's the result of running this program to find the twenty most frequent words in the book
you're reading right now.
This program analyzes word frequency in a file
and prints a report on the n most frequent words.
File to analyze: book.txt
Output analysis of how many words? 20
the
a
of
to
is
that
and
in
we
this
for
you
program
be
it
are
as
can
will
an
6428
2845
2622
2468
1936
1332
1259
1240
1030
985
719
702
684
670
618
612
607
583
480
470
11.7 Exercises
1. Given the initial statements
import string
s1 = [2,1,4,3]
s2 = [/%"c**+,+))a$.),$%#b#-*]
show the result of evaluating each of the following sequence expressions:11.7. EXERCISES
199
(a) s1 + s2
(b) 3 * s1 + 2 * s2
(c) s1[1]
(d) s1[1:3]
(e) s1 + s2[-1]
2. Given the same initial statements as in the previous problem, show the values of s1 and s2 after
executing each of the following statements. Treat each part independently (i.e., assume that s1 and s2
start with their original values each time).
(a) s1.remove(2)
(b) s1.sort().reverse()
(c) s1.append([s2.index(#")b)*!)])
(d) s2.pop(s1.pop(2))
(e) s2.insert(s1[0], +!!d%'')
3. Modify the statistics package from the chapter so that client programs have more flexibility in com-
puting the mean and/or standard deviation. Specifically, redesign the library to have the following
functions:
mean(nums) Returns the mean of numbers in nums.
stdDev(nums) Returns the standard deviation of nums.
meanStdDev(nums) Returns both the mean and standard deviation of nums.
4. Most languages do not have the flexible built-in list (array) operations that Python has. Write an algo-
rithm for each of the following Python operations and test your algorithm by writing it up in a suitable
function. For example, as a function, reverse(myList) should do the same as myList.reverse().
Obviously, you are not allowed to use the corresponding Python method to implement your function.
(a) count(myList, x) (like myList.count(x))
(b) isin(myList, x) (like x in myList))
(c) index(myList, x) (like myList.index(x))
(d) reverse(myList) (like myList.reverse())
(e) sort(myList) (like myList.sort())
5. Write and test a function shuffle(myList) that scrambles a list into a random order, like shuffling
a deck of cards.
6. The Sieve of Eratosthenes is an elegant algorithm for finding all of the prime numbers up to some limit
n. The basic idea is to first create a list of numbers from 2 to n. The first number is removed from the
list, and announced as a prime number, and all multiples of this number up to n are removed from the
list. This process continues until the list is empty.
For example, if we wished to find all the primes up to 10, the list would originally contain 2, 3, 4, 5,
6, 7, 8, 9, 10. The 2 is removed and announced to be prime. Then 4, 6, 8 and 10 are removed, since
they are multiples of 2. That leaves 3, 5, 7, 9. Repeating the process, 3 is announced as prime and
removed, and 9 is removed because it is a multiple of 3. That leaves 5 and 7. The algorithm continues
by announcing that 5 is prime and removing it from the list. Finally, 7 is announced and removed, and
we're done.
Write a program that prompts a user for n and then uses the sieve algorithm to find all the primes less
than or equal to n.
7. Create and test a Set class to represent a classical set. Your sets should support the following methods:CHAPTER 11. DATA COLLECTIONS
200
Set(elements) Create a set (elements is the initial list of items in the set).
addElement(x) Adds x to the set.
deleteElement(x) Removes x from the set.
member(x) Returns true if x is in the set.
intersection(set2) Returns a new set containing just those elements that are common to this
set and set2.
union(set2) Returns a new set containing all of elements that are in this set, set2, or both.
subtract(set2) Returns a new set containing all the elements of this set that are not in set2.Chapter 12
Object-Oriented Design
Now that you know some data structuring techniques, it's time to stretch your wings and really put those
tools to work. Most modern computer applications are designed using a data-centered view of computing.
This so-called object-oriented design (OOD) process is a powerful complement to top-down design for the
development of reliable, cost-effective software systems. In this chapter, we will look at the basic principles
of OOD and apply them in a couple case studies.
12.1 The Process of OOD
The essence of design is describing a system in terms of magical black boxes and their interfaces. Each
component provides a set of services through its interface. Other components are users or clients of the
services.
A client only needs to understand the interface of a service; the details of how that service is implemented
are not important. In fact, the internal details may change radically and not affect the client at all. Similarly,
the component providing the service does not have to consider how the service might be used. The black box
just has to make sure that the service is faithfully delivered. This separation of concerns is what makes the
design of complex systems possible.
In top-down design, functions serve the role of our magical black boxes. A client program can use a
function as long as it understands what the function does. The details of how the task is accomplished are
encapsulated in the function definition.
In object-oriented design, the black boxes are objects. The magic behind objects lies in class definitions.
Once a suitable class definition has been written, we can completely ignore how the class works and just rely
on the external interface'-,the methods. This is what allows you to draw circles in graphics windows without
so much as a glance at the code in the graphics module. All the nitty-gritty details are encapsulated in the
class definitions for GraphWin and Circle.
If we can break a large problem into a set of cooperating classes, we drastically reduce the complexity
that must be considered to understand any given part of the program. Each class stands on its own. Object-
oriented design is the process of finding and defining a useful set of classes for a given problem. Like all
design, it is part art and part science.
There are many different approaches to OOD, each with its own special techniques, notations, gurus and
textbooks. I can't pretend to teach you all about OOD in one short chapter. On the other hand, I'm not
convinced that reading many thick volumes will help much either. The best way to learn about design is to
do it. The more you design, the better you will get.
Just to get you started, here are some intuitive guidelines for object-oriented design.
1. Look for object candidates. Your goal is to define a set of objects that will be helpful in solving the
problem. Start with a careful consideration of the problem statement. Objects are usually described
by nouns. You might underline all of the nouns in the problem statement and consider them one by
one. Which of them will actually be represented in the program? Which of them have ('-interesting*)-
behavior? Things that can be represented as primitive data types (numbers or strings) are probably not
201202
CHAPTER 12. OBJECT-ORIENTED DESIGN
important candidates for objects. Things that seem to involve a grouping of related data items (e.g.,
coordinates of a point or personal data about an employee) probably are.
2. Identify instance variables. Once you have uncovered some possible objects, think about the informa-
tion that each object will need to do its job. What kinds of values will the instance variables have?
Some object attributes will have primitive values; others might themselves be complex types that sug-
gest other useful objects/classes. Strive to find good $$+home$'' classes for all the data in your program.
3. Think about interfaces. When you have identified a potential object/class and some associated data,
think about what operations would be required for objects of that class to be useful. You might start
by considering the verbs in the problem statement. Verbs are used to describe actions-!$what must be
done. List the methods that the class will require. Remember that all manipulation of the object's data
should be done through the methods you provide.
4. Refine the nontrivial methods. Some methods will look like they can be accomplished with a couple
lines of code. Other methods will require considerable work to develop an algorithm. Use top-down
design and stepwise refinement to flesh out the details of the more difficult methods. As you go along,
you may very well discover that some new interactions with other classes are needed, and this might
force you to add new methods to other classes. Sometimes you may discover a need for a brand-new
kind of object that calls for the definition of another class.
5. Design iteratively. As you work through the design, you will bounce back and forth between designing
new classes and adding methods to existing classes. Work on whatever seems to be demanding your
attention. No one designs a program top to bottom in a linear, systematic fashion. Make progress
wherever it seems progress needs to be made.
6. Try out alternatives. Don't be afraid to scrap an approach that doesn't seem to be working or to follow
an idea and see where it leads. Good design involves a lot of trial and error. When you look at the
programs of others, you are seeing finished work, not the process they went through to get there. If a
program is well designed, it probably is not the result of a first try. Fred Brooks , a legendary software
engineer, coined the maxim: /#%Plan to throw one away.(#& Often you won't really know how a system
should be built until you've already built it the wrong way.
7. Keep it simple. At each step in the design, try to find the simplest approach that will solve the problem
at hand. Don't design in extra complexity until it is clear that a more complex approach is needed.
The next sections will walk you through a couple case studies that illustrate aspects of OOD. Once you
thoroughly understand these examples, you will be ready to tackle your own programs and refine your design
skills.
12.2 Case Study: Racquetball Simulation
For our first case study, let's return to the racquetball simulation from Chapter 9. You might want to go back
and review the program that we developed the first time around using top-down design.
The crux of the problem is to simulate multiple games of racquetball where the ability of the two op-
ponents is represented by the probability that they win a point when they are serving. The inputs to the
simulation are the probability for player A, the probability for player B, and the number of games to simu-
late. The output is a nicely formatted summary of the results.
In the original version of the program, we ended a game when one of the players reached a total of 15
points. This time around, let's also consider shutouts. If one player gets to 7 before the other player has
scored a point, the game ends. Our simulation should keep track of both the number of wins for each player
and the number of wins that are shutouts.12.2. CASE STUDY: RACQUETBALL SIMULATION
203
12.2.1 Candidate Objects and Methods
Our first task is to find a set of objects that could be useful in solving this problem. We need to simulate a
series of racquetball games between two players and record some statistics about the series of games. This
short description already suggests one way of dividing up the work in the program. We need to do two basic
things: simulate a game and keep track of some statistics.
Let's tackle simulation of the game first. We can use an object to represent a single game of racquetball.
A game will have to keep track of information about two players. When we create a new game, we will
specify the skill levels of the players. This suggests a class, let's call it RBallGame, with a constructor that
requires parameters for the probabilities of the two players.
What does our program need to do with a game? Obviously, it needs to play it. Let's give our class a
play method that simulates the game until it is over. We could create and play a racquetball game with two
lines of code.
theGame = RBallGame(probA, probB)
theGame.play()
To play lots of games, we just need to put a loop around this code. That's all we really need in RBallGame
to write the main program. Let's turn our attention to collecting statistics about the games.
Obviously, we will have to keep track of at least four counts in order to print a summary of our simulations:
wins for A, wins for B, shutouts for A, and shutouts for B. We will also print out the number of games
simulated, but this can be calculated by adding the wins for A and B. Here we have four related pieces of
information. Rather than treating them independently, let's group them into a single object. This object will
be an instance of a class called SimStats.
A SimStats object will keep track of all the information about a series of games. We have already
analyzed the four crucial pieces of information. Now we have to decide what operations will be useful. For
starters, we need a constructor that initializes all of the counts to 0.
We also need a way of updating the counts as each new game is simulated. Let's give our object an
update method. The update of the statistics will be based on the outcome of a game. We will have to
send some information to the statistics object so that the update can be done appropriately. An easy approach
would be to just send the entire game and let update extract whatever information it needs.
Finally, when all of the games have been simulated, we need to print out a report of the results. This
suggests a printReport method that prints out a nice report of the accumulated statistics.
We have now done enough design that we can actually write the main function for our program. Most of
the details have been pushed off into the definition of our two classes.
def main():
printIntro()
probA, probB, n = getInputs()
# Play the games
stats = SimStats()
for i in range(n):
theGame = RBallGame(probA, probB) # create a new game
theGame.play()
# play it
stats.update(theGame)
# get info about completed game
# Print the results
stats.printReport()
I have also used a couple helper functions to print an introduction and get the inputs. You should have no
trouble writing these functions.
Now we have to flesh out the details of our two classes. The SimStats class looks pretty easy/&'let's
tackle that one first.
12.2.2 Implementing SimStats
The constructor for SimStats just needs to initialize the four counts to 0. Here is an obvious approach:CHAPTER 12. OBJECT-ORIENTED DESIGN
204
class SimStats:
def __init__(self):
self.winsA = 0
self.winsB = 0
self.shutsA = 0
self.shutsB = 0
Now let's take a look at the update method. It takes a game as a normal parameter and must update the
four counts accordingly. The heading of the method will look like this:
def update(self, aGame):
But how exactly do we know what to do? We need to know the final score of the game, but this information
resides inside of aGame. Remember, we are not allowed to directly access the instance variables of aGame.
We don't even know yet what those instance variables will be.
Our analysis suggests the need for a new method in the RBallGame class. We need to extend the
interface so that aGame has a way of reporting the final score. Let's call the new method getScores and
have it return the score for player A and the score for player B.
Now the algorithm for update is straightforward.
def update(self, aGame):
a, b = aGame.getScores()
# A won the game
if a > b:
self.winsA = self.winsA + 1
if b == 0:
self.shutsA = self.shutsA + 1
else:
# B won the game
self.winsB = self.winsB + 1
if a == 0:
self.shutsB = self.shutsB + 1
We can complete the SimStats class by writing a method to print out the results. Our printReport
method will generate a table that shows the wins, win percentage, shutouts and shutout percentage for each
player. Here is a sample output:
Summary of 500 games:
wins (% total)
shutouts (% wins)
--------------------------------------------
Player A:
411 82.2%
60 14.6%
Player B:
89 17.8%
7
7.9%
It is easy to print out the headings for this table, but the formatting of the lines takes a little more care.
We want to get the columns lined up nicely, and we must avoid division by zero in calculating the shutout
percentage for a player who didn't get any wins. Let's write the basic method but procrastinate a bit and push
off the details of formatting the line into another method, printLine. The printLine method will need
the player label (A or B), number of wins and shutouts, and the total number of games (for calculation of
percentages).
def printReport(self):
# Print a nicely formatted report
n = self.winsA + self.winsB
print "Summary of", n , "games:"
print
print "
wins (% total)
shutouts (% wins) "
print "--------------------------------------------"
self.printLine("A", self.winsA, self.shutsA, n)
self.printLine("B", self.winsB, self.shutsB, n)12.2. CASE STUDY: RACQUETBALL SIMULATION
205
To finish out the class, we implement the printLine method. This method will make heavy use of
string formatting. A good start is to define a template for the information that will appear in each line.
def printLine(self, label, wins, shuts, n):
template = "Player %s: %4d %5.1f%% %11d %s"
if wins == 0:
# Avoid division by zero!
shutStr = "-----"
else:
shutStr = "%4.1f%%" % (float(shuts)/wins*100)
print template % (label, wins, float(wins)/n*100, shuts, shutStr)
Notice how the shutout percentage is handled. The main template includes it as a string, and the if statement
takes care of formatting this piece to prevent division by zero.
12.2.3 Implementing RBallGame
Now that we have wrapped up the SimStats class, we need to turn our attention to RBallGame. Summa-
rizing what we have decided so far, this class needs a constructor that accepts two probabilities as parameters,
a play method that plays the game, and a getScores method that reports the scores.
What will a racquetball game need to know? To actually play the game, we have to remember the
probability for each player, the score for each player, and which player is serving. If you think about this
carefully, you will see that probability and score are properties related to particular players, while the server
is a property of the game between the two players. That suggests that we might simply consider that a game
needs to know who the players are and which is serving. The players themselves can be objects that know
their probability and score. Thinking about the RBallGame class this way leads us to design some new
objects.
If the players are objects, then we will need another class to define their behavior. Let's name that class
Player. A Player object will keep track of its probability and current score. When a Player is first
created the probability will be supplied as a parameter, but the score will just start out at 0. We'll flesh out
the design of Player class methods as we work on RBallGame.
We are now in a position to define the constructor for RBallGame. The game will need instance variables
for the two players and another variable to keep track of which player is serving.
class RBallGame:
def __init__(self, probA, probB):
self.playerA = Player(probA)
self.playerB = Player(probB)
self.server = self.PlayerA # Player A always serves first
Sometimes it helps to draw a picture to see the relationships among the objects that we are creating.
Suppose we create an instance of RBallGame like this:
theGame = RBallGame(.6,.5)
Figure 12.1 shows an abstract picture of the objects created by this statement and their inter-relationships.
OK, now that we can create an RBallGame, we need to figure out how to play it. Going back to the
dicussion of racquetball from Chapter 9, we need an algorithm that continues to serve rallies and either award
points or change the server as appropriate until the game is over. We can translate this loose algorithm almost
directly into our object-based code.
First, we need a loop that continues as long as the game is not over. Obviously, the decision of whether
the game has ended or not can only be made by looking at the game object itself. Let's just assume that
an appropriate isOver method can be written. The beginning of our play method can make use of this
(yet-to-be-written) method.
def play(self):
while not self.isOver():CHAPTER 12. OBJECT-ORIENTED DESIGN
206
Player
RBallGame
playerA:
prob: 0.6
score: 0
playerB:
server:
Player
prob: 0.5
score: 0
Figure 12.1: Abstract view of RBallGame object.
Inside of the loop, we need to have the serving player serve and, based on the result, decide what to do.
This suggests that Player objects should have a method that performs a serve. After all, whether the serve
is won or not depends on the probability that is stored inside of each player object. We'll just ask the server
if the serve is won or lost.
if self.server.winsServe():
Based on this result, we either award a point or change the server. To award a point, we need to change a
player's score. This again requires the player do something, namely increment the score. Changing servers,
on the other hand, is done at the game level, since this information is kept in the server instance variable
of RBallGame.
Putting it all together, here is our play method:
def play(self):
while not self.isOver():
if self.server.winsServe():
self.server.incScore()
else:
self.changeServer()
As long as you remember that self is an RBallGame, this code should be clear. While the game is not
over, if the server wins a serve, award a point to the server, otherwise change the server.
Of course the price we pay for this simple algorithm is that we now have two new methods (isOver and
changeServer) that need to be implemented in the RBallGame class and two more (winsServer and
incScore) for the Player class.
Before attacking the new methods of the RBallGame class, let's go back and finish up the other top-level
method of the class, namely getScores. This one just returns the scores of the two players. Of course,
we run into the same problem again. It is the player objects that actually know the scores, so we will need a
method that asks a player to return its score.
def getScore(self):
return self.playerA.getScore(), self.playerB.getScore()
This adds one more method to be implemented in the Player class. Make sure you put that on our list to
complete later.
To finish out the RBallGame class, we need to write the isOver and changeServer methods. Given
what we have developed already and our previous version of this program, these methods are straightforward.
I'll leave those as an exercise for you at the moment. If you're looking for my solutions, skip to the complete
code at the end of this section.12.2. CASE STUDY: RACQUETBALL SIMULATION
207
12.2.4 Implementing Player
In developing the RBallGame class, we discovered the need for a Player class that encapsulates the
service probability and current score for a player. The Player class needs a suitable constructor and methods
for winsServe, incScore and getScore.
If you are getting the hang of this object-oriented approach, you should have no trouble coming up with
a constructor. We just need to initialize the instance variables. The player's probability will be passed as a
parameter, and the score starts at 0.
def __init__(self, prob):
# Create a player with this probability
self.prob = prob
self.score = 0
The other methods for our Player class are even simpler. To see if a player wins a serve, we compare
the probability to a random number between 0 and 1.
def winsServe(self):
return random() <= self.prob
To give a player a point, we simply add one to the score.
def incScore(self):
self.score = self.score + 1
The final method just returns the value of the score.
def getScore(self):
return self.score
Initially, you may think that it's silly to create a class with a bunch of one- or two-line methods. Actually,
it's quite common for a well-modularized, objected-oriented program to have lots of trivial methods. The
point of design is to break a problem down into simpler pieces. If those pieces are so simple that their
implementation is obvious, that gives us confidence that we must have gotten it right.
12.2.5 The Complete Program
That pretty much wraps up our object-oriented version of the racquetball simulation. The complete program
follows. You should read through it and make sure you understand exactly what each class does and how it
does it. If you have questions about any parts, go back to the discussion above to figure it out.
# objrball.py -- Simulation of a racquet game.
#
Illustrates design with objects.
from random import random
class Player:
# A Player keeps track of service probability and score
def __init__(self, prob):
# Create a player with this probability
self.prob = prob
self.score = 0
def winsServe(self):
# RETURNS a Boolean that is true with probability self.prob
return random() <= self.probCHAPTER 12. OBJECT-ORIENTED DESIGN
208
def incScore(self):
# Add a point to this player's score
self.score = self.score + 1
def getScore(self):
# RETURNS this player's current score
return self.score
class RBallGame:
# A RBallGame represents a game in progress. A game has two players
# and keeps track of which one is currently serving.
def __init__(self, probA, probB):
# Create a new game having players with the given probs.
self.playerA = Player(probA)
self.playerB = Player(probB)
self.server = self.playerA # Player A always serves first
def play(self):
# Play the game to completion
while not self.isOver():
if self.server.winsServe():
self.server.incScore()
else:
self.changeServer()
def isOver(self):
# RETURNS game is finished (i.e. one of the players has won).
a,b = self.getScores()
return a == 15 or b == 15 or \
(a == 7 and b == 0) or (b==7 and a == 0)
def changeServer(self):
# Switch which player is serving
if self.server == self.playerA:
self.server = self.playerB
else:
self.server = self.playerA
def getScores(self):
# RETURNS the current scores of player A and player B
return self.playerA.getScore(), self.playerB.getScore()
class SimStats:
# SimStats handles accumulation of statistics across multiple
#
(completed) games. This version tracks the wins and shutouts for
#
each player.
def __init__(self):
# Create a new accumulator for a series of games
self.winsA = 0
self.winsB = 0
self.shutsA = 0
self.shutsB = 012.2. CASE STUDY: RACQUETBALL SIMULATION
209
def update(self, aGame):
# Determine the outcome of aGame and update statistics
a, b = aGame.getScores()
if a > b:
# A won the game
self.winsA = self.winsA + 1
if b == 0:
self.shutsA = self.shutsA + 1
else:
# B won the game
self.winsB = self.winsB + 1
if a == 0:
self.shutsB = self.shutsB + 1
def printReport(self):
# Print a nicely formatted report
n = self.winsA + self.winsB
print "Summary of", n , "games:"
print
print "
wins (% total)
shutouts (% wins) "
print "--------------------------------------------"
self.printLine("A", self.winsA, self.shutsA, n)
self.printLine("B", self.winsB, self.shutsB, n)
def printLine(self, label, wins, shuts, n):
template = "Player %s: %4d %5.1f%% %11d %s"
if wins == 0:
# Avoid division by zero!
shutStr = "-----"
else:
shutStr = "%4.1f%%" % (float(shuts)/wins*100)
print template % (label, wins, float(wins)/n*100, shuts, shutStr)
def printIntro():
print "This program simulates games of racquetball between two"
print /*-players called "A" and "B". The ability of each player is.(*
print "indicated by a probability (a number between 0 and 1) that"
print "the player wins the point when serving. Player A always"
print "has the first serve.\n"
def getInputs():
# Returns the three simulation parameters
a = input("What is the prob. player A wins a serve? ")
b = input("What is the prob. player B wins a serve? ")
n = input("How many games to simulate? ")
return a, b, n
def main():
printIntro()
probA, probB, n = getInputs()
# Play the games
stats = SimStats()
for i in range(n):
theGame = RBallGame(probA, probB) # create a new gameCHAPTER 12. OBJECT-ORIENTED DESIGN
210
theGame.play()
stats.update(theGame)
# play it
# get info about completed game
# Print the results
stats.printReport()
main()
raw_input("\nPress <Enter> to quit")
12.3 Case Study: Dice Poker
Back in Chapter 10, I suggested that objects are particularly useful for the design of graphical user interfaces.
I want to finish up this chapter by looking at a graphical application using some of the widgets that we
developed in previous chapters.
12.3.1 Program Specification
Our goal is to write a game program that allows a user to play video poker using dice. The program will
display a hand consisting of five dice. The basic set of rules is as follows:
The player starts with $100.
Each round costs $10 to play. This amount is subtracted from the user's money at the start of the round.
The player initially rolls a completely random hand (i.e., all five dice are rolled).
The player gets two chances to enhance the hand by rerolling some or all of the dice.
At the end of the hand, the player's money is updated according to the following payout schedule:
Hand
Two Pairs
Three of a Kind
Full House (A Pair and a Three of a Kind)
Four of a Kind
Straight (1"!(5 or 2&*!6)
Five of a Kind
Pay
5
8
12
15
20
30
Ultimately, we want this program to present a nice graphical interface. Our interaction will be through
mouse clicks. The interface should have the following characteristics:
The current score (amount of money) is constantly displayed.
The program automatically terminates if the player goes broke.
The player may choose to quit at appropriate points during play.
The interface will present visual cues to indicate what is going on at any given moment and what the
valid user responses are.
12.3.2 Identifying Candidate Objects
Our first step is to analyze the program description and identify some objects that will be useful in attacking
this problem. This is a game involving dice and money. Are either of these good candidates for objects? Both
the money and an individual die can be simply represented as numbers. By themselves, they do not seem to
be good object candidates. However, the game uses five dice, and this sounds like a collection. We will need
to be able to roll all the dice or a selection of dice as well as analyze the collection to see what it scores.
We can encapsulate the information about the dice in a Dice class. Here are a few obvious operations
that this class will have to implement.12.3. CASE STUDY: DICE POKER
211
constructor Create the initial collection.
rollAll Assign random values to each of the five dice.
roll Assign a random value to some subset of the dice, while maintaining the current value of others.
values Return the current values of the five dice.
score Return the score for the dice.
We can also think of the entire program as an object. Let's call the class PokerApp. A PokerApp
object will keep track of the current amount of money, the dice, the number of rolls, etc. It will implement a
run method that we use to get things started and also some helper methods that are used to implement run.
We won't know exactly what methods are needed until we design the main algorithm.
Up to this point, I have concentrated on the actual game that we are implementing. Another component to
this program will be the user interface. One good way to break down the complexity of a more sophisticated
program is to separate the user interface from the main guts of the program. This is often called the model-
view approach. Our program implements some model (in this case, it models a poker game), and the interface
is a view of the current state of the model.
One way of separating out the interface is to encapsulate the decisions about the interface in a separate
interface object. An advantage of this approach is that we can change the look and feel of the program simply
by substituting a different interface object. For example, we might have a text-based version of a progam and
a graphical version.
Let's assume that our program will make use of an interface object, call it a PokerInterface. It's
not clear yet exactly what behaviors we will need from this class, but as we refine the PokerApp class, we
will need to get information from the user and also display information. These will correspond to methods
implemented by the PokerInterface class.
12.3.3 Implementing the Model
So far, we have a pretty good picture of what the Dice class will do and a starting point for implementing
the PokerApp class. We could proceed by working on either of these classes. We won't really be able to try
out the PokerApp class until we have dice, so let's start with the lower-level Dice class.
Implementing Dice
The Dice class implements a collection of dice, which are just changing numbers. The obvious representa-
tion is to use a list of five ints. Our constructor needs to create a list and assign some initial values.
class Dice:
def __init__(self):
self.dice = [0]*5
self.rollAll()
This code first creates a list of five zeroes. These need to be set to some random values. Since we are going
to implement a rollAll function anyway, calling it here saves duplicating that code.
We need methods to roll selected dice and also to roll all of the dice. Since the latter is a special case of
the former, let's turn our attention to the roll function, which rolls a subset. We can specify which dice to
roll by passing a list of indexes. For example, roll([0,3,4]) would roll the dice in positions 0, 3 and 4
of the dice list. We just need a loop that goes through the parameter and generates a new random value for
each position.
def roll(self, which):
for pos in which:
self.dice[pos] = randrange(1,7)
Next, we can use roll to implement rollAll as follows:CHAPTER 12. OBJECT-ORIENTED DESIGN
212
def rollAll(self):
self.roll(range(5))
I used range(5) to generate a list of all the indexes.
The values function is used to return the values of the dice so that they can be displayed. Another
one-liner suffices.
def values(self):
return self.dice[:]
Notice that I created a copy of the dice list by slicing it. That way, if a Dice client modifies the list that
it gets back from values, it will not affect the original copy stored in the Dice object. This defensive
programming prevents other parts of the code from accidently messing with our object.
Finally, we come to the score method. This is the function that will determine the worth of the current
dice. We need to examine the values and determine whether we have any of the patterns that lead to a payoff,
namely Five of a Kind, Four of a Kind, Full House, Three of a Kind, Two Pairs, or Straight. Our function
will need some way to indicate what the payoff is. Let's return a string labeling what the hand is and an int
that gives the payoff amount.
We can think of this function as a multi-way decision. We simply need to check for each possible hand.
If we do so in a sensible order, we can guarantee giving the correct payout. For example, a full house also
contains a three of a kind. We need to check for the full house before checking for three of a kind, since the
full house is more valuable.
One simple way of checking the hand is to generate a list of the counts of each value. That is, counts[i]
will be the number of times that the value i occurs in dice. If the dice are: [3,2,5,2,3] then the count
list would be [0,0,2,2,0,1,0]. Notice that counts[0] will always be zero, since dice values are in
the range 1#%$6. Checking for various hands can then be done by looking for various values in counts. For
example, if counts contains a 3 and a 2, the hand contains a triple and a pair, and hence, is a full house.
Here's the code:
def score(self):
# Create the counts list
counts = [0] * 7
for value in self.dice:
counts[value] = counts[value] + 1
# score the hand
if 5 in counts:
return "Five of a Kind", 30
elif 4 in counts:
return "Four of a Kind", 15
elif (3 in counts) and (2 in counts):
return "Full House", 12
elif 3 in counts:
return "Three of a Kind", 8
elif not (2 in counts) and (counts[1]==0 or counts[6] == 0):
return "Straight", 20
elif counts.count(2) == 2:
return "Two Pairs", 5
else:
return "Garbage", 0
The only tricky part is the testing for straights. Since we have already checked for 5, 4 and 3 of a kind,
checking that there are no pairs not 2 in counts guarantees that the dice show five distinct values. If
there is no 6, then the values must be 1%!"5; likewise, no 1 means the values must be 2#-"6.
At this point, we could try out the Dice class to make sure that it is working correctly. Here is a short
interaction showing some of what the class can do:12.3. CASE STUDY: DICE POKER
213
>>> from dice import Dice
>>> d = Dice()
>>> d.values()
[6, 3, 3, 6, 5]
>>> d.score()
(-,%Two Pairs),., 5)
>>> d.roll([4])
>>> d.values()
[6, 3, 3, 6, 4]
>>> d.roll([4])
>>> d.values()
[6, 3, 3, 6, 3]
>>> d.score()
(/+$Full House&#&, 12)
We would want to be sure that each kind of hand scores properly.
Implementing PokerApp
Now we are ready to turn our attention to the task of actually implementing the poker game. We can use
top-down design to flesh out the details and also suggest what methods will have to be implemented in the
PokerInterface class.
Initially, we know that the PokerApp will need to keep track of the dice, the amount of money, and
some user interface. Let's initialize these values in the constructor.
class PokerApp:
def __init__(self):
self.dice = Dice()
self.money = 100
self.interface = PokerInterface()
To run the program, we will create an instance of this class and call its run method. Basically, the
program will loop, allowing the user to continue playing hands until he or she is either out of money or
chooses to quit. Since it costs $10 to play a hand, we can continue as long as self.money >= 10.
Determining whether the user actually wants to play another hand must come from the user interface. Here
is one way we might code the run method:
def run(self):
while self.money >= 10 and self.interface.wantToPlay():
self.playRound()
self.interface.close()
Notice the call to interface.close at the bottom. This will allow us to do any necessary cleaning up
such as printing a final message for the user or closing a graphics window.
Most of the work of the program has now been pushed into the playRound method. Let's continue the
top-down process by focusing our attention here. Each round will consist of a series of rolls. Based on these
rolls, the program will have to adjust the player's score.
def playRound(self):
self.money = self.money - 10
self.interface.setMoney(self.money)
self.doRolls()
result, score = self.dice.score()
self.interface.showResult(result, score)
self.money = self.money + score
self.interface.setMoney(self.money)CHAPTER 12. OBJECT-ORIENTED DESIGN
214
This code only really handles the scoring aspect of a round. Anytime new information must be shown to the
user, a suitable method from interface is invoked. The $10 fee to play a round is first deducted and the
interface is updated with the new amount of money remaining. The program then processes a series of rolls
(doRolls), shows the user the result, and updates the amount of money accordingly.
Finally, we are down to the nitty-gritty details of implementing the dice rolling process. Initially, all of
the dice will be rolled. Then we need a loop that continues rolling user-selected dice until either the user
chooses to quit rolling or the limit of three rolls is reached. Let's use a local variable rolls to keep track of
how many times the dice have been rolled. Obviously, displaying the dice and getting the the list of dice to
roll must come from interaction with the user through interface.
def doRolls(self):
self.dice.rollAll()
roll = 1
self.interface.setDice(self.dice.values())
toRoll = self.interface.chooseDice()
while roll < 3 and toRoll != []:
self.dice.roll(toRoll)
roll = roll + 1
self.interface.setDice(self.dice.values())
if roll < 3:
toRoll = self.interface.chooseDice()
At this point, we have completed the basic functions of our interactive poker program. That is, we have a
model of the process for playing poker. We can't really test out this program yet, however, because we don't
have a user interface.
12.3.4 A Text-Based UI
In designing PokerApp we have also developed a specification for a generic PokerInterface class. Our
interface must support the methods for displaying information: setMoney, setDice, and showResult.
It must also have methods that allow for input from the user: wantToPlay, and chooseDice. These
methods can be implemented in many different ways, producing programs that look quite different even
though the underlying model, PokerApp, remains the same.
Usually, graphical interfaces are much more complicated to design and build than text-based ones. If we
are in a hurry to get our application running, we might first try building a simple text-based interface. We can
use this for testing and debugging of the model without all the extra complication of a full-blown GUI.
First, let's tweak our PokerApp class a bit so that the user interface is supplied as a parameter to the
constructor.
class PokerApp:
def __init__(self, interface):
self.dice = Dice()
self.money = 100
self.interface = interface
Then we can easily create versions of the poker program using different interfaces.
Now let's consider a bare-bones interface to test out the poker program. Our text-based version will not
present a finished application, but rather, give us a minimalist interface solely to get the program running.
Each of the necessary methods can be given a trivial implementation.
Here is a complete TextInterface class using this approach:
# file: textpoker.py
class TextInterface:
def __init__(self):
print "Welcome to video poker."12.3. CASE STUDY: DICE POKER
215
def setMoney(self, amt):
print "You currently have $%d." % (amt)
def setDice(self, values):
print "Dice:", values
def wantToPlay(self):
ans = raw_input("Do you wish to try your luck? ")
return ans[0] in "yY"
def close(self):
print "\nThanks for playing!"
def showResult(self, msg, score):
print "%s. You win $%d." % (msg, score)
def chooseDice(self):
return input("Enter list of which to change ([] to stop) ")
Using this interface, we can test out our PokerApp program to see if we have implemented a correct
model. Here is a complete program making use of the modules that we have developed:
# textpoker.py -- video dice poker using a text-based interface.
from pokerapp import PokerApp
from textinter import TextInterface
inter = TextInterface()
app = PokerApp(inter)
app.run()
Basically, all this program does is create a text-based interface and then build a PokerApp using this inter-
face and start it running.
Running this program, we get a rough but useable interaction.
Welcome to video poker.
Do you wish to try your luck?
You currently have $90.
Dice: [6, 4, 4, 2, 4]
Enter list of which to change
Dice: [1, 4, 4, 2, 2]
Enter list of which to change
Dice: [2, 4, 4, 2, 2]
Full House. You win $12.
You currently have $102.
Do you wish to try your luck?
You currently have $92.
Dice: [5, 6, 4, 4, 5]
Enter list of which to change
Dice: [5, 5, 4, 4, 5]
Enter list of which to change
Full House. You win $12.
You currently have $104.
Do you wish to try your luck?
You currently have $94.
y
([] to stop) [0,4]
([] to stop) [0]
y
([] to stop) [1]
([] to stop) []
y216
CHAPTER 12. OBJECT-ORIENTED DESIGN
Dice: [3, 2, 1, 1, 1]
Enter list of which to change ([] to stop) [0,1]
Dice: [5, 6, 1, 1, 1]
Enter list of which to change ([] to stop) [0,1]
Dice: [1, 5, 1, 1, 1]
Four of a Kind. You win $15.
You currently have $109.
Do you wish to try your luck? n
Thanks for playing!
You can see how this interface provides just enough so that we can test out the model. In fact, we've got a
game that's already quite a bit of fun to play!
12.3.5 Developing a GUI
Now that we have a working program, let's turn our attention to a nicer graphical interface. Our first step must
be to decide exactly how we want our interface to look and function. The interface will have to support the
various methods found in the text-based version and will also probably have some additional helper methods.
Designing the Interaction
Let's start with the basic methods that must be supported and decide exactly how interaction with the user
will occur. Clearly, in a graphical interface, the faces of the dice and the current score should be continuously
displayed. The setDice and setMoney methods will be used to change those displays. That leaves
one output method, showResult, that we need to accommodate. One common way to handle this sort of
tranisent information is with a message at the bottom of the window. This is sometimes called a status bar.
To get information from the user, we will make use of buttons. In wantToPlay, the user will have to
decide between either rolling the dice or quitting. We could include *(-Roll Dice+)% and #.'Quit*(+ buttons for this
choice. That leaves us with figuring out how the user should choose dice.
To implement chooseDice, we could provide a button for each die and have the user click the buttons
for the dice they want to roll. When the user is done choosing the dice, they could click the %$+Roll Dice&&!
button again to roll the selected dice. Elaborating on this idea, it would be nice if we allowed the user to
change his or her mind while selecting the dice. Perhaps clicking the button of a currently selected die would
cause it to become unselected. The clicking of the button will serve as a sort of toggle that selects/unselects
a particular die. The user commits to a certain selection by clicking on '*,Roll Dice.##/
Our vision for chooseDice suggests a couple of tweaks for the interface. First, we should have some
way of showing the user which dice are currently selected. There are lots of ways we could do this. One
simple approach would be to change the color of the die. Let's ""+gray out,.% the pips on the dice selected for
rolling. Second, we need a good way for the user to indicate that they wish to stop rolling. That is, they
would like the dice scored just as they stand. We could handle this by having them click the "/,Roll Dice'*,
button when no dice are selected, hence asking the program to roll no dice. Another approach would be to
provide a separate button to click that causes the dice to be scored. The latter approach seems a bit more
intuitive/informative. Let's add a +$"Score"%! button to the interface.
Now we have a basic idea of how the interface will function. We still need to figure out how it will look.
What is the exact layout of the widgets? Figure 12.2 is a sample of how the interface might look. I'm sure
those of you with a more artisitic eye can come up with a more pleasing interface, but we'll use this one as
our working design.
Managing the Widgets
The graphical interface that we are developing makes use of buttons and dice. Our intent is to resue the
Button and DieView classes for these widgets that were developed in previous chapters. The Button
class can be used as is, and since we have quite a number of buttons to manage, we can use a list of Buttons,
similar to the approach we used in the calculator program from Chapter 11.12.3. CASE STUDY: DICE POKER
217
Figure 12.2: GUI interface for video dice poker.
Unlike the buttons in the calculator program, the buttons of our poker interface will not be active all of the
time. For example, the dice buttons will only be active when the user is actually in the process of choosing
dice. When user input is required, the valid buttons for that interaction will be set active and the others will be
inactive. To implement this behavior, we can add a helper method called choose to the PokerInterface
class.
The choose method takes a list of button labels as a parameter, activates them, and then waits for the
user to click one of them. The return value of the function is the label of the button that was clicked. We can
call the choose method whenever we need input from the user. For example, if we are waiting for the user
to choose either the %)$Roll Dice'.! or '&*Quit+/$ button, we would use a sequence of code like this:
choice = self.choose(["Roll Dice", "Quit"])
if choice == "Roll Dice":
...
Assuming the buttons are stored in an instance variable called buttons, here is one possible implemen-
tation of choose:
def choose(self, choices):
buttons = self.buttons
# activate choice buttons, deactivate others
for b in buttons:
if b.getLabel() in choices:
b.activate()
else:
b.deactivate()
# get mouse clicks until an active button is clicked
while 1:
p = self.win.getMouse()
for b in buttons:CHAPTER 12. OBJECT-ORIENTED DESIGN
218
if b.clicked(p):
return b.getLabel()
# function exit here.
The other widgets in our interface will be our DieView that we developed in the last two chapters.
Basically, we will use the same class as before, but we need to add just a bit of new functionality. As
discussed above, we want to change the color of a die to indicate whether it is selected for rerolling.
You might want to go back and review the DieView class. Remember, the class contructor draws
a square and seven circles to represent the positions where the pips of various values will appear. The
setValue method turns on the appropriate pips to display a given value. To refresh your memory a bit,
here is the setValue method as we left it:
def setValue(self, value):
# Turn all the pips off
for pip in self.pips:
pip.setFill(self.background)
# Turn the appropriate pips back on
for i in self.onTable[value]:
self.pips[i].setFill(self.foreground)
We need to modify the DieView class by adding a setColor method. This method will be used to
change the color that is used for drawing the pips. As you can see in the code for setValue, the color of
the pips is determined by the value of the instance variable foreground. Of course, changing the value of
foregroud will not actually change the appearance of the die until it is redrawn using the new color.
The algorithm for setColor seems straightforward. We need two steps:
change foreground to the new color
redraw the current value of the die
Unfortunately, the second step presents a slight snag. We already have code that draws a value, namely
setValue. But setValue requires us to send the value as a parameter, and the current version of
DieView does not store this value anywhere. Once the proper pips have been turned on, the actual value is
discarded.
In order to implement setColor, we need to tweak setValue so that it remembers the current value.
Then setColor can redraw the die using its current value. The change to setValue is easy; we just need
to add a single line.
self.value = value
This line stores the value parameter in an instance variable called value.
With the modified version of setValue, implementing setColor is a breeze.
def setColor(self, color):
self.foreground = color
self.setValue(self.value)
Notice how the last line simply calls setValue to (re)draw the die, passing along the value that was saved
from the last time setValue was called.
Creating the Interface
Now that we have our widgets under control, we are ready to actually implement our GUI poker interface.
The constructor will create all of our widgets, setting up the interface for later interactions.
class GraphicsInterface:
def __init__(self):
self.win = GraphWin("Dice Poker", 600, 400)
self.win.setBackground("green3")12.3. CASE STUDY: DICE POKER
219
banner = Text(Point(300,30), "Python Poker Parlor")
banner.setSize(24)
banner.setFill("yellow2")
banner.setStyle("bold")
banner.draw(self.win)
self.msg = Text(Point(300,380), "Welcome to the Dice Table")
self.msg.setSize(18)
self.msg.draw(self.win)
self.createDice(Point(300,100), 75)
self.buttons = []
self.addDiceButtons(Point(300,170), 75, 30)
b = Button(self.win, Point(300, 230), 400, 40, "Roll Dice")
self.buttons.append(b)
b = Button(self.win, Point(300, 280), 150, 40, "Score")
self.buttons.append(b)
b = Button(self.win, Point(570,375), 40, 30, "Quit")
self.buttons.append(b)
self.money = Text(Point(300,325), "$100")
self.money.setSize(18)
self.money.draw(self.win)
You should compare this code to Figure 12.2 to make sure you understand how the elements of the interface
are created and positioned.
I hope you noticed that I pushed the creation of the dice and their associated buttons into a couple of
helper methods. Here are the necessary definitions:
def createDice(self, center, size):
center.move(-3*size,0)
self.dice = []
for i in range(5):
view = DieView(self.win, center, size)
self.dice.append(view)
center.move(1.5*size,0)
def addDiceButtons(self, center, width, height):
center.move(-3*width, 0)
for i in range(1,6):
label = "Die %d" % (i)
b = Button(self.win, center, width, height, label)
self.buttons.append(b)
center.move(1.5*width, 0)
These two methods are similar in that they employ a loop to draw five similar widgets. In both cases, a
Point variable, center, is used to calculate the correct position of the next widget.
Implementing the Interaction
You might be a little scared at this point that the constructor for our GUI interface was so complex. Even
simple graphical interfaces involve many independent components. Getting them all set up and initialized is
often the most tedious part of coding the interface. Now that we have that part out of the way, actually writing
the code that handles the interaction will not be too hard, provided we attack it one piece at a time.
Let's start with the simple output methods setMoney and showResult. These two methods display
some text in our interface window. Since our constructor took care of creating and positioning the relevant
Text objects, all our methods have to do is call the setText methods for the appropriate objects.
def setMoney(self, amt):220
CHAPTER 12. OBJECT-ORIENTED DESIGN
self.money.setText("$%d" % (amt))
def showResult(self, msg, score):
if score > 0:
text = "%s! You win $%d" % (msg, score)
else:
text = "You rolled %s" % (msg)
self.msg.setText(text)
In a similar spirit, the output method setDice must make a call to the setValue method of the
approriate DieView objects in dice. We can do this with a for loop.
def setDice(self, values):
for i in range(5):
self.dice[i].setValue(values[i])
Take a good look at the line in the loop body. It sets the ith die to show the ith value.
As you can see, once the interface has been constructed, making it functional is not overly difficult.
Our output methods are completed with just a few lines of code. The input methods are only slightly more
complicated.
The wantToPlay method will wait for the user to click either *!&Roll Dice,-+ or !&#Quit.$$$ We can use our
choose helper method to do this.
def wantToPlay(self):
ans = self.choose(["Roll Dice", "Quit"])
self.msg.setText("")
return ans == "Roll Dice"
After waiting for the user to click an appropriate button, this method then clears out any message, such as
the previous results, by setting the msg text to the empty string. The method then returns a Boolean value by
examining the label returned by choose.
That brings us to the chooseDice method. Here we must implement a more extensive user interaction.
The chooseDice method returns a list of the indexes of the dice that the user wishes to roll.
In our GUI, the user will choose dice by clicking on corresponding buttons. We need to maintain a list of
which dice have been chosen. Each time a die button is clicked, that die is either chosen (its index is appended
to the list) or unchosen (its index is removed from the list). In addition, the color of the corresponding
DieView reflects the status of the die. The interaction ends when the user clicks either the roll button or the
score button. If the roll button is clicked, the method returns the list of currently chosen indexes. If the score
button is clicked, the function returns an empty list to signal that the player is done rolling.
Here is one way to implement the choosing of dice. The comments in this code explain the algorithm:
def chooseDice(self):
# choices is a list of the indexes of the selected dice
choices = []
# No dice chosen yet
while 1:
# wait for user to click a valid button
b = self.choose(["Die 1", "Die 2", "Die 3", "Die 4", "Die 5",
"Roll Dice", "Score"])
if b[0] == "D":
# User clicked a die button
i = eval(b[4]) - 1
# Translate label to die index
if i in choices:
# Currently selected, unselect it
choices.remove(i)
self.dice[i].setColor("black")
else:
# Currently unselected, select it
choices.append(i)12.4. OO CONCEPTS
221
self.dice[i].setColor("gray")
else:
# User clicked Roll or Score
for d in self.dice:
# Revert appearance of all dice
d.setColor("black")
if b == "Score":
# Score clicked, ignore choices
return []
elif choices != []:
# Don't accept Roll unless some
return choices
#
dice are actually selected
That about wraps up our program. The only missing piece of our interface class is the close method.
To close up the graphical version, we just need to close the graphics window.
def close(self):
self.win.close()
Finally, we need a few lines to actually get our graphical poker playing program started. This code is
exactly like the start code for the textual version, except that we use a GraphicsInterface in place of
the TextInterface.
inter = GraphicsInterface()
app = PokerApp(inter)
app.run()
We now have a complete, useable video dice poker game. Of course, our game is lacking a lot of bells and
whistles such as printing a nice introduction, providing help with the rules, and keeping track of high scores.
I have tried to keep this example relatively simple, while still illustrating important issues in the design of
GUIs using objects. Improvements are left as exercises for you. Have fun with them!
12.4 OO Concepts
My goal for the racquetball and video poker case studies was to give you a taste for what OOD is all about.
Actually, what you've seen is only a distillation of the design process for these two programs. Basically, I have
walked you through the algorithms and rationale for two completed designs. I did not document every single
decision, false start and detour along the way. Doing so would have at least tripled the size of this (already
long) chapter. You will learn best by making your own decisions and discovering your own mistakes, not by
reading about mine.
Still, these smallish examples illustrate much of the power and allure of the object-oriented approach.
Hopefully you can see why OO techniques are becoming standard practice in software development. The
bottom-line is that the OO approach helps us to produce complex software that is more reliable and cost-
effective. However, I still have not defined exactly what counts as objected-oriented development.
Most OO gurus talk about three features that together make development truly object-oriented: encapsu-
lation, polymorphism and inheritance. I don't want to belabor these concepts too much, but your introduction
to object-oriented design and programming would not be complete without at least some understanding of
what is meant by these terms.
12.4.1 Encapsulation
I have already mentioned the term encapsulation in previous discussion of objects. As you know, objects
know stuff and do stuff. They combine data and operations. This process of packaging some data along with
the set of operations that can be performed on the data is called encapsulation.
Encapsulation is one of the major attractions of using objects. It provides a convenient way to compose
complex problems that corresponds to our intuitive view of how the world works. We naturally think of the
world around us as consisiting of interacting objects. Each object has its own identity, and knowing what
kind of object it is allows us to understand its nature and capabilities. I look out my window and I see houses,
cars and trees, not a swarming mass of countless molecules or atoms.222
CHAPTER 12. OBJECT-ORIENTED DESIGN
From a design standpoint, encapsulation also provides a critical service of separating the concerns of
//(what!(, vs. !$-how.+++ The actual implementation of an object is independent of its use. The implementation
can change, but as long as the interface is preserved, other components that rely on the object will not break.
Encapsulation allows us to isolate major design decisions, especially ones that are subject to change.
Another advantage of encapsulation is that it supports code reuse. It allows us to package up general
components that can be used from one program to the next. The DieView class and Button classes are
good examples of reuseable components.
Encapsulation is probably the chief benefit of using objects, but alone, it only makes a system object-
based. To be truly objected-oriented, the approach must also have the characteristics of polymorphism and
inheritance.
12.4.2 Polymorphism
Literally, the word polymorphism means +)(many forms.,$( When used in object-oriented literature, this refers
to the fact that what an object does in response to a message (a method call) depends on the type or class of
the object.
Our poker program illustrated one aspect of polymorphism. The PokerApp class was used both with
a TextInterface and a GraphicsInterface. There were two different forms of interface, and the
PokerApp class could function quite well with either. When the PokerApp called the showDice method,
for example, the TextInterface showed the dice one way and the GraphicsInterface did it an-
other.
In our poker example, we used either the text interface or the graphics interface. The remarkable thing
about polymorphism, however, is that a given line in a program may invoke a completely different method
from one moment to the next. As a simple example, suppose you had a list of graphics objects to draw on the
screen. The list might contain a mixture of Circle, Rectangle, Polygon, etc. You could draw all the
items in a list with this simple code:
for obj in objects:
obj.draw(win)
Now ask yourself, what operation does this loop actually execute? When obj is a circle, it executes the
draw method from the circle class. When obj is a rectangle, it is the draw method from the rectangle class,
etc.
Polymorphism gives object-oriented systems the flexibility for each object to perform an action just the
way that it should be performed for that object. Before object orientation, this kind of flexibility was much
harder to achieve.
12.4.3 Inheritance
The third important property for object-oriented approaches, inheritance, is one that we have not yet used.
The idea behind inheritance is that a new class can be defined to borrow behavior from another class. The
new class (the one doing the borrowing) is called a subclass, and the existing class (the one being borrowed
from) is its superclass.
For example, if we are building a system to keep track of employees, we might have a general class
Employee that contains the general information that is common to all employees. One example attribute
would be a homeAddress method that returns the home address of an employee. Within the class of all
employees, we might distinguish between SalariedEmployee and HourlyEmployee. We could make
these subclasses of Employee, so they would share methods like homeAddress. However, each subclass
would have its own monthlyPay function, since pay is computed differently for these different classes of
employees.
Inheritance provides two benefits. One is that we can structure the classes of a system to avoid duplication
of operations. We don't have to write a separate homeAddress method for the HourlyEmployee and
SalariedEmployee classes. A closely related benefit is that new classes can often be based on existing
classes, promoting code reuse.12.5. EXERCISES
223
We could have used inheritance to build our poker program. When we first wrote the DieView class,
it did not provide a way of changing the appearance of the die. We solved this problem by modifying the
original class definition. An alternative would have been to leave the original class unchanged and create
a new subclass ColorDieView. A ColorDieView is just like a DieView except that it contains an
additional method that allows us to change its color. Here is how it would look in Python:
class ColorDieView(DieView):
def setValue(self, value):
self.value = value
DieView.setValue(self, value)
def setColor(self, color):
self.foreground = color
self.setValue(self.value)
The first line of this definition says that we are defining a new class ColorDieView that is based
on (i.e., a subclass of) DieView. Inside the new class, we define two methods. The second method,
setColor, adds the new operation. Of course, in order to make setColor work, we also need to modify
the setValue operation slightly.
The setValue method in ColorDieView redefines or overrides the definition of setValue that was
provided in the DieView class. The setValue method in the new class first stores the value and then relies
on the setValue method of the superclass DieView to actually draw the pips. Notice especially how the
call to the method from the superclass is made. The normal approach self.setValue(value) would re-
fer to the setValue method of the ColorDieView class, since self is an instance of ColorDieView.
In order to call the original setValue method from the superclass, it is necessary to put the class name
where the object would normally go.
DieView.setValue(self,value)
The actual object to which the method is applied is then sent as the first parameter.
12.5 Exercises
1. In your own words, describe the process of OOD.
2. In your own words, define encapsulation, polymorphism and inheritance.
3. Add bells and whistles to the Poker Dice game.
4. Redo any of the design problems from Chapter 9 using OO techniques.
5. Find the rules to an interesting dice game and write an interactive program to play it. Some examples
are Craps, Yacht, Greed and Skunk.
6. Write a program that deals four bridge hands, counts how many points they have and gives opening
bids.
7. Find a simple card game that you like and implement an interactive program to play that game. Some
possibilities are War, Blackjack, various solitaire games, and Crazy Eights.
8. Write an interactive program for a board game. Some examples are Othello(Reversi), Connect Four,
Battleship, Sorry!, and Parcheesi.224
CHAPTER 12. OBJECT-ORIENTED DESIGNChapter 13
Algorithm Analysis and Design
If you have worked your way through to this point in the book, you are well on the way to becoming a
programmer. Way back in Chapter 1, I discussed the relationship between programming and the study of
computer science. Now that you have some programming skills, you are ready to start considering the
broader issues in the field. Here we will take up one of the central issues, namely the design and analysis of
algorithms.
13.1 Searching
Let's begin by considering a very common and well-studied programming problem: search. Search is the
process of looking for a particular value in a collection. For example, a program that maintains the member-
ship list for a club might need to look up the information about a particular member. This involves some form
of search process.
13.1.1 A Simple Searching Problem
To make the discussion of searching algorithms as simple as possible, let's boil the problem down to its
essential essence. Here is the specification of a simple searching function:
def search(x,
# nums is
# RETURNS
#
x is
nums):
a list of numbers and x is a number
the position in the list where x occurs or -1 if
not in the list.
Here are a couple interactive examples that illustrate its behavior:
>>> search(4, [3, 1, 4, 2, 5])
2
>>> search(7, [3, 1, 4, 2, 5])
-1
In the first example, the function returns the index where 4 appears in the list. In the second example, the
return value -1 indicates that 7 is not in the list.
You may recall from our discussion of list operations that Python actually provides a number of built-in
search-related methods. For example, we can test to see if a value appears in a sequence using in.
if x in nums:
# do something
If we want to know the position of x in a list, the index method fills the bill nicely.
225CHAPTER 13. ALGORITHM ANALYSIS AND DESIGN
226
>>> nums = [3,1,4,2,5]
>>> nums.index(4)
2
In fact, the only difference between our search function and index is that the latter raises an exception if
the target value does not appear in the list. We could implement the search function using index by simply
catching the exception and returning -1 for that case.
def search(x, nums):
try:
return nums.index(x)
except:
return -1
This approach begs the question, however. The real issue is how does Python actually search the list? What
is the algorithm?
13.1.2 Strategy 1: Linear Search
Let's try our hand at developing a search algorithm using a simple !./be the computer-*$ strategy. Suppose that
I gave you a page full of numbers in no particular order and asked whether the number 13 is in the list. How
would you solve this problem? If you are like most people, you would simply scan down the list comparing
each value to 13. When you see 13 in the list, you quit and tell me that you found it. If you get to the very
end of the list without seeing 13, then you tell me it's not there.
This strategy is called a linear search. You are searching through the list of items one by one until the
target value is found. This algorithm translates directly into simple code.
def search(x, nums):
for i in range(len(nums)):
if nums[i] == x:
# item found, return the index value
return i
return -1
# loop finished, item was not in list
This algorithm was not hard to develop, and it will work very nicely for modest-sized lists. For an
unordered list, this algorithm is as good as any. The Python in and index operators both implement linear
searching algorithms.
If we have a very large collection of data, we might want to organize it in some way so that we don't have
to look at every single item to determine where, or if, a particular value appears in the list. Suppose that the
list is stored in sorted order (lowest to highest). As soon as we encounter a value that is greater than the target
value, we can quit the linear search without looking at the rest of the list. On average, that saves us about half
of the work. But, if the list is sorted, we can do even better than this.
13.1.3 Strategy 2: Binary Search
When a list is ordered, there is a much better searching strategy, one that you probably already know. Have
you ever played the number guessing game? I pick a number between 1 and 100, and you try to guess what
it is. Each time you guess, I will tell you if your guess is correct, too high, or too low. What is your stategy?
If you play this game with a very young child, they might well adopt a strategy of simply guessing
numbers at random. An older child might employ a systematic approach corresponding to linear search,
guessing 1 (#* 2 *&- 3 .-$ 4
until the mystery value is found.
Of course, virtually any adult will first guess 50. If told that the number is higher, then the range of
possible values is 50--$100. The next logical guess is 75. Each time we guess the middle of the remaining
range to try to narrow down the possible range. This strategy is called a binary search. Binary means two,
and at each step, we are dividing the possible range into two parts.
We can employ a binary search strategy to look through a sorted list. The basic idea is that we use two
variables to keep track of the endpoints of the range in the list where the item could be. Initially, the target13.1. SEARCHING
227
could be anywhere in the list, so we start with variables low and high set to the first and last positions of
the list, respectively.
The heart of the algorithm is a loop that looks at the item in the middle of the remaining range to compare
it to x. If x is smaller than the middle item, then we move top, so that the search is narrowed to the lower
half. If x is larger, then we move low, and the search is narrowed to the upper half. The loop terminates
when x is found or there are no longer any more places to look (i.e., low > high). Here is the code.
def search(x, nums):
low = 0
high = len(nums) - 1
while low <= high:
mid = (low + high) / 2
item = nums[mid]
if x == item :
return mid
elif x < item:
high = mid - 1
else:
low = mid + 1
return -1
# There is still a range to search
# position of middle item
# Found it! Return the index
# x is in lower half of range
#
move top marker down
# x is in upper half
#
move bottom marker up
# no range left to search, x is not there
This algorithm is quite a bit more sophisticated than the simple linear search. You might want to trace
through a couple of example searches to convince yourself that it actually works.
13.1.4 Comparing Algorithms
So far, we have developed two solutions to our simple searching problem. Which one is better? Well, that
depends on what exactly we mean by better. The linear search algorithm is much easier to understand and
implement. On the other hand, we expect that the binary seach is more efficient, because it doesn't have to
look at every value in the list. Intuitively, then, we might expect the linear search to be a better choice for
small lists and binary search a better choice for larger lists. How could we actually confirm such intuitions?
One approach would be to do an empirical test. We could simply code up both algorithms and try them
out on various sized lists to see how long the search takes. These algorithms are both quite short, so it
would not be difficult to run a few experiments. When I tested the algorithms on my particular computer (a
somewhat dated laptop), linear search was faster for lists of length 10 or less, and there was no significant
difference in the range of length 10!&'1000. After that, binary search was a clear winner. For a list of a million
elements, linear search averaged 2.5 seconds to find a random value, whereas binary search averaged only
0.0003 seconds.
The empirical analysis has confirmed our intuition, but these are results from one particular machine
under specific circumstances (amount of memory, processor speed, current load, etc.). How can we be sure
that the results will always be the same?
Another approach is to analyze our algorithms abstractly to see how efficient they are. Other factors being
equal, we expect the algorithm with the fewest number of %!)steps!$# to be the more efficient. But how do we
count the number of steps? For example, the number of times that either algorithm goes through its main loop
will depend on the particular inputs. We have already guessed that the advantage of binary search increases
as the size of the list increases.
Computer scientists attack these problems by analyzing the number of steps that an algorithm will take
relative to the size or difficulty of the specific problem instance being solved. For searching, the difficulty is
determined by the size of the collection. Obviously, it takes more steps to find a number in a collection of a
million than it does in a collection of ten. The pertinent question is how many steps are needed to find a value
in a list of size n. We are particularly interested in what happens as n gets very large.
Let's consider the linear search first. If we have a list of ten items, the most work our algorithm might
have to do is to look at each item in turn. The loop will iterate at most ten times. Suppose the list is twice as
big. Then we might have to look at twice as many items. If the list is three times as large, it will take threeCHAPTER 13. ALGORITHM ANALYSIS AND DESIGN
228
times as long, etc. In general, the amount of time required is linearly related to the size of the list n. This is
what computer scientists call a linear time algorithm. Now you really know why it's called a linear search.
What about the binary search? Let's start by considering a concrete example. Suppose the list contains
sixteen items. Each time through the loop, the remaining range is cut in half. After one pass, there are eight
items left to consider. The next time through there will be four, then two, and finally one. How many times
will the loop execute? It depends on how many times we can halve the range before running out of data. This
table might help you to sort things out:
List size
1
2
4
8
16
Halvings
0
1
2
3
4
Can you see the pattern here? Each extra iteration of the loop doubles the size of the list. If the binary
search loops i times, it can find a single value in a list of size 2 i . Each time through the loop, it looks at
one value (the middle) in the list. To see how many items are examined in a list of size n, we need to solve
this relationship: n 2 i for i. In this formula, i is just an exponent with a base of 2. Using the appropriate
logarithm gives us this relationship: i log 2 n. If you are not entirely comfortable with logarithms, just
remember that this value is the number of times that a collection of size n can be cut in half.
OK, so what does this bit of math tell us? Binary search is an example of a log time algorithm. The
amount of time it takes to solve a given problem grows as the log of the problem size. In the case of binary
search, each additional iteration doubles the size of the problem that we can solve.
You might not appreciate just how efficient binary search really is. Let me try to put it in perspective.
Suppose you have a New York City phone book with, say, twelve million names listed in alphabetical order.
You walk up to a typical New Yorker on the street and make the following proposition (assuming their number
is listed): I'm going to try guessing your name. Each time I guess a name, you tell me if your name comes
alphabetically before or after the name I guess. How many guesses will you need?
Our analysis above shows the answer to this question is log 2 12 //& 000 .'+ 000. If you don't have a calculator
handy, here is a quick way to estimate the result. 2 10 1024 or roughly 1000, and 1000x1000 1 .$- 000 "$/ 000.
That means that 2 10 x2 10 2 20 1 #%, 000 (*) 000. That is, 2 20 is approximately one million. So, searching a
million items requires only 20 guesses. Continuting on, we need 21 guesses for two million, 22 for four
million, 23 for eight million, and 24 guesses to search among sixteen million names. We can figure out the
name of a total stranger in New York City using only 24 guesses! By comparison, a linear search would
require (on average) 6 million guesses. Binary search is a phenomenally good algorithm!
I said earlier that Python uses a linear search algorithm to implement its built-in searching methods. If a
binary search is so much better, why doesn't Python use it? The reason is that the binary search is less general;
in order to work, the list must be in order. If you want to use binary search on an unordered list, the first thing
you have to do is put it in order or sort it. This is another well-studied problem in computer science, and
one that we should look at. Before we turn to sorting, however, we need to generalize the algorithm design
technique that we used to develop the binary search.
13.2 Recursive Problem-Solving
Remember the basic idea behind the binary search algorithm was to sucessively divide the problem in half.
This is sometimes referred to as a #..divide and conquer&'$ approach to algorithm design, and it often leads to
very efficient algorithms.
One interesting aspect of divide and conquer alorithms is that the original problem divides into subprob-
lems that are just smaller versions of the original. To see what I mean, think about the binary search again.
Initially, the range to search is the entire list. Our first step is to look at the middle item in the list. Should the
middle item turn out to be the target, then we are finished. If it is not the target, we continue by performing
binary search on either the top-half or the bottom half of the list.
Using this insight, we might express the binary search algorithm in another way.13.2. RECURSIVE PROBLEM-SOLVING
229
Algorithm: binarySearch -- search for x in range nums[low] to nums[high]
mid = (low + high) / 2
if low > high
x is not in nums
elif x < nums[mid]
perform binary search for x in range nums[low] to nums[mid-1]
else
perform binary search for x in range nums[mid+1] to nums[high]
Rather than using a loop, this defintion of the binary search seems to refer to itself. What is going on here?
Can we actually make sense of such a thing?
13.2.1 Recursive Definitions
A description of something that refers to itself is called a recursive definition. In our last formulation, the
binary search algorithm makes use of its own description. A -++call-+. to binary search /#.recurs&!, inside of the
definition(&!hence, the label recursive definition.
At first glance, you might think recursive definitions are just nonsense. Surely you have had a teacher
who insisted that you can't use a word inside of its own definition? That's called a circular definition and is
usually not worth much credit on an exam.
In mathematics, however, certain recursive definitions are used all the time. As long as we excercise some
care in the formulation and use of recursive definitions, they can be quite handy and surprisingly powerful.
Let's look at a simple example to gain some insight and then apply those ideas to binary search.
The classic recursive example in mathematics is the definition of factorial. Back in Chapter 3, we defined
the factorial of a value like this:
n! n n 1 n 2
1
For example, we can compute
5!
5 4 3 2 1
Recall that we implemented a program to compute factorials using a simple loop that accumulates the factorial
product.
Looking at the calculation of 5!, you will notice something interesting. If we remove the 5 from the front,
what remains is a calculation of 4!. In general, n! n n 1 !. In fact, this relation gives us another way of
expressing what is meant by factorial in general. Here is a recursive definition:
n!
1
n n
if n 0
1 ! otherwise
This definition says that the factorial of 0 is, by definition, 1, while the factorial of any other number is defined
to be that number times the factorial of one less than that number.
Even though this definition is recursive, it is not circular. In fact, it provides a very simple method of
calculating a factorial. Consider the value of 4!. By definition we have
4!
4 4
1 !
4 3!
But what is 3!? To find out, we apply the definition again.
4!
4 3!
4 3 3
1 !
4 3 2!
Now, of course, we have to expand 2!, which requires 1!, which requires 0!. Since 0! is simply 1, that's the
end of it.
4! 4 3!
4 3 2!
4 3 2 1!
4 3 2 1 0!
4 3 2 1 1
24
You can see that the recursive definition is not circular because each application causes us to request the
factorial of a smaller number. Eventually we get down to 0, which doesn't require another application of the
definition. This is called a base case for the recursion. When the recursion bottoms out, we get a closed
expression that can be directly computed. All good recursive definitions have these key characteristics:CHAPTER 13. ALGORITHM ANALYSIS AND DESIGN
230
1. There are one or more base cases for which no recursion is required.
2. When the definition is recursively applied, it is always applied to a smaller case.
3. All chains of recursion eventually end up at one of the base cases.
13.2.2 Recursive Functions
You already know that the factorial can be computed using a loop with an accumulator. That implementation
has a natural correspondence to the original definition of factorial. Can we also implement a version of
factorial that follows the recursive definition?
If we write factorial as a separate function, the recursive definition translates directly into code.
def fact(n):
if n == 0:
return 1L
else:
return n * fact(n-1)
Do you see how the definition that refers to itself turns into a function that calls itself? The function first
checks to see if we are at a the base case n == 0 and, if so, returns 1 (note the use of a long int constant
since factorials grow rapidly). If we are not yet at the base case, the function returns the result of multiplying
n by the factorial of n-1. The latter is calculated by a recursive call to fact(n-1).
I think you will agree that this is a reasonable translation of the recursive definition. The really cool part
is that it actually works! We can use this recursive function to compute factorial values.
>>> from recfact import fact
>>> fact(4)
24
>>> fact(10)
3628800
Some beginning programmers are surprised by this result, but it follows naturally from the semantics for
functions that we discussed way back in Chapter 6. Remember that each call to a function starts that function
anew. That means it gets its own copy of any local values, including the values of the parameters. Figure 13.1
shows the sequence of recursive calls that computes 2!. Note especially how each return value is multiplied
by a value of n appropriate for each function invocation. The values of n are stored on the way down the
chain and then used on the way back up as the function calls return.
n = 2
fact(2)
def fact(n):
if n == 0:
1
return 1
n =
2 else:
return n * fact(n%(+1)
n:
2
def fact(n):
if n == 0:
0
return 1
n =
1 else:
return n * fact(n+"/1)
n:
1
1
def fact(n):
if n == 0:
return 1
else:
return n * fact(n()*1)
n:
0
Figure 13.1: Recursive computation of 2!
13.2.3 Recursive Search
Now that we have a technique for implementing recursive definitions, we are ready to go back and look again
at binary search as a recursive process. The basic idea was to look at the middle value and then recursively
search either the lower half or the upper half of the array. The base cases for the recursion are the conditions
when we can stop, namely when the target value is found, or we run out of places to look. The recursive calls13.3. SORTING ALGORITHMS
231
will cut the size of the problem in half each time. In order to do this, we need to specify the range of locations
in the list that are still (,/in play&)& for each recursive call. We can do this by passing the values of low and
high along with the list. Each invocation will search the list between the low and high indexes.
Here is a direct implementation of the recursive algorithm using these ideas:
def recBinSearch(x, nums, low, high):
if low > high:
# No place left to look, return -1
return -1
mid = (low + high) / 2
item = nums[mid]
if item == x:
# Found it! Return the index
return mid
elif x < item:
# Look in lower half
return recBinSearch(x, nums, low, mid-1)
else:
# Look in upper half
return recBinSearch(x, nums, mid+1, high)
We can then implement our original search function using a suitable call to the recursive binary search, telling
it to start the search between 0 and len(nums)-1
def search(x, nums):
return recBinSearch(x, nums, 0, len(nums)-1)
Of course, as in the case of factorial, we already implemented this algorithm using a loop, and there
is no compelling reason to use a recursive implementation. In fact, the looping version is probably a bit
faster because calling functions is generally slower than iterating a loop. The recursive version, however,
makes the divide-and-conquer structure of binary search much more obvious. Below, we will see examples
where recursive divide-and-conquer approaches provide a natural solution to some problems where loops are
awkward.
13.3 Sorting Algorithms
The sorting problem provides a nice testbed for the algorithm design techniques we have been discussing.
Recall, the basic sorting problem is to take a list and rearrange it so that the values are in increasing (actually,
nondecreasing) order.
13.3.1 Naive Sorting: Selection Sort
Let's start with a simple !-"be the computer,+$ approach to sorting. Suppose you have a stack of index cards,
each with a number on it. The stack has been shuffled, and you need to put the cards back in order. How
would you accomplish this task?
There are any number of good systematic approaches. One simple method is to look through the deck
to find the smallest value and then place that value at the front of the stack (or perhaps in a separate stack).
Then you could go through and find the smallest of the remaining cards and put it next in line, etc. Of course,
this means that you'll also need an algorithm for finding the smallest remaining value. You can use the same
approach we used for finding the max of a list (see Chapter 6). As you go through, you keep track of the
smallest value seen so far, updating that value whenever you find a smaller one.
The algorithm I just described is called selection sort. Basically, the algorithm consists of a loop and
each time through the loop, we select the smallest of the remaining elements and move it into its proper
position. Applying this idea to a list, we proceed by finding the smallest value in the list and putting it into
the 0th position. Then we find the smallest remaining value (from positions 1**&(n-1)) and put it in position 1.
Next the smallest value from positions 2/'.(n-1) goes into position 2, etc. When we get to the end of the list,
everything will be in its proper place.
There is one subtlety in implementing this algorithm. When we place a value into its proper position, we
need to make sure that we do not accidently lose the value that was originally stored in that position. For
example, if the smallest item is in position 10, moving it into position 0 involves an assignment.CHAPTER 13. ALGORITHM ANALYSIS AND DESIGN
232
nums[0] = nums[10]
But this wipes out the value currently in nums[0]; it really needs to be moved to another location in the list.
A simple way to save the value is to swap it with the one that we are moving. Using simultaneous assignment,
the statement
nums[0], nums[10] = nums[10], nums[0]
places the value from position 10 at the front of the list, but preserves the original first value by stashing it
into location 10.
Using this idea, it is a simple matter to write a selection sort in Python. I will use a variable called
bottom to keep track of which position in the list we are currently filling, and the variable mp will be used
to track the location of the smallest remaining value. The comments in this code explain this implementation
of selection sort:
def selSort(nums):
# sort nums into ascending order
n = len(nums)
# For each position in the list (except the very last)
for bottom in range(n-1):
# find the smallest item in nums[bottom]..nums[n-1]
mp = bottom
for i in range(bottom+1,n):
if nums[i] < nums[mp]:
mp = i
# initially bottom is smallest so far
# look at each position
# this one is smaller
#
remember its index
# swap smallest item to the bottom
lst[bottom], lst[mp] = lst[mp], lst[bottom]
One thing to notice about this algorithm is the accumulator for finding the minimum value. Rather than
actually storing the minimum seen so far, mp just remembers the position of the minimum. A new value is
tested by comparing the item in position i to the item in position mp. You should also notice that bottom
stops at the second to last item in the list. Once all of the items up to the last have been put in the proper
place, the last item has to be the largest, so there is no need to bother looking at it.
The selection sort algorithm is easy to write and works well for moderate-sized lists, but it is not a very
efficient sorting algorithm. We'll come back and analyze it after we've developed another algorithm.
13.3.2 Divide and Conquer: Merge Sort
As discussed above, one technique that often works for developing efficient algorithms is the divide-and-
conquer approach. Suppose a friend and I were working together trying to put our deck of cards in order. We
could divide the problem up by splitting the deck of cards in half with one of us sorting each of the halves.
Then we just need to figure out a way of combining the two sorted stacks.
The process of combining two sorted lists into a single sorted result is called merging. If you think about
it, merging is pretty simple. Since our two stacks are sorted, each has its smallest value on top. Whichever of
the top values is the smallest will be the first item in the merged list. Once the smaller value is removed, we
can look at the tops of the stacks again, and whichever top card is smaller will be the next item in the list. We
just continue this process of placing the smaller of the two top values into the big list until one of the stacks
runs out. At that point, we finish out the list with the cards from the remaining stack.
Here is a Python implementation of the merge process. In this code, lst1 and lst2 are the smaller lists
and lst3 is the larger list where the results are placed. In order for the merging process to work, the length
of lst3 must be equal to the sum of the lengths of lst1 and lst2. You should be able to follow this code
by studying the accompanying comments:13.3. SORTING ALGORITHMS
233
def merge(lst1, lst2, lst3):
# merge sorted lists lst1 and lst2 into lst3
# these indexes keep track of current position in each list
i1, i2, i3 = 0, 0, 0 # all start at the front
n1, n2 = len(lst1), len(lst2)
# Loop while both lst1 and lst2
while i1 < n1 and i2 < n2:
if lst1[i1] < lst2[i2]:
lst3[i3] = lst1[i1]
i1 = i1 + 1
else:
lst3[i3] = lst2[i2]
i2 = i2 + 1
i3 = i3 + 1
have more items
# top of lst1 is smaller
#
copy it into current spot in lst3
# top of lst2 is smaller
#
copy it into current spot in lst3
# item added to lst3, update position
# Here either lst1 or lst2 is done. One of the following loops will
# execute to finish up the merge.
# Copy remaining items (if any) from lst1
while i1 < n1:
lst3[i3] = lst1[i1]
i1 = i1 + 1
i3 = i3 + 1
# Copy remaining items (if any) from lst2
while i2 < n2:
lst3[i3] = lst2[i2]
i2 = i2 + 1
i3 = i3 + 1
With this merging algorithm in hand, it's easy to see the general structure for a divide-and-conquer sorting
algorithm.
Algorithm: mergeSort nums
split nums into two halves
sort the first half
sort the second half
merge the two sorted halves back into nums
Looking at the steps in this algorithm, the first and last parts look easy. We can use slicing to split the list,
and we can use the merge function that we just wrote to put the pieces back together. But how do we sort
the two halves?
Well, let's think about it. We are trying to sort a list, and our algorithm requires us to sort two smaller
lists. This sounds like a perfect place to use recursion. Maybe we can use mergeSort itself to sort the two
lists. Let's go back to our recursion guidelines and see if we can develop a proper recursive algorithm.
In order for recursion to work, we need to find at least one base case that does not require a recursive
call, and we also have to make sure that recursive calls are always made on smaller versions of the original
problem. The recursion in our mergeSort will always occur on a list that is half as large as the original,
so the latter property is automatically met. Eventually, our lists will be very small, containing only a single
item. Fortunately, a list with just one item is already sorted! Voil ,/a, we have a base case. When the length of
the list is less than 2, we do nothing, leaving the list unchanged.
Given our analysis, we can update the mergeSort algorithm to make it properly recursive.CHAPTER 13. ALGORITHM ANALYSIS AND DESIGN
234
if len(nums) > 1:
split nums into two halves
mergeSort the first half
mergeSort the second half
merge the two sorted halves back into nums
We can translate this algorithm directly into Python code.
def mergeSort(nums):
# Put items of nums in ascending order
n = len(nums)
# Do nothing if nums contains 0 or 1 items
if n > 1:
# split into two sublists
m = n / 2
nums1, nums2 = nums[:m], nums[m:]
# recursively sort each piece
mergeSort(nums1)
mergeSort(nums2)
# merge the sorted pieces back into original list
merge(nums1, nums2, nums)
I know this use of recursion may still seem a bit mysterious to you. You might try tracing this algorithm with
a small list (say eight elements), just to convince yourself that it really works. In general, though, tracing
through recursive algorithms can be tedious and often not very enlightening.
Recursion is closely related to mathematical induction, and it requires something of a leap of faith before
it becomes comfortable. As long as you follow the rules and make sure that every recursive chain of calls
eventually reaches a base case, your algorithms will work. You just have to trust and let go of the grungy
details. Let Python worry about that for you!
13.3.3 Comparing Sorts
Now that we have developed two sorting algorithms, which one should we use? Before we actually try them
out, let's do some analysis. As in the searching problem, the difficulty of sorting a list depends on the size
of the list. We need to figure out how many steps each of our sorting algorithms requires as a function of the
size of the list to be sorted.
Take a look back at the algorithm for selection sort. Remember, this algorithm works by first finding the
smallest item, then finding the smallest of the remaining elements, and so on. Suppose we start with a list
of size n. In order to find the smallest value, the algorithm has to inspect each of the n items. The next time
around the outer loop, it has to find the smallest of the remaining n 1 items. The third time around, there are
n 2 items of interest. This process continues until there is only one item left to place. Thus, the total number
of iterations of the inner loop for the selection sort can be computed as the sum of a decreasing sequence.
n
n
1
n
2
n
3
1
In other words, the time required by selection sort to sort a list of n items in proportional to the sum of the
first n whole numbers. There is a well-known formula for this sum, but even if you do not know the formula,
it is easy to derive. If you add the first and last numbers in the series you get n 1. Adding the second and
second to last values gives n 1 2 n 1. If you keep pairing up the values working from the outside
in, all of the pairs add to n 1. Since there are n numbers, there must be n 2 pairs. That means the sum of all
n n 1
2
the pairs is
.
You can see that the final formula contains an n 2 term. That means that the number of steps in the
algorithm is proportional to the square of the size of the list. If the size of the list doubles, the number of
steps quadruples. If the size triples, it will take nine times as long to finish. Computer scientists call this a
quadratic or n-squared algorithm.13.4. HARD PROBLEMS
235
Let's see how that compares to the merge sort algorithm. In the case of merge sort, we divided a list into
two pieces and sorted the individual pieces before merging them together. The real work is done during the
merge process when the values in the sublists are copied back into the original list.
Figure 13.2 depicts the merging process to sort the list [3, 1, 4, 1, 5, 9, 2, 6]. The dashed
lines show how the original list is continually halved until each item is its own list with the values shown at
the bottom. The single-item lists are then merged back up into the two item lists to produce the values shown
in the second level. The merging process continues up the diagram to produce the final sorted version of the
list shown at the top.
1
1
1 1 2
1 3 4
3
3
1
1
3
4
4
4
5
1
5
5 6 9
2 5 6
9
9
2
9
2
6
6
Figure 13.2: Merges required to sort [3, 1, 4, 1, 5, 9, 2, 6].
The diagram makes analysis of the merge sort trivial. Starting at the bottom level, we have to copy the n
values into the second level. From the second to third level, the n values need to be copied again. Each level
of merging involves copying n values. The only question left to answer is how many levels are there? This
boils down to how many times a list of size n can be split in half. You already know from the analysis of
binary search that this is just log 2 n. Therefore, the total work required to sort n items is n log 2 n. Computer
scientists call this an n log n algorithm.
So which is going to be better, the n-squared selection sort or the n-log-n merge sort? If the input size is
small, the selection sort might be a little faster, because the code is simpler and there is less overhead. What
happens, though as n gets larger? We saw in the analysis of binary search that the log function grows very
slowly (log 2 16 000 000 24) so n log 2 n will grow much slower than n n .
Empirical testing of these two algorithms confirms this analysis. On my computer, selection sort beats
merge sort on lists up to size about 50, which takes around 0.008 seconds. On larger lists, the merge sort
dominates. Figure 13.3 shows a comparison of the time required to sort lists up to size 3000. You can see
that the curve for selection sort veers rapidly upward (forming half of a parabola), while the merge sort curve
looks almost straight (look at the bottom). For 3000 items, selection sort requires over 30 seconds while
merge sort completes the task in about 34 of a second. Merge sort can sort a list of 20,000 items in less than
six seconds; selection sort takes around 20 minutes. That's quite a difference!
13.4 Hard Problems
Using our divide-and-conquer approach we were able to design good algorithms for the searching and sorting
problems. Divide and conquer and recursion are very powerful techniques for algorithm design. However,
not all problems have efficient solutions.CHAPTER 13. ALGORITHM ANALYSIS AND DESIGN
236
35
$$$selSort#.'
%-.mergeSort%.-
30
25
20
15
10
5
0
0
500
1000
1500
List Size
2000
2500
3000
Figure 13.3: Experimental comparison of selection sort and merge sort.
13.4.1 Towers of Hanoi
One very elegant application of recursive problem solving is the solution to a mathematical puzzle usually
called the Tower of Hanoi or Tower of Brahma. This puzzle is generally attributed to the French mathe-
matician Edouard Lucas, who published an article about it in 1883. The legend sorrounding the puzzle goes
something like this.
Somewhere in a remote region of the world is a monastery of a very devout religious order. The monks
have been charged with a sacred task that keeps time for the universe. At the beginning of all things, the
monks were given a table that supports three vertical posts. On one of the posts was a stack of 64 concentric
golden disks. The disks are of varying radii and stacked in the shape of a beautiful pyramid. The monks
were charged with the task of moving the disks from the first post to the third post. When the monks have
completed their task, all things will crumble to dust and the universe will end.
Of course, if that's all there were to the problem, the universe would have ended long ago. To maintain
divine order, the monks must abide by certain rules.
1. Only one disk may be moved at a time.
2. A disk may not be (&$set aside."+$ It may only be stacked on one of the three posts.
3. A larger disk may never be placed on top of a smaller one.
Versions of this puzzle were quite popular at one time, and you can still find variations on this theme in
toy and puzzle stores. Figure 13.4 depicts a small version containing only eight disks. The task is to move
the tower from the first post to the third post using the center post as sort of a temporary resting place during
the process. Of course, you have to follow the three sacred rules given above.
We want to develop an algorithm for this puzzle. You can think of our algorithm either as a set of steps
that the monks need to carry out, or as a program that generates a set of instructions. For example, if we label
the three posts A, B and C. The instructions might start out like this:
Move disk from A to C.13.4. HARD PROBLEMS
237
Figure 13.4: Tower of Hanoi puzzle with eight disks.
Move disk from A to B.
Move disk from C to B.
...
This is a difficult puzzle for most people to solve. Of course, that is not surprising, since most people are
not trained in algorithm design. The solution process is actually quite simple.,/if you know about recursion.
Let's start by considering some really easy cases. Suppose we have a version of the puzzle with only
one disk. Moving a tower consisting of a single disk is simple)!" we just remove it from A and put it on C.
Problem solved. OK, what if there are two disks? I need to get the larger of the two disks over to post C, but
the smaller one is sitting on top of it. I need to move the smaller disk out of the way, and I can do this by
moving it to post B. Now the large disk on A is clear; I can move it to C and then move the smaller disk from
post B onto post C.
Now let's think about a tower of size three. In order to move the largest disk to post C, I first have to move
the two smaller disks out of the way. The two smaller disks form a tower of size two. Using the process I
outlined above, I could move this tower of two onto post B, and that would free up the largest disk so that I
can move it to post C. Then I just have to move the tower of two disks from post B onto post C. Solving the
three disk case boils down to three steps.
1. Move a tower of two from A to B.
2. Move one disk from A to C.
3. Move a tower of two from B to C.
The first and third steps involve moving a tower of size two. Fortunately, we have already figured out how to
do this. It's just like solving the puzzle with two disks, except that we move the tower from A to B using C
as the temporary resting place and then from B to C, using A as the temporary.
We have just developed the outline of a simple recursive algorithm for the general process of moving a
tower of any size from one post to another.
Algorithm: move n-disk tower from source to destination via resting place
move n-1 disk tower from source to resting place
move 1 disk tower from source to destination
move n-1 disk tower from resting place to destinationCHAPTER 13. ALGORITHM ANALYSIS AND DESIGN
238
What is the base case for this recursive process? Notice how a move of n disks results in two recursive moves
of n 1 disks. Since we are reducing n by one each time, the size of the tower will eventually be 1. A tower
of size 1 can be moved directly by just moving a single disk; we don't need any recursive calls to remove
disks above it.
Fixing up our general algorithm to include the base case gives us a working moveTower algorithm.
Let's code it up in Python. Our moveTower function will need parameters to represent the size of the tower,
n; the source post, source; the destintation post, dest; and the temporary resting post, temp. We an use
an int for n and the strings +-!A"#,, !''B,!%, and #,*C()/ to represent the posts. Here is the code for moveTower.
def moveTower(n, source, dest, temp):
if n == 1:
print "Move disk from", source, "to", dest+"."
else:
moveTower(n-1, source, temp, dest)
moveTower(1, source, dest, temp)
moveTower(n-1, temp, dest, source)
See how easy that was? Sometimes using recursion can make otherwise difficult problems almost trivial.
To get things started, we just need to supply values for our four parameters. Let's write a little function
that prints out instructions for moving a tower of size n from post A to post C.
def hanoi(n):
moveTower(n, "A", "C", "B")
Now we're ready to try it out. Here are solutions to the three- and four-disk puzzles. You might want to
trace through these solutions to convince yourself that they work.
>>> hanoi(3)
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from A
A
C
A
B
B
A to
to
to
to
to
to
to C.
B.
B.
C.
A.
C.
C.
>>> hanoi(4)
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from
Move disk from A
A
B
A
C
C
A
A
B
B
C
B
A
A
B to
to
to
to
to
to
to
to
to
to
to
to
to
to
to B.
C.
C.
B.
A.
B.
B.
C.
C.
A.
A.
C.
B.
C.
C.
So, our solution to the Tower of Hanoi is a %!%trivial/"! algorithm requiring only nine lines of code. What
is this problem doing in a section labeled hard problems? To answer that question, we have to look at the
efficiency of our solution. Remember, when I talk about the efficiency of an algorithm, I mean how many13.4. HARD PROBLEMS
239
steps it requires to solve a given size problem. In this case, the difficulty is determined by the number of disks
in the tower. The question we want to answer is how many steps does it take to move a tower of size n?
Just looking at the structure of our algorithm, you can see that moving a tower of size n requires us to
move a tower of size n 1 twice, once to move it off the largest disk, and again to put it back on top. If we
add another disk to the tower, we essentially double the number of steps required to solve it. The relationship
becomes clear if you simply try out the program on increasing puzzle sizes.
Numer of Disks
1
2
3
4
5
Steps in Solution
1
3
7
15
31
In general, solving a puzzle of size n will require 2 n 1 steps.
Computer scientists call this an exponential time algorithm, since the measure of the size of the problem,
n, appears in the exponent of this formula. Exponential algorithms blow up very quickly and can only be
practically solved for relatively small sizes, even on the fastest computers. Just to illustrate the point, if our
monks really started with a tower of just 64 disks and moved one disk every second, 24 hours a day, every day,
without making a mistake, it would still take them over 580 billion years to complete their task. Considering
that the universe is roughly 15 billion years old now, I'm not too worried about turning to dust just yet.
Even though the algorithm for Towers of Hanoi is easy to express, it belongs to a class known as in-
tractable problems. These are problems that require too much computing power (either time or memory)
to be solved in practice, except for the simplest cases. And in this sense, our toy-store puzzle does indeed
represent a hard problem. But some problems are even harder than intractable, and we'll meet one of those
in the next section.
13.4.2 The Halting Problem
Let's just imagine for a moment that this book has inspired you to pursue a career as a computer professional.
It's now six years later, and you are a well-established software developer. One day, your boss comes to you
with an important new project, and you are supposed to drop everything and get right on it.
It seems that your boss has had a sudden inspiration on how your company can double its productivity.
You've recently hired a number of rather inexperienced programmers, and debugging their code is taking an
inordinate amount of time. Apparently, these wet-behind-the-ears newbies tend to accidently write a lot of
programs with inifinite loops (you've been there, right?). They spend half the day waiting for their computers
to reboot so they can track down the bugs. Your boss wants you to design a program that can analyze source
code and detect whether it contains an infinite loop before actually running it on test data. This sounds like
an interesting problem, so you decide to give it a try.
As usual, you start by carefully considering the specifications. Basically, you want a program that can read
other programs and determine whether they contain an infinite loop. Of course, the behavior of a program is
determined not just by its code, but also by the input it is given when it runs. In order to determine if there is
an infinite loop, you will have to know what the input will be. You decide on the following specification:
Program: Halting Analyzer
Inputs: A Python program file.
The input for the program.
Outputs: $($OK*!$ if the program will evenutally stop.
++)FAULTY$%+ if the program has an infinite loop.
Right away you notice a couple interesting things about this program. One is that it is a program that
examines other programs. You have not written many of these before, but you know that it's not a problem
in principle. After all, compilers and interpreters are common examples of programs that analyze other
programs. You can represent both the program that is being analyzed and the proposed input to the program
as Python strings.CHAPTER 13. ALGORITHM ANALYSIS AND DESIGN
240
The second thing you notice is that this description sounds similar to something you've heard about
before. Hmmm... a program that determines whether another program will halt or not. Suddenly it dawns on
you: this is known as the Halting Problem, and it's unsolvable. There is no possible algorithm that can meet
this specification!
How do we know that there is no solution to this problem? This is a question that all the design skills in
the world will not answer for you. Design can show that problems are solvable, but it can never prove that a
problem is not solvable. To do that, we need to use our analytical skills.
One way to prove that something is impossible is to first assume that it is possible and show that this leads
to a contradiction. Mathematicians call this proof by contradiction. We'll use this technique to show that the
halting problem cannot be solved.
We begin by assuming that there is some algorithm that can determine if a program terminates when
executed on a particular input. If such an algorithm could be written, we could package it up in a function.
def terminates(program, inputData):
# program and inputData are both strings
# RETURNS true if program would halt when run with inputData
#
as its input.
Of course, I can't actually write the function, but let's just assume that this function exists.
Using the terminates function, we can write a goofy program.
# goofy.py
import string
def terminates(program, inputData):
# program and inputData are both strings
# RETURNS true if program would halt when run with inputData
#
as its input.
def main():
# Read a program from standard input
lines = []
print "Type in a program (type /,)done./" to quit)."
line = raw_input("")
while line != "done":
lines.append(line)
line = raw_input("")
testProg = string.join(lines, "\n")
# If program halts on itself as input, go into an infinite loop
if terminates(testProg, testProg):
while 1: pass
main()
The first thing goofy.py does is read in a program typed by the user. This is accomplished with a sentinel
loop that accumulates lines in a list one at a time. The string.join function then concatenates the
lines together using a newline character (" n") between them. This effectively creates a multi-line string
representing the program that was typed.
Goofy.py then calls the terminates function and sends the input program as both the program to
test and the input data for the program. Essentially, this is a test to see if the program read from the input
terminates when given itself as input. The pass statement actually does nothing; if the terminates
function returns true, goofy.py will go into an infinite loop.
OK, this seems like a silly program, but there is nothing in principle that keeps us from writing it, provided
that the terminates function exists. Goofy.py is constructed in this peculiar way simply to illustrate a
point. Here's the million dollar question: What happens if we run goofy.py and, when prompted to type13.4. HARD PROBLEMS
241
in a program, type in the contents of goofy.py? Put more specifically, does goofy.py halt when given
itself as its input?
Let's think it through. We are running goofy.py and providing goofy.py as its input. In the call to
terminates, both the program and the data will be a copy of goofy.py, so if goofy.py halts when
given itself as input, terminates will return true. But if terminates returns true, goofy.py then goes
into an infinite loop, so it doesn't halt! That's a contradiction; goofy.py can't both halt and not halt. It's
got to be one or the other.
Let's try it the other way around. Suppose that terminates returns a false value. That means that
goofy.py, when given itself as input goes into an infinite loop. But as soon as terminates returns false,
goofy.py quits, so it does halt! It's still a contradiction.
If you've gotten your head around the previous two paragraphs, you should be convinced that goofy.py
represents an impossible program. The existence of a function meeting the specification for terminates
leads to a logical impossibility. Therefore, we can safely conclude that no such function exists. That means
that there cannot be an algorithm for solving the halting problem!
There you have it. Your boss has assigned you an impossible task. Fortunately, your knowledge of
computer science is sufficient to recognize this. You can explain to your boss why the problem can't be
solved and then move on to more productive pursuits.
13.4.3 Conclusion
I hope this chapter has given you a taste of what computer science is all about. As the examples in this chapter
have shown, computer science is much more than #)-just$!& programming. The most important computer for any
computing professional is still the one between the ears.
Hopefully this book has helped you along the road to becoming a computer programmer. Along the way,
I have tried to it has pique your curiousity about the science of computing. If you have mastered the concepts
in this text, you can already write interesting and useful programs. You should also have a firm foundation of
the fundamental ideas of computer science and software engineering. Should you be interested in studying
these fields in more depth, I can only say $-.go for it.(,/ Perhaps one day you will also consider yourself a
computer scientist; I would be delighted if my book played even a very small part in that process.Index
doc , 171
init , 168
name , 106
and, 132
operational definition, 138
Ants Go Marching, The, 100
append, 186
archery, 85, 121
argument, 93
array, 186
associative, 199
arrow (on Lines), 82
ASCII, 46
assignment statement, 10, 17/''20
sematics, 17
simultaneous, 19
syntax, 17
associative array, 199
attributes, 161
private, 178
average n numbers
algorithm
empty string sentinel, 128
problem description, 123
program
counted loop, 123
empty string sentinel, 128
end-of-file loop, 130
from file with readlines, 129
interactive loop, 126
negative sentinel, 127
average two numbers, 20
average1.py, 123
average2.py, 126
average3.py, 127
average4.py, 128
average5.py, 129
average6.py, 130
avg2.py, 20
abstraction, 148
accessor, 68
accumulator, 31
acronym, 61
algorithm
analysis, 2, 233
definition of, 2
design strategy, 118
divide and conquer, 235
exponential time, 245
intractable, 246
linear time, 234
log time, 234
quadratic (n-squared) time, 241
algorithms
average n numbers
counted loop, 123
empty string sentinel, 128
interactive loop, 126
binary search, 233
cannonball simulation, 162
future value, 23
future value graph, 71, 73
input validation, 135
linear search, 232
max-of-three
comparing each to all, 115
decision tree, 116
sequential, 117
median, 189
merge sort, 240
message decoding, 48
message encoding, 47
quadratic equation three-way decision, 110
racquetball simulation
simOneGame, 150
selection sort, 238
simNGames, 149
temperature conversion, 14
alias, 69
analysis of algorithms, 2, 233
babysitting, 120
batch processing, 58
example program, 58
binary, 4
binary search, 232
bit, 33
black box, 207
Blackjack, 159
242INDEX
BMI (Body Mass Index), 120
Boolean
algebra (logic), 134
expression, 106, 131
operator, 132
values, 106
break statement, 136
implementing post-test loop, 136
style considerations, 137
Brooks, Fred, 208
bug, 13
butterfly effect, 11
Button
class definition, 175
description, 173
methods, 174
button.py, 175
byte code, 8
Caesar cipher, 61
calculator
problem description, 194
program, 197
cannonball
algorithm, 162
graphical display, 180
problem description, 162
program, 164, 169, 172
Projectile class, 169
card, playing, 181
cball1.py, 164
cball3.py, 169
cball4.py, 172
Celsius, 13
change counter
program, 27, 54
change.py, 27
change2.py, 54
chaos
discussion, 10$)/11
program, 7
chaos.py, 7
chr, 46
Christmas, 85
cipher, 50
ciphertext, 50
Circle
constructor, 82
methods, 82
circle
area formula, 38
intersection with line, 85
class, 66, 161
class standing, 120
243
class statement, 167
classes
Button, 175
Calculator, 197
Dice, 217
DieView, 176, 193
GraphicsInterface, 225
MSDie, 166
Player, 213
PokerApp, 219
Projectile, 169
Projectile as module file, 171
RBallGame, 211
SimStats, 210
TextInterface, 221
client, 207
clone, 70, 82
close
GraphWin, 81
cmp, 203
code duplication
in future value graph, 91
maintenance issues, 88
reducing with functions, 88
coffee, 39
Collatz sequence, 140
color
changing graphics object, 75
changing GraphWin, 75
fill, 75
outline, 75
specifying, 84
color rgb, 84
comments, 9
compareItems, 203
compiler, 4
diagram, 5
vs. interpreter, 5
compound condition, 115
computer
definition of, 1
functional view, 3
program, 1
computer science
definition of, 2
methods of investigation, 2
concatenation
list, 185
string, 43
condition, 105
compound, 115
design issues, 115
for termination, 134
syntax, 105244
conditional loop, 124
constructor, 67, 161
init , 168
parameters in, 67
control codes, 46
control structure, 103
decision, 103
definition of, 22
loop, 22
nested loops, 130
nesting, 110
control structures
Boolean operators, 138
for statement, 22
if, 105
if-elif-else, 111
if-else, 108
while, 124
convert.py, 14, 103
convert2.py, 104
convert gui.pyw, 79
coordinates
as instance variables, 67
changing with setCoords, 75
in a GraphWin, 65
of a Point, 65
setCoords example, 76
transforming, 75
counted loop
definition of, 21
in Python, 22
CPU (Central Processing Unit), 3
craps, 159
createLabeledWindow, 98
cryptography, 50
cylinder, 180
data, 27, 161
data type
automatic conversion, 36
definition of, 28
explicit conversion, 36
in format specifiers, 53
mixed-type expressions, 36
string conversion, 52
string conversions, 49
data types
file, 55
float, 28
int, 28
long int, 35
string, 41
date, 120
day number, 120
INDEX
debugging, 13
decision, 103
implementation via Boolean operator, 138
multi-way, 110
nested, 110
simple (one-way), 105
two-way, 108
decision tree, 115
decoding, 48
algorithm, 48
program, 49
definite loop, 124
definition of, 20
use as counted loop, 22
degree-days, 140
delete, 187
DeMorgan's laws, 134
design, 13, 207
object oriented, see object oriented design
top-down, 146
steps in, 154
design pattern
importance of, 124
design patterns
counted loop, 21, 123
end-of-file loop, 129
interactive loop, 126
IPO, 14
loop accumulator, 31, 123
model-view, 217
nested loops, 130, 131
sentinel loop, 127
loop and a half, 136
design techniques
divide and conquer, 235
spiral development, 156
when to use, 158
dice, 159
dice poker
classes
Dice, 217
GraphicsInterface, 225
PokerApp, 219
TextInterface, 221
problem description, 216
dice roller
problem description, 173
program, 178
dictionary, 199
creation, 200
empty, 200
methods, 200
DieView, 191
class definition, 176, 193INDEX
description, 176
Dijkstra, Edsgar, 2
disk, 3
distance function, 96
division, 29
docstring, 171
dot notation, 8, 59, 67
draw, 82
drawBar, 91
duplication, see code duplication
Easter, 120
elif, 111
empty list, 186
empty string, 128
encapsulation, 170, 228
encoding, 46
algorithm, 47
program, 47
encryption, 50
Entry, 79, 83
environment, programming, 7
epact, 39
equality, 105
Eratosthenes, 206
error checking, 112
errors
KeyError, 201
math range, 30
name, 16, 42
overflow, 33
Euclid's algorithm, 140
eval, 49
event, 77
event loop, 179
event-driven, 77
exam grader, 61, 120
exception handling, 112
exponential notation, 35
expression
as input, 18
Boolean, 106, 131
definition of, 15
spaces in, 16
face, 85, 180
fact.py, 236
factorial
definition of, 31
program, 32, 35
recursive definition, 235
factorial.py, 32
factorial2, 35
Fahrenheit, 13
245
fetch execute cycle, 3
Fibonacci numbers, 39, 140
file, 55
closing, 56
opening, 56
processing, 56
program to print, 57
read operations, 56
representation, 55
write operations, 57
float, 28
literal, 28
representation, 35
floppy, 3
flowchart, 22
flowcharts
for loop, 22
if semantics, 105
loop and a half sentinel, 137
max-of-three decision tree, 116
max-of-three sequential solution, 117
nested decisions, 111
post-test loop, 135
temperature conversion with warnings, 104
two-way decision, 109
while loop, 125
flush, 81
for statement (for loop), 21, 123
as counted loop, 22
flowchart, 22
semantics, 21
syntax, 21
using simultaneous assignment, 196
formal parameter, 93
format specifier, 53
from..import, 64
function, 6
actual parameters, 93
arguments, 93
as parameter, 203
as black box, 207
as subprogram, 88
call, 6, 93
createLabeledWindow, 98
defining, 6, 93
for modularity, 97
invoking, see function, call
missing return, 97
multiple parameters, 94
None as default return, 97
parameters, 6
recursive, 236
return value, 95
returning multiple values, 96INDEX
246
signature (interface), 148
to reduce duplication, 88
function definition, 88
functions
built-in
chr, 46
cmp, 203
eval, 49
float, 37
int, 37
len, 43
long, 37
max, 118
open, 56
ord, 46
range, 32
raw input, 42
read, 56
readline, 56
readlines, 56
round, 37
str, 52
type, 28
write, 57
compareItems, 203
distance, 96
drawBar, 91
gameOver, 152
getInputs, 148
getNumbers, 187
happy, 89
main, 7
why use, 9
math library, see math library, functions
mean, 188
median, 189
merge, 239
mergeSort, 240
moveTower, 244
random library, see random library, functions
recursive binary search, 237
recursive factorial, 236
selsort, 238
simNGames, 150
simOneGame, 152
singFred, 89
singLucy, 89
square, 95
stdDev, 188
string library, see string library
future value
algorithm, 23
problem description, 23
program, 24, 99
program specification, 23
future value graph
final algorithm, 73
problem, 70
program, 74, 76, 87, 91
rough algorithm, 71
futval.py, 24
futval graph.py, 74
futval graph2.py, 76, 87
futval graph3.py, 91
futval graph4.py, 99
gameOver, 152
GCD (Greatest Common Divisor), 140
getAnchor, 83
getCenter, 82, 83
getInputs, 148
getMouse, 78, 81
example use, 78
getNumbers, 187
getP1, 82, 83
getP2, 82, 83
getPoints, 83
getRadius, 82
getText, 83
getX, 82
getY, 82
goofy.py, 247
gozinta, 29
graphics library, 64, 81'$"84
drawing example, 66
generic methods summary, 82
graphical objects, 82''-83
methods
for Text, 83
clone, 70
for Circle, 82
for Entry, 83
for Image, 83
for Line, 82
for Oval, 83
for Point, 82
for Polygon, 83
for Rectangle, 82
getMouse, 78
move, 68
setCoords, 75
objects
Circle, 82
Entry, 79, 83
GraphWin, 64, 81
Image, 83
Line, 82
Oval, 83INDEX
Point, 65, 82
Polygon, 79, 83
Rectangle, 82
Text, 83
GraphWin, 64, 81
methods summary, 81
Gregorian epact, 39
GUI, 64
hailstone function, 140
halting problem, 246
happy, 89
happy birthday
lyrics, 88
problem description, 88
program, 90
happy.py, 90
hard drive, 3
hardware, 2
hash array, 199
hierarchy chart, 148, see structure chart
house, 86
house (of representatives), 120
identifier
definition of, 15
rules for forming, 15
Idle, 7
if statement
flowchart, 105
semantics, 105
syntax, 105
if-elif-else statement
semantics, 111
syntax, 111
if-else statement
decision tree, 116
nested, 110, 116
semantics, 109
syntax, 108
Image, 83
implementation, 13
import statement, 30, 106
with #.*from#$), 64
indefinite loop, 124
indexing
dictionary, 200
from the right, 52
list, 185, 187
negative indexes, 52
string, 42
infinite loop, 125, 136
inheritance, 229
input, 9
247
validation, 135
input statement, 18
multiple values, 20
semantics, 18
syntax, 18
Input/Output Devices, 3
instance, 66, 161
instance variable, 67, 161
accessing, 168
and object state, 168
int, 28
automatic conversion to float, 36
conversion to float, 37
literal, 28
range of, 34
representaiton, 34
integer division, 29
interface, 148
interpreter, 4
diagram, 5
Python, 5
vs. compiler, 5
intractable problems, 2, 246
investment doubling, 140
IPO (Input, Process, Output), 14
iteration, 20
key
cipher, 51
private, 51
public, 51
with dictionary, 199
key-value pair, 199
KeyError, 201
label, 72
ladder, 39
leap year, 120
left-justification, 54
len
with list, 185, 188
with string, 43
lexicographic ordering, 105
library
definition of, 29
graphics, see graphics library
math, see math library
random, see random library
string, see string library
lightning, 39
Line, 82
line continuation
using backslash ( ), 55
using brackets, 191INDEX
248
linear time, 234
list, 184
as sequence, 185
creation, 186
empty, 186
indexing, 185
merging, 239
methods, 187, 203
operators, 185
removing items, 187
slice, 187
vs. string, 185
literal, 16
float, 28
int, 28
string, 41, 172
log time, 234
long int, 35
when to use, 36
loop, 9
accumulator variable, 31
as control structure, 22
counted, 21, 22
definite, 20, 124
end-of-file, 129
event loop, 179
for statement, 21
indefinite (conditional), 124
index variable, 21
infinite, 125, 136
interactive, 126
loop and a half, 136
nested, 130
over a sequence, 21
post-test, 135
using break, 136
using while, 135
pre-test, 124
vs. recursive function, 237
while statement, 124
loop and a half, 136
lower, 59
Lucas, Edouard, 243
machine code, 4
maintenance, 13
mapping, 199
math library, 29
functions, 30, 31
using, 30
math range error, 30
max, 118
max-of-n program, 117
max-of-three, 114$&#117
maxn.py, 117
mean, 188
median, 184, 189
memory, 3
main, 3
secondary, 3
merge, 239
merge sort, 239, see sorting, merge sort
mergeSort, 240
analysis, 241
message decoding
algorithm, 48
problem description, 48
program, 49
message encoding
algorithm, 47
problem description, 46
program, 47
meta-language, 17
method, 67, 161
parameterless, 68
accessor, 68
call (invoke), 67, 167
mutator, 68
normal parameter, 167
object parameters, 68
self parameter, 167
methods
activate, 174
clicked, 174
deactivate, 174
dictionary, 200
list, 186, 187
model-view, 217
module file, 7
module hierarchy chart, see structure chart
molecular weight, 39
Monte Carlo, 144, 159
month abbreviation
problem description, 44
program, 45
month.py, 45
move, 68, 82
moveTower, 244
MPG, 140
MSDie, 166
mutable, 185, 200
mutator, 68
name error, 16, 42
names, 15
nesting, 110
newline character ( n), 55, 108
with readline, 130INDEX
249
Newton's method, 40
None, 97
numbers2text.py, 49
numerology, 61
object, 161
aliasing, 69
application as, 194
as black box, 207
as parameter, 68
attributes, 161
definition of, 63
state, 68
object oriented design (OOD), 207
object-oriented, 63
objects
built-in
file, 59
None, 97
string, 59
graphics, see graphics library, objects
other, see classes
objrball.py, 213
Old MacDonald, 100
one-way decision, 105
open, 56
operator
Boolean, 132
as control structure, 138
definition of, 16
precedence, 16, 132
relational, 105
short-circuit, 138
operators
Boolean, 132
del, 187
list, 185
mathematical, 16
Python numeric operators, 28
relational, 105
string formatting, 53
or, 132
operational definition, 138
ord, 46
output labeling, 17
output statements, 16
Oval, 83
overflow error, 33
override, 230
overtime, 120
parameter, 6
actual, 93
as function input, 95
formal, 93
functions as parameters, 203
matching by order, 95
multiple, 94
objects as, 68
removing code duplication, 90
scope issues, 92, 93
self, 167
pi
math library, 31
Monte Carlo approximation, 159
series approximation, 39
pixel, 65
pizza, 38
plaintext, 50
Player, 213
playing card, 181
plot, 81
plotPixel, 81
Point, 65, 82
poker, see dice poker
Polygon, 79, 83
polymorphism, 228
portability, 5
post-test loop, 135
precision, 53
prime number, 140, 206
priming read, 127
print statement, 6, 17
semantics, 17
syntax, 17
printfile.py, 57
prism, 180
private attributes, 178
private key encryption, 51
program, 1
programming
definition of, 2
environment, 7
event-driven, 77
why learn, 2
programming language, 4)**5
and portability, 5
vs. natural language, 4
examples, 4
high-level, 4
syntax, 17
translation, 4
programs, 35
average n numbers, 123, 126&%.130
average two numbers, 20
calculator, 197
cannonball simulation, 164, 169, 172
change counter, 27, 54INDEX
250
chaos, 7
dice roller, 178
factorial, 32
future value, 24
future value graph, 74, 76, 87, 91, 99
goofy: an impossible program, 247
happy birthday, 90
max-of-n, 117
message decoding, 49
message encoding, 47
month abbreviation, 45
print file, 57
quadratic equation, 29, 107$,#109, 111$,!113
racquetball simulation, 153
racquetball simulation (object version, 213
simple statistics, 189
temperature conversion, 14, 79, 103, 104
triangle, 78, 96
username generation, 44, 58
word frequency, 204
prompt
Python, 6
using Text object, 79
prototype, 156
pseudocode, 14
pseudorandom numbers, 144
public key encryption, 51
pyc file, 8
Python
Boolean operators, 132
mathematical operators, 16
numeric operators, 28
programming environment, 7
relational operators, 105
reserved words, 15
running programs, 7
pyw, 78
quadratic equation, 29
algorithm with three-way decision, 110
decision flowchart, 109
program, 29, 107
program (bullet-proof), 113
program (simple if), 108
program (two-way decision), 109
program (using exception), 112
program (using if-elif-else), 111
quadratic time, 241
quadratic.py, 29, 107
quadratic2.py, 108
quadratic3.py, 109
quadratic4.py, 111
quadratic5.py, 112
quadratic6.py, 113
quiz grader, 60, 120
racquetball, 133, 143
racquetball simulation
algorithms
simNGames, 149
simOneGmae, 150
classes
Player, 213
RBallGame, 211
SimStats, 210
discussion, 156
problem description, 144
program, 153
program (object version), 213
specification, 144
structure charts
level 2, 150
level 3, 151
top-level, 148
RAM (random access memory), 3
random, 145
random library, 145
functions
random, 145
randrange, 145
random numbers, 144
random walk, 159
randrange, 145
range, 21
general form, 32
range error, 30
raw input, 42
RBallGame, 211
read, 56
readline, 56
readlines, 56
recBinSearch, 237
Rectangle, 82
recursion, 235
regression line, 141, 181
relational operator, 105
repetition
list, 185
string, 43
requirements, 13
reserved words
definition of, 15
in Python, 15
resolution, 72
return statement, 95
multiple values, 96
roller.py, 178
root beer, 30INDEX
round, 37
scientific notation, 35
scope, 92
screen resolution, 72
script, 7
search, 231
searching
binary search, 232
linear search, 232
problem description, 231
recursive formulation, 237
seed, 145
selection sort, see sorting, selection sort
self, 167
selSort, 238
semantics, 4
senate, 120
sentinel, 127
sentinel loop, 127
sequence operators, 185
setArrow, 82
setBackground, 81
setCoords, 75, 81
example, 76
setFace, 83
setFill, 82
setOutline, 82
sets, 206
setSize, 83
setStyle, 83
setText, 83
setWidth, 82
shell game, 179
shuffle, 206
Sieve of Eratosthenes, 206
signature, 148
simNGames, 150
simOneGame, 152
simple decision, 105
simple statistics, 205
problem, 184
program, 189
SimStats, 210
simulation, 143
simultaneous assignment, 19
in for loop, 196
with multiple return values, 97
singFred, 89
singLucy, 89
slicing
list, 187
string, 43
slope of line, 39
251
snowman, 85
software, 2
software development, 13
phases
design, 13
implementation, 13
maintenance, 13
requirements, 13
specifications, 13
testing/debugging, 13
sort, 203
sorting, 234
merge sort
algorithm, 240
analysis, 241
implementation, 240
selection sort
algorithm, 238
analysis, 241
implementation, 238
space
between program lines, 24
blank line in output, 94, 108
in expressions, 16
in prompts, 18
specifications, 13
speeding fine, 120
sphere, 38, 180
surface area formula, 38
volume formula, 38
split, 48
sqrt, 30
square function, 95
square root, 40
standard deviation, 184
statement, 6
statements
assignment, 10, 17"')20
break, 136
class, 167
comment, 9
def (function definition), 6, 88
for, 21, 123
from..import, 64
if, 105
if-elif-else, 111
if-else, 108
import, 30
input, 9, 18
multiple input, 20
print, 6, 16(-%17
return, 95
simultaneous assignment, 19
try-except, 113INDEX
252
while, 124
stats.py, 189
stdDev, 188
step-wise refinement, 154
str, 52
string, 17, 41
as input, 41
as lookup table, 44
ASCII encoding, 46
concatenation, 43
converting to, 52
converting to other types, 49
formatting, see string formatting
formatting operator (%), 53
indexing, 42
from back, 52
length, 43
library, see string library
literal, 41, 172
multi-line, 172
operators, 44
repetition, 43
representation, 46
slicing, 43
substring, 43
UniCode encoding, 46
vs. list, 185
string formatting, 52
examples, 53
format specifier, 53
leading zeroes, 55
left-justification, 54
using a tuple, 204
string library, 48
function summary, 51
lower, 59
split, 48
structure chart, 148
structure charts
racquetball simulation level 2, 150
racquetball simulation level 3, 151
racquetball simulation top level, 148
subprogram, 88
substitution cipher, 50
substring, 43
swap, 19
using simultaneous assignment, 20
syntax, 4, 17
Syracuse numbers, 140 problem description, 13
program, 14, 103
program with GUI, 79
temperature conversion with warnings
design, 103
flowchart, 104
problem description, 103
program, 104
tennis, 158
testing, 13
unit, 155
Text, 83
as prompt, 79
methods, 83
text file, 55
text2numbers.py, 47
textpoker.py, 221
Tkinter, 64
top-down design, 146
steps in process, 154
Towers of Hanoi (Brahma), 243
recursive solution, 244
Tracker, 180
triangle
area formula, 39
program, 78, 96
triangle.pyw, 78
triangle2.py, 96
truth table, 132
truth tables
definition of and, 132
definition of not, 132
definition of or, 132
try-except statement
semantics, 113
syntax, 113
tuple, 195
as string formtting argument, 204
unpacking, 196
type conversion
to float, 37
automatic, 36
explicit, 36
from string, 49
summary of functions, 52
to int, 37
to long int, 37
to string, 52
type function, 28
table tennis, 158
table-driven, 192
temperature conversion
algorithm, 14 undraw, 82
UniCode, 46
unit testing, 155
unpacking, 196INDEX
userfile.py, 58
username generation
program, 44, 58
username.py, 44
validation
of inputs, 135
value returning function, 95
variable
changing value, 18
definition of, 9
instance, 67, 161
local, 92
scope, 92
VGA, 72
volleyball, 133, 158
wc, 62
while statement
as post-test loop, 135
flow chart, 125
semantics, 124
syntax, 124
whitespace, see space
widget, 77, 172
width, 53
windchill, 140
winter, 85
word count, 62
word frequency
problem description, 201
program, 204
wordfreq.py, 204
write, 57


C++:
A second edition is a second chance to acknowledge and to thank those folks without whose support
and help this book literally would have been impossible. First among them are Stacey, Robin, and
Rachel Liberty.
I must also thank everyone associated with my books, both at Sams and at Wrox press, for being
professionals of the highest quality. The editors at Sams did a fantastic job, and I must especially
acknowledge and thank Fran Hatton, Mary Ann Abramson, Greg Guntle, and Chris Denny.
I have taught an online course based on this book for a couple years, and many folks there contributed
to finding and eradicating bugs and errors. A very large debt is owed to these folks, and I must
especially thank Greg Newman, Corrinne Thompson, and also Katherine Prouty and Jennifer
Goldman.
I would also like to acknowledge the folks who taught me how to program: Skip Gilbrech and David
McCune, and those who taught me C++, including Steve Rogers and Stephen Zagieboylo. I want
particularly to thank Mike Kraley, Ed Belove, Patrick Johnson, Mike Rothman, and Sangam Pant, all
of whom taught me how to manage a project and ship a product.
Others who contributed directly or indirectly to this book include: Scott Boag, David Bogartz, Gene
Broadway, Drew and Al Carlson, Frank Childs, Jim Culbert, Thomas Dobbing, James Efstratiou,David Heath, Eric Helliwell, Gisele and Ed Herlihy, Mushtaq Khalique, Matt Kingman, Steve Leland,
Michael Smith, Frank Tino, Donovan White, Mark Woodbury, Wayne Wylupski, and Alan Zeitchek.
Programming is as much a business and creative experience as it is a technical one, and I must
therefore acknowledge Tom Hottenstein, Jay Leve, David Rollert, David Shnaider, and Robert
Spielvogel.
Finally, I'd like to thank Mrs. Kalish, who taught my sixth-grade class how to do binary arithmetic in
1965, when neither she nor we knew why.
Tell Us What You Think!
As a reader, you are the most important critic and commentator of our books. We value your opinion
and want to know what we're doing right, what we could do better, what areas you'd like to see us
publish in, and any other words of wisdom you're willing to pass our way. You can help us make
strong books that meet your needs and give you the computer guidance you require.
Do you have access to CompuServe or the World Wide Web? Then check out our CompuServe forum
by typing GO SAMS at any prompt. If you prefer the World Wide Web, check out our site at
http://www.mcp.com
NOTE: If you have a technical question about this book, call the technical support line
at 317-581-3833.
As the publishing manager of the group that created this book, I welcome your comments. You can
fax, e-mail, or write me directly to let me know what you did or didn't like about this book--as well as
what we can do to make our books stronger. Here's the information:
Fax: 317-581-4669
E-mail: programming_mgr@sams.mcp.com
Mail: Greg Wiegand Sams Publishing 201 W. 103rd Street Indianapolis, IN 46290
Introduction
This book is designed to help you teach yourself how to program with C++. In just 21 days, you'll
learn about such fundamentals as managing I/O, loops and arrays, object-oriented programming,
templates, and creating C++ applications--all in well-structured and easy-to-follow lessons. Lessons
provide sample listings--complete with sample output and an analysis of the code--to illustrate the
topics of the day. Syntax examples are clearly marked for handy reference.To help you become more proficient, each lesson ends with a set of common questions and answers,
exercises, and a quiz. You can check your progress by examining the quiz and exercise answers
provided in the book's appendix.
Who Should Read This Book
You don't need any previous experience in programming to learn C++ with this book. This book starts
you from the beginning and teaches you both the language and the concepts involved with
programming C++. You'll find the numerous examples of syntax and detailed analysis of code an
excellent guide as you begin your journey into this rewarding environment. Whether you are just
beginning or already have some experience programming, you will find that this book's clear
organization makes learning C++ fast and easy.
Conventions
NOTE: These boxes highlight information that can make your C++ programming more
efficient and effective.
WARNING: These focus your attention on problems or side effects that can occur in
specific situations.
These boxes provide clear definitions of essential terms.
DO use the "Do/Don't" boxes to find a quick summary of a fundamental principle in a
lesson. DON'T overlook the useful information offered in these boxes.
This book uses various typefaces to help you distinguish C++ code from regular English. Actual C++
code is typeset in a special monospace font. Placeholders--words or characters temporarily used to
represent the real words or characters you would type in code--are typeset in italic monospace. New
or important terms are typeset in italic.
In the listings in this book, each real code line is numbered. If you see an unnumbered line in a listing,
you'll know that the unnumbered line is really a continuation of the preceding numbered code line
(some code lines are too long for the width of the book). In this case, you should type the two lines as
one; do not divide them.
Day 1
Getting Started
Introduction
A Brief History of C++
Programs
Solving Problems
Procedural, Structured, and Object-Oriented Programming
C++ and Object-Oriented Programming
How C++ Evolved
The ANSI Standard
Should I Learn C First?
Preparing to Program
Your Development Environment
Compiling the Source Code
Creating an Executable File with the Linker
The Development Cycle
Figure 1.1.
HELLO.CPPYour First C++ Program
Listing 1.1. HELLO.CPP, the Hello World program.
Compile Errors
Listing 1.2. Demonstration of
compiler error.
Summary
Q&A
Workshop
Quiz
Exercises
Day 1
Getting Started
IntroductionWelcome to Teach Yourself C++ in 21 Days! Today you will get started on your way to becoming a
proficient C++ programmer. You'll learn
Why C++ is the emerging standard in software development.
The steps to develop a C++ program.
How to enter, compile, and link your first working C++ program.
A Brief History of C++
Computer languages have undergone dramatic evolution since the first electronic computers were
built to assist in telemetry calculations during World War II. Early on, programmers worked with the
most primitive computer instructions: machine language. These instructions were represented by long
strings of ones and zeroes. Soon, assemblers were invented to map machine instructions to human-
readable and -manageable mnemonics, such as ADD and MOV.
In time, higher-level languages evolved, such as BASIC and COBOL. These languages let people
work with something approximating words and sentences, such as Let I = 100. These
instructions were translated back into machine language by interpreters and compilers. An interpreter
translates a program as it reads it, turning the program instructions, or code, directly into actions. A
compiler translates the code into an intermediary form. This step is called compiling, and produces an
object file. The compiler then invokes a linker, which turns the object file into an executable program.
Because interpreters read the code as it is written and execute the code on the spot, interpreters are
easy for the programmer to work with. Compilers, however, introduce the extra steps of compiling
and linking the code, which is inconvenient. Compilers produce a program that is very fast each time
it is run. However, the time-consuming task of translating the source code into machine language has
already been accomplished.
Another advantage of many compiled languages like C++ is that you can distribute the executable
program to people who don't have the compiler. With an interpretive language, you must have the
language to run the program.
For many years, the principle goal of computer programmers was to write short pieces of code that
would execute quickly. The program needed to be small, because memory was expensive, and it
needed to be fast, because processing power was also expensive. As computers have become smaller,
cheaper, and faster, and as the cost of memory has fallen, these priorities have changed. Today the
cost of a programmer's time far outweighs the cost of most of the computers in use by businesses.
Well-written, easy-to-maintain code is at a premium. Easy- to-maintain means that as business
requirements change, the program can be extended and enhanced without great expense.
ProgramsThe word program is used in two ways: to describe individual instructions, or source code, created by
the programmer, and to describe an entire piece of executable software. This distinction can cause
enormous confusion, so we will try to distinguish between the source code on one hand, and the
executable on the other.
New Term: A program can be defined as either a set of written instructions created by a
programmer or an executable piece of software.
Source code can be turned into an executable program in two ways: Interpreters translate the source
code into computer instructions, and the computer acts on those instructions immediately.
Alternatively, compilers translate source code into a program, which you can run at a later time.
While interpreters are easier to work with, most serious programming is done with compilers because
compiled code runs much faster. C++ is a compiled language.
Solving Problems
The problems programmers are asked to solve have been changing. Twenty years ago, programs were
created to manage large amounts of raw data. The people writing the code and the people using the
program were all computer professionals. Today, computers are in use by far more people, and most
know very little about how computers and programs work. Computers are tools used by people who
are more interested in solving their business problems than struggling with the computer.
Ironically, in order to become easier to use for this new audience, programs have become far more
sophisticated. Gone are the days when users typed in cryptic commands at esoteric prompts, only to
see a stream of raw data. Today's programs use sophisticated "user-friendly interfaces," involving
multiple windows, menus, dialog boxes, and the myriad of metaphors with which we've all become
familiar. The programs written to support this new approach are far more complex than those written
just ten years ago.
As programming requirements have changed, both languages and the techniques used for writing
programs have evolved. While the complete history is fascinating, this book will focus on the
transformation from procedural programming to object-oriented programming.
Procedural, Structured, and Object-Oriented Programming
Until recently, programs were thought of as a series of procedures that acted upon data. A procedure,
or function, is a set of specific instructions executed one after the other. The data was quite separate
from the procedures, and the trick in programming was to keep track of which functions called which
other functions, and what data was changed. To make sense of this potentially confusing situation,
structured programming was created.
The principle idea behind structured programming is as simple as the idea of divide and conquer. A
computer program can be thought of as consisting of a set of tasks. Any task that is too complex to bedescribed simply would be broken down into a set of smaller component tasks, until the tasks were
sufficiently small and self-contained enough that they were easily understood.
As an example, computing the average salary of every employee of a company is a rather complex
task. You can, however, break it down into these subtasks:
1. Find out what each person earns.
2. Count how many people you have.
3. Total all the salaries.
4. Divide the total by the number of people you have.
Totaling the salaries can be broken down into
1. Get each employee's record.
2. Access the salary.
3. Add the salary to the running total.
4. Get the next employee's record.
In turn, obtaining each employee's record can be broken down into
1. Open the file of employees.
2. Go to the correct record.
3. Read the data from disk.
Structured programming remains an enormously successful approach for dealing with complex
problems. By the late 1980s, however, some of the deficiencies of structured programing had became
all too clear.
First, it is natural to think of your data (employee records, for example) and what you can do with
your data (sort, edit, and so on) as related ideas.
Second, programmers found themselves constantly reinventing new solutions to old problems. This is
often called "reinventing the wheel," and is the opposite of reusability. The idea behind reusability is
to build components that have known properties, and then to be able to plug them into your program
as you need them. This is modeled after the hardware world--when an engineer needs a new transistor,
she doesn't usually invent one, she goes to the big bin of transistors and finds one that works the way
she needs it to, or perhaps modifies it. There was no similar option for a software engineer.New Term: The way we are now using computers--with menus and buttons and windows--
fosters a more interactive, event-driven approach to computer programming. Event-driven
means that an event happens--the user presses a button or chooses from a menu--and the
program must respond. Programs are becoming increasingly interactive, and it has became
important to design for that kind of functionality.
Old-fashioned programs forced the user to proceed step-by-step through a series of screens. Modern
event-driven programs present all the choices at once and respond to the user's actions.
Object-oriented programming attempts to respond to these needs, providing techniques for managing
enormous complexity, achieving reuse of software components, and coupling data with the tasks that
manipulate that data.
The essence of object-oriented programming is to treat data and the procedures that act upon the data
as a single "object"--a self-contained entity with an identity and certain characteristics of its own.
C++ and Object-Oriented Programming
C++ fully supports object-oriented programming, including the four pillars of object-oriented
development: encapsulation, data hiding, inheritance, and polymorphism. Encapsulation and Data
Hiding When an engineer needs to add a resistor to the device she is creating, she doesn't typically
build a new one from scratch. She walks over to a bin of resistors, examines the colored bands that
indicate the properties, and picks the one she needs. The resistor is a "black box" as far as the engineer
is concerned--she doesn't much care how it does its work as long as it conforms to her specifications;
she doesn't need to look inside the box to use it in her design.
The property of being a self-contained unit is called encapsulation. With encapsulation, we can
accomplish data hiding. Data hiding is the highly valued characteristic that an object can be used
without the user knowing or caring how it works internally. Just as you can use a refrigerator without
knowing how the compressor works, you can use a well-designed object without knowing about its
internal data members.
Similarly, when the engineer uses the resistor, she need not know anything about the internal state of
the resistor. All the properties of the resistor are encapsulated in the resistor object; they are not spread
out through the circuitry. It is not necessary to understand how the resistor works in order to use it
effectively. Its data is hidden inside the resistor's casing.
C++ supports the properties of encapsulation and data hiding through the creation of user-defined
types, called classes. You'll see how to create classes on Day 6, "Basic Classes." Once created, a well-
defined class acts as a fully encapsulated entity--it is used as a whole unit. The actual inner workings
of the class should be hidden. Users of a well-defined class do not need to know how the class works;
they just need to know how to use it. Inheritance and Reuse When the engineers at Acme Motors want
to build a new car, they have two choices: They can start from scratch, or they can modify an existing
model. Perhaps their Star model is nearly perfect, but they'd like to add a turbocharger and a six-speedtransmission. The chief engineer would prefer not to start from the ground up, but rather to say, "Let's
build another Star, but let's add these additional capabilities. We'll call the new model a Quasar." A
Quasar is a kind of Star, but one with new features.
C++ supports the idea of reuse through inheritance. A new type, which is an extension of an existing
type, can be declared. This new subclass is said to derive from the existing type and is sometimes
called a derived type. The Quasar is derived from the Star and thus inherits all its qualities, but can
add to them as needed. Inheritance and its application in C++ are discussed on Day 12, "Inheritance,"
and Day 15, "Advanced Inheritance." Polymorphism The new Quasar might respond differently than a
Star does when you press down on the accelerator. The Quasar might engage fuel injection and a
turbocharger, while the Star would simply let gasoline into its carburetor. A user, however, does not
have to know about these differences. He can just "floor it," and the right thing will happen,
depending on which car he's driving.
C++ supports the idea that different objects do "the right thing" through what is called function
polymorphism and class polymorphism. Poly means many, and morph means form. Polymorphism
refers to the same name taking many forms, and is discussed on Day 10, "Advanced Functions," and
Day 13, "Polymorphism."
How C++ Evolved
As object-oriented analysis, design, and programming began to catch on, Bjarne Stroustrup took the
most popular language for commercial software development, C, and extended it to provide the
features needed to facilitate object-oriented programming. He created C++, and in less than a decade
it has gone from being used by only a handful of developers at AT&T to being the programming
language of choice for an estimated one million developers worldwide. It is expected that by the end
of the decade, C++ will be the predominant language for commercial software development.
While it is true that C++ is a superset of C, and that virtually any legal C program is a legal C++
program, the leap from C to C++ is very significant. C++ benefited from its relationship to C for
many years, as C programmers could ease into their use of C++. To really get the full benefit of C++,
however, many programmers found they had to unlearn much of what they knew and learn a whole
new way of conceptualizing and solving programming problems.
The ANSI Standard
The Accredited Standards Committee, operating under the procedures of the American National
Standards Institute (ANSI), is working to create an international standard for C++.
The draft of this standard has been published, and a link is available at
www.libertyassociates.com.
The ANSI standard is an attempt to ensure that C++ is portable--that code you write for Microsoft's
compiler will compile without errors, using a compiler from any other vendor. Further, because thecode in this book is ANSI compliant, it should compile without errors on a Mac, a Windows box, or
an Alpha.
For most students of C++, the ANSI standard will be invisible. The standard has been stable for a
while, and all the major manufacturers support the ANSI standard. We have endeavored to ensure that
all the code in this edition of this book is ANSI compliant.
Should I Learn C First?
The question inevitably arises: "Since C++ is a superset of C, should I learn C first?" Stroustrup and
most other C++ programmers agree. Not only is it unnecessary to learn C first, it may be
advantageous not to do so. This book attempts to meet the needs of people like you, who come to C++
without prior experience of C. In fact, this book assumes no programming experience of any kind.
Preparing to Program
C++, perhaps more than other languages, demands that the programmer design the program before
writing it. Trivial problems, such as the ones discussed in the first few chapters of this book, don't
require much design. Complex problems, however, such as the ones professional programmers are
challenged with every day, do require design, and the more thorough the design, the more likely it is
that the program will solve the problems it is designed to solve, on time and on budget. A good design
also makes for a program that is relatively bug-free and easy to maintain. It has been estimated that
fully 90 percent of the cost of software is the combined cost of debugging and maintenance. To the
extent that good design can reduce those costs, it can have a significant impact on the bottom-line cost
of the project.
The first question you need to ask when preparing to design any program is, "What is the problem I'm
trying to solve?" Every program should have a clear, well-articulated goal, and you'll find that even
the simplest programs in this book do so.
The second question every good programmer asks is, "Can this be accomplished without resorting to
writing custom software?" Reusing an old program, using pen and paper, or buying software off the
shelf is often a better solution to a problem than writing something new. The programmer who can
offer these alternatives will never suffer from lack of work; finding less-expensive solutions to today's
problems will always generate new opportunities later.
Assuming you understand the problem, and it requires writing a new program, you are ready to begin
your design.
Your Development Environment
This book makes the assumption that your computer has a mode in which you can write directly to the
screen, without worrying about a graphical environment, such as the ones in Windows or on the
Macintosh.Your compiler may have its own built-in text editor, or you may be using a commercial text editor or
word processor that can produce text files. The important thing is that whatever you write your
program in, it must save simple, plain-text files, with no word processing commands embedded in the
text. Examples of safe editors include Windows Notepad, the DOS Edit command, Brief, Epsilon,
EMACS, and vi. Many commercial word processors, such as WordPerfect, Word, and dozens of
others, also offer a method for saving simple text files.
The files you create with your editor are called source files, and for C++ they typically are named
with the extension .CPP, .CP, or .C. In this book, we'll name all the source code files with the .CPP
extension, but check your compiler for what it needs.
NOTE: Most C++ compilers don't care what extension you give your source code, but
if you don't specify otherwise, many will use .CPP by default.
DO use a simple text editor to create your source code, or use the built-in editor that
comes with your compiler. DON'T use a word processor that saves special formatting
characters. If you do use a word processor, save the file as ASCII text. DO save your
files with the .C, .CP, or .CPP extension. DO check your documentation for specifics
about your compiler and linker to ensure that you know how to compile and link your
programs.
Compiling the Source Code
Although the source code in your file is somewhat cryptic, and anyone who doesn't know C++ will
struggle to understand what it is for, it is still in what we call human-readable form. Your source code
file is not a program, and it can't be executed, or run, as a program can.
To turn your source code into a program, you use a compiler. How you invoke your compiler, and
how you tell it where to find your source code, will vary from compiler to compiler; check your
documentation. In Borland's Turbo C++ you pick the RUN menu command or type
tc <filename>
from the command line, where <filename> is the name of your source code file (for example,
test.cpp). Other compilers may do things slightly differently.
NOTE: If you compile the source code from the operating system's command line, you
should type the following:
For the Borland C++ compiler: bcc <filename>For the Borland C++ for Windows compiler: bcc <filename>
For the Borland Turbo C++ compiler: tc <filename>
For the Microsoft compilers: cl <filename>
After your source code is compiled, an object file is produced. This file is often named with the
extension .OBJ. This is still not an executable program, however. To turn this into an executable
program, you must run your linker.
Creating an Executable File with the Linker
C++ programs are typically created by linking together one or more OBJ files with one or more
libraries. A library is a collection of linkable files that were supplied with your compiler, that you
purchased separately, or that you created and compiled. All C++ compilers come with a library of
useful functions (or procedures) and classes that you can include in your program. A function is a
block of code that performs a service, such as adding two numbers or printing to the screen. A class is
a collection of data and related functions; we'll be talking about classes a lot, starting on Day 5,
"Functions."
The steps to create an executable file are
1. Create a source code file, with a .CPP extension.
2. Compile the source code into a file with the .OBJ extension.
3. Link your OBJ file with any needed libraries to produce an executable program.
The Development Cycle
If every program worked the first time you tried it, that would be the complete development cycle:
Write the program, compile the source code, link the program, and run it. Unfortunately, almost every
program, no matter how trivial, can and will have errors, or bugs, in the program. Some bugs will
cause the compile to fail, some will cause the link to fail, and some will only show up when you run
the program.
Whatever type of bug you find, you must fix it, and that involves editing your source code,
recompiling and relinking, and then rerunning the program. This cycle is represented in Figure 1.1,
which diagrams the steps in the development cycle.
Figure 1.1. The steps in the development of a C++ program.HELLO.CPPYour First C++ Program
Traditional programming books begin by writing the words Hello World to the screen, or a
variation on that statement. This time-honored tradition is carried on here.
Type the first program directly into your editor, exactly as shown. Once you are certain it is correct,
save the file, compile it, link it, and run it. It will print the words Hello World to your screen.
Don't worry too much about how it works, this is really just to get you comfortable with the
development cycle. Every aspect of this program will be covered over the next couple of days.
WARNING: The following listing contains line numbers on the left. These numbers
are for reference within the book. They should not be typed in to your editor. For
example, in line 1 of Listing 1.1, you should enter:
#include <iostream.h>
Listing 1.1. HELLO.CPP, the Hello World program.
1:
2:
3:
4:
5:
6:
7:
#include <iostream.h>
int main()
{
cout << "Hello World!\n";
return 0;
}
Make certain you enter this exactly as shown. Pay careful attention to the punctuation. The << in line
5 is the redirection symbol, produced on most keyboards by holding the Shift key and pressing the
comma key twice. Line 5 ends with a semicolon; don't leave this off!
Also check to make sure you are following your compiler directions properly. Most compilers will
link automatically, but check your documentation. If you get errors, look over your code carefully and
determine how it is different from the above. If you see an error on line 1, such as cannot find
file iostream.h, check your compiler documentation for directions on setting up your
include path or environment variables. If you receive an error that there is no prototype for main,
add the line int main(); just before line 3. You will need to add this line before the beginning of
the main function in every program in this book. Most compilers don't require this, but a few do.
Your finished program will look like this:
1: #include <iostream.h>2:
3:
4:
5:
6:
7:
8:
int main();
{
cout <<"Hello World!\n";
return 0;
}
Try running HELLO.EXE; it should write
Hello World!
directly to your screen. If so, congratulations! You've just entered, compiled, and run your first C++
program. It may not look like much, but almost every professional C++ programmer started out with
this exact program.
Compile Errors
Compile-time errors can occur for any number of reasons. Usually they are a result of a typo or other
inadvertent minor error. Good compilers will not only tell you what you did wrong, they'll point you
to the exact place in your code where you made the mistake. The great ones will even suggest a
remedy!
You can see this by intentionally putting an error into your program. If HELLO.CPP ran smoothly,
edit it now and remove the closing brace on line 6. Your program will now look like Listing 1.2.
Listing 1.2. Demonstration of compiler error.
1:
2:
3:
4:
5:
6:
#include <iostream.h>
int main()
{
cout << "Hello World!\n";
return 0;
Recompile your program and you should see an error that looks similar to the following:
Hello.cpp, line 5: Compound statement missing terminating } in
function main().
This error tells you the file and line number of the problem, and what the problem is (although I admit
it is somewhat cryptic). Note that the error message points you to line 5. The compiler wasn't sure if
you intended to put the closing brace before or after the cout statement on line 5. Sometimes theerrors just get you to the general vicinity of the problem. If a compiler could perfectly identify every
problem, it would fix the code itself.
Summary
After reading this chapter, you should have a good understanding of how C++ evolved and what
problems it was designed to solve. You should feel confident that learning C++ is the right choice for
anyone interested in programming in the next decade. C++ provides the tools of object-oriented
programming and the performance of a systems-level language, which makes C++ the development
language of choice.
Today you learned how to enter, compile, link, and run your first C++ program, and what the normal
development cycle is. You also learned a little of what object-oriented programming is all about. You
will return to these topics during the next three weeks.
Q&A
Q. What is the difference between a text editor and a word processor?
A. A text editor produces files with plain text in them. There are no formatting commands or
other special symbols required by a particular word processor. Text files do not have automatic
word wrap, bold print, italics, and so forth.
Q. If my compiler has a built-in editor, must I use it?
A. Almost all compilers will compile code produced by any text editor. The advantages of
using the built-in text editor, however, might include the ability to quickly move back and forth
between the edit and compile steps of the development cycle. Sophisticated compilers include
a fully integrated development environment, allowing the programmer to access help files,
edit, and compile the code in place, and to resolve compile and link errors without ever leaving
the environment.
Q. Can I ignore warning messages from my compiler?
A. Many books hedge on this one, but I'll stake myself to this position: No! Get into the habit,
from day one, of treating warning messages as errors. C++ uses the compiler to warn you when
you are doing something you may not intend. Heed those warnings, and do what is required to
make them go away.
Q. What is compile time?
A. Compile time is the time when you run your compiler, as opposed to link time (when you
run the linker) or run-time (when running the program). This is just programmer shorthand to
identify the three times when errors usually surface.
WorkshopThe Workshop provides quiz questions to help you solidify your understanding of the material
covered and exercises to provide you with experience in using what you've learned. Try to answer the
quiz and exercise questions before checking the answers in Appendix D, and make sure you
understand the answers before continuing to the next chapter.
Quiz
1. What is the difference between an interpreter and a compiler?
2. How do you compile the source code with your compiler?
3. What does the linker do?
4. What are the steps in the normal development cycle?
Exercises
1. Look at the following program and try to guess what it does without running it.
1: #include <iostream.h>
2: int main()
3: {
4: int x = 5;
5: int y = 7;
6: cout "\n";
7: cout << x + y << " " << x * y;
8: cout "\n";
9:return 0;
10: }
2. Type in the program from Exercise 1, and then compile and link it. What does it do? Does it
do what you guessed?
3. Type in the following program and compile it. What error do you receive?
1:
2:
3:
4:
5:
6:
include <iostream.h>
int main()
{
cout << "Hello World\n";
return 0;
}
4. Fix the error in the program in Exercise 3, and recompile, link, and run it. What does it do?",#
Day 2
The Parts of a C++ Program
A Simple Program
Listing 2.1. HELLO.CPP demonstrates the parts of a C++ program.
A Brief Look at cout
Listing 2.2.
Using cout.
Comments
Types of Comments
Using Comments
Listing 2.3. HELP.CPP demonstrates comments.
Comments at the Top of Each File
A Final Word of Caution About Comments
Functions
Listing 2.4. Demonstrating a call to a function.
Using Functions
Listing 2.5. FUNC.CPP demonstrates a simple function.
Summary
Q&A
Workshop
Quiz
Exercises
Day 2
The Parts of a C++ Program
C++ programs consist of objects, functions, variables, and other component parts. Most of this book is
devoted to explaining these parts in depth, but to get a sense of how a program fits together you must
see a complete working program. Today you learn
The parts of a C++ program.
How the parts work together.
What a function is and what it does.
A Simple Program
Even the simple program HELLO.CPP from Day 1, "Getting Started," had many interesting parts.
This section will review this program in more detail. Listing 2.1 reproduces the original version of
HELLO.CPP for your convenience.
Listing 2.1. HELLO.CPP demonstrates the parts of a C++ program.
1: #include <iostream.h>
2:
3: int main()
4: {
5:
cout << "Hello World!\n";
6:
return 0;
7: }
Hello World!
On line 1, the file iostream.h is included in the file. The first character is the # symbol, which is a
signal to the preprocessor. Each time you start your compiler, the preprocessor is run. The
preprocessor reads through your source code, looking for lines that begin with the pound symbol (#),
and acts on those lines before the compiler runs.
include is a preprocessor instruction that says, "What follows is a filename. Find that file and read it in
right here." The angle brackets around the filename tell the preprocessor to look in all the usual places
for this file. If your compiler is set up correctly, the angle brackets will cause the preprocessor to look
for the file iostream.h in the directory that holds all the H files for your compiler. The file iostream.h
(Input-Output-Stream) is used by cout, which assists with writing to the screen. The effect of line 1 is
to include the file iostream.h into this program as if you had typed it in yourself.
New Term: The preprocessor runs before your compiler each time the compiler is invoked. The
preprocessor translates any line that begins with a pound symbol (#) into a special command, getting
your code file ready for the compiler.
Line 3 begins the actual program with a function named main(). Every C++ program has a main()
function. In general, a function is a block of code that performs one or more actions. Usually functions
are invoked or called by other functions, but main() is special. When your program starts, main() is
called automatically.
main(), like all functions, must state what kind of value it will return. The return value type for main()
in HELLO.CPP is void, which means that this function will not return any value at all. Returning
values from functions is discussed in detail on Day 4, "Expressions and Statements."All functions begin with an opening brace ({) and end with a closing brace (}). The braces for the
main() function are on lines 4 and 7. Everything between the opening and closing braces is considered
a part of the function.
The meat and potatoes of this program is on line 5. The object cout is used to print a message to the
screen. We'll cover objects in general on Day 6, "Basic Classes," and cout and its related object cin in
detail on Day 17, "The Preprocessor." These two objects, cout and cin, are used in C++ to print strings
and values to the screen. A string is just a set of characters.
Here's how cout is used: type the word cout, followed by the output redirection operator (<<).
Whatever follows the output redirection operator is written to the screen. If you want a string of
characters written, be sure to enclose them in double quotes ("), as shown on line 5.
New Term: A text string is a series of printable characters.
The final two characters, \n, tell cout to put a new line after the words Hello World! This special code
is explained in detail when cout is discussed on Day 17.
All ANSI-compliant programs declare main() to return an int. This value is "returned" to the operating
system when your program completes. Some programmers signal an error by returning the value 1. In
this book, main() will always return 0.
The main() function ends on line 7 with the closing brace.
A Brief Look at cout
On Day 16, "Streams," you will see how to use cout to print data to the screen. For now, you can use
cout without fully understanding how it works. To print a value to the screen, write the word cout,
followed by the insertion operator (<<), which you create by typing the less-than character (<) twice.
Even though this is two characters, C++ treats it as one.
Follow the insertion character with your data. Listing 2.2 illustrates how this is used. Type in the
example exactly as written, except substitute your own name where you see Jesse Liberty (unless your
name is Jesse Liberty, in which case leave it just the way it is; it's perfect-- but I'm still not splitting
royalties!).
Listing 2.2.Using cout.
1:
2:
3:
4:
5:
6:
// Listing 2.2 using cout
#include <iostream.h>
int main()
{
cout << "Hello there.\n";7:
cout << "Here is 5: " << 5 << "\n";
8:
cout << "The manipulator endl writes a new line to the
screen." <<
.&endl;
9:
cout << "Here is a very big number:\t" << 70000 << endl;
10:
cout << "Here is the sum of 8 and 5:\t" << 8+5 << endl;
11:
cout << "Here's a fraction:\t\t" << (float) 5/8 << endl;
12:
cout << "And a very very big number:\t" << (double) 7000
* 7000 <<
((endl;
13:
cout << "Don't forget to replace Jesse Liberty with your
name...\n";
14:
cout << "Jesse Liberty is a C++ programmer!\n";
15:
return 0;
16: }
Hello there.
Here is 5: 5
The manipulator endl writes a new line to the screen.
Here is a very big number:
70000
Here is the sum of 8 and 5:
13
Here's a fraction:
0.625
And a very very big number:
4.9e+07
Don't forget to replace Jesse Liberty with your name...
Jesse Liberty is a C++ programmer!
On line 3, the statement #include <iostream.h> causes the iostream.h file to be added to your source
code. This is required if you use cout and its related functions.
On line 6 is the simplest use of cout, printing a string or series of characters. The symbol \n is a
special formatting character. It tells cout to print a newline character to the screen.
Three values are passed to cout on line 7, and each value is separated by the insertion operator. The
first value is the string "Here is 5: ". Note the space after the colon. The space is part of the string.
Next, the value 5 is passed to the insertion operator and the newline character (always in double
quotes or single quotes). This causes the line
Here is 5: 5
to be printed to the screen. Because there is no newline character after the first string, the next value is
printed immediately afterwards. This is called concatenating the two values.
On line 8, an informative message is printed, and then the manipulator endl is used. The purpose of
endl is to write a new line to the screen. (Other uses for endl are discussed on Day 16.)On line 9, a new formatting character, \t, is introduced. This inserts a tab character and is used on lines
8-12 to line up the output. Line 9 shows that not only integers, but long integers as well can be
printed. Line 10 demonstrates that cout will do simple addition. The value of 8+5 is passed to cout,
but 13 is printed.
On line 11, the value 5/8 is inserted into cout. The term (float) tells cout that you want this value
evaluated as a decimal equivalent, and so a fraction is printed. On line 12 the value 7000 * 7000 is
given to cout, and the term (double) is used to tell cout that you want this to be printed using scientific
notation. All of this will be explained on Day 3, "Variables and Constants," when data types are
discussed.
On line 14, you substituted your name, and the output confirmed that you are indeed a C++
programmer. It must be true, because the computer said so!
Comments
When you are writing a program, it is always clear and self-evident what you are trying to do. Funny
thing, though--a month later, when you return to the program, it can be quite confusing and unclear.
I'm not sure how that confusion creeps into your program, but it always does.
To fight the onset of confusion, and to help others understand your code, you'll want to use comments.
Comments are simply text that is ignored by the compiler, but that may inform the reader of what you
are doing at any particular point in your program.
Types of Comments
C++ comments come in two flavors: the double-slash (//) comment, and the slash-star (/*) comment.
The double-slash comment, which will be referred to as a C++-style comment, tells the compiler to
ignore everything that follows this comment, until the end of the line.
The slash-star comment mark tells the compiler to ignore everything that follows until it finds a star-
slash (*/) comment mark. These marks will be referred to as C-style comments. Every /* must be
matched with a closing */.
As you might guess, C-style comments are used in the C language as well, but C++-style comments
are not part of the official definition of C.
Many C++ programmers use the C++-style comment most of the time, and reserve C-style comments
for blocking out large blocks of a program. You can include C++-style comments within a block
"commented out" by C-style comments; everything, including the C++-style comments, is ignored
between the C-style comment marks.
Using CommentsAs a general rule, the overall program should have comments at the beginning, telling you what the
program does. Each function should also have comments explaining what the function does and what
values it returns. Finally, any statement in your program that is obscure or less than obvious should be
commented as well.
Listing 2.3 demonstrates the use of comments, showing that they do not affect the processing of the
program or its output.
Listing 2.3. HELP.CPP demonstrates comments .
1: #include <iostream.h>
2:
3: int main()
4: {
5: /* this is a comment
6: and it extends until the closing
7: star-slash comment mark */
8:
cout << "Hello World!\n";
9:
// this comment ends at the end of the line
10:
cout << "That comment ended!\n";
11:
12: // double slash comments can be alone on a line
13: /* as can slash-star comments */
14:
return 0;
15: }
Hello World!
That comment ended!
The comments on lines 5 through 7 are completely ignored by the compiler, as
are the comments on lines 9, 12, and 13. The comment on line 9 ended with the
end of the line, however, while the comments on lines 5 and 13 required a closing comment mark.
Comments at the Top of Each File
It is a good idea to put a comment block at the top of every file you write. The exact style of this block
of comments is a matter of individual taste, but every such header should include at least the
following information:
The name of the function or program.
The name of the file.
What the function or program does.
A description of how the program works. The author's name.
A revision history (notes on each change made).
What compilers, linkers, and other tools were used to make the program.
Additional notes as needed.
For example, the following block of comments might appear at the top of the Hello World program.
/************************************************************
Program: Hello World
File: Hello.cpp
Function: Main (complete program listing in this file)
Description: Prints the words "Hello world" to the screen
Author: Jesse Liberty (jl)
Environment: Turbo C++ version 4, 486/66 32mb RAM, Windows 3.1
DOS 6.0. EasyWin module.
Notes: This is an introductory, sample program.
Revisions: 1.00
1.01
10/1/94 (jl) First release
10/2/94 (jl) Capitalized "World"
************************************************************/
It is very important that you keep the notes and descriptions up-to-date. A common problem with
headers like this is that they are neglected after their initial creation, and over time they become
increasingly misleading. When properly maintained, however, they can be an invaluable guide to the
overall program.
The listings in the rest of this book will leave off the headings in an attempt to save room. That does
not diminish their importance, however, so they will appear in the programs provided at the end of
each week.
A Final Word of Caution About Comments
Comments that state the obvious are less than useful. In fact, they can be counterproductive, because
the code may change and the programmer may neglect to update the comment. What is obvious to oneperson may be obscure to another, however, so judgment is required.
The bottom line is that comments should not say what is happening, they should say why it is
happening.
DO add comments to your code. DO keep comments up-to-date. DO use comments to
tell what a section of code does. DON'T use comments for self-explanatory code.
Functions
While main() is a function, it is an unusual one. Typical functions are called, or invoked, during the
course of your program. A program is executed line by line in the order it appears in your source
code, until a function is reached. Then the program branches off to execute the function. When the
function finishes, it returns control to the line of code immediately following the call to the function.
A good analogy for this is sharpening your pencil. If you are drawing a picture, and your pencil
breaks, you might stop drawing, go sharpen the pencil, and then return to what you were doing. When
a program needs a service performed, it can call a function to perform the service and then pick up
where it left off when the function is finished running. Listing 2.4 demonstrates this idea.
Listing 2.4. Demonstrating a call to a function.
1:
#include <iostream.h>
2:
3:
// function Demonstration Function
4:
// prints out a useful message
5:
void DemonstrationFunction()
6:
{
7:
cout << "In Demonstration Function\n";
8:
}
9:
10:
// function main - prints out a message, then
11:
// calls DemonstrationFunction, then prints out
12:
// a second message.
13:
int main()
14:
{
15:
cout << "In main\n" ;
16:
DemonstrationFunction();
17:
cout << "Back in main\n";
18:
return 0;
19: }
In main
In Demonstration FunctionBack in main
The function DemonstrationFunction() is defined on lines 5-7. When it is called, it prints a message to
the screen and then returns.
Line 13 is the beginning of the actual program. On line 15, main() prints out a message saying it is in
main(). After printing the message, line 16 calls DemonstrationFunction(). This call causes the
commands in DemonstrationFunction() to execute. In this case, the entire function consists of the code
on line 7, which prints another message. When DemonstrationFunction() completes (line 8), it returns
back to where it was called from. In this case the program returns to line 17, where main() prints its
final line.
Using Functions
Functions either return a value or they return void, meaning they return nothing. A function that adds
two integers might return the sum, and thus would be defined to return an integer value. A function
that just prints a message has nothing to return and would be declared to return void.
Functions consist of a header and a body. The header consists, in turn, of the return type, the function
name, and the parameters to that function. The parameters to a function allow values to be passed into
the function. Thus, if the function were to add two numbers, the numbers would be the parameters to
the function. Here's a typical function header:
int Sum(int a, int b)
A parameter is a declaration of what type of value will be passed in; the actual value passed in by the
calling function is called the argument. Many programmers use these two terms, parameters and
arguments, as synonyms. Others are careful about the technical distinction. This book will use the
terms interchangeably.
The body of a function consists of an opening brace, zero or more statements, and a closing brace.
The statements constitute the work of the function. A function may return a value, using a return
statement. This statement will also cause the function to exit. If you don't put a return statement into
your function, it will automatically return void at the end of the function. The value returned must be
of the type declared in the function header.
NOTE: Functions are covered in more detail on Day 5, "Functions." The types that can
be returned from a function are covered in more det+[radical][Delta][infinity]on Day 3.
The information provided today is to present you with an overview, because functions
will be used in almost all of your C++ programs.
Listing 2.5 demonstrates a function that takes two integer parameters and returns an integer value.
Don't worry about the syntax or the specifics of how to work with integer values (for example, int x)for now; that is covered in detail on Day 3.
Listing 2.5. FUNC.CPP demonstrates a simple function.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22: }
#include <iostream.h>
int Add (int x, int y)
{
cout << "In Add(), received " << x << " and " << y << "\n";
return (x+y);
}
int main()
{
cout << "I'm in main()!\n";
int a, b, c;
cout << "Enter two numbers: ";
cin >> a;
cin >> b;
cout << "\nCalling Add()\n";
c=Add(a,b);
cout << "\nBack in main().\n";
cout << "c was set to " << c;
cout << "\nExiting...\n\n";
return 0;
I'm in main()!
Enter two numbers: 3 5
Calling Add()
In Add(), received 3 and 5
Back in main().
c was set to 8
Exiting...
The function Add() is defined on line 2. It takes two integer parameters and returns an integer value.
The program itself begins on line 9 and on line 11, where it prints a message. The program prompts
the user for two numbers (lines 13 to 15). The user types each number, separated by a space, and then
presses the Enter key. main() passes the two numbers typed in by the user as arguments to the Add()
function on line 17.
Processing branches to the Add() function, which starts on line 2. The parameters a and b are printed
and then added together. The result is returned on line 6, and the function returns.In lines 14 and 15, the cin object is used to obtain a number for the variables a and b, and cout is used
to write the values to the screen. Variables and other aspects of this program are explored in depth in
the next few days.
Summary
The difficulty in learning a complex subject, such as programming, is that so much of what you learn
depends on everything else there is to learn. This chapter introduced the basic
parts of a simple C++ program. It also introduced the development cycle and a number of important
new terms.
Q&A
Q. What does #include do?
A. This is a directive to the preprocessor, which runs when you call your compiler. This
specific directive causes the file named after the word include to be read in, as if it were typed
in at that location in your source code.
Q. What is the difference between // comments and /* style comments?
A. The double-slash comments (//) "expire" at the end of the line. Slash-star (/*) comments are
in effect until a closing comment (*/). Remember, not even the end of the function terminates a
slash-star comment; you must put in the closing comment mark, or you will get a compile-time
error.
Q. What differentiates a good comment from a bad comment?
A. A good comment tells the reader why this particular code is doing whatever it is doing or
explains what a section of code is about to do. A bad comment restates what a particular line of
code is doing. Lines of code should be written so that they speak for themselves. Reading the
line of code should tell you what it is doing without needing a comment.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material
covered and exercises to provide you with experience in using what you've learned. Try to answer the
quiz and exercise questions before checking the answers in Appendix D, and make sure you
understand the answers before continuing to the next chapter.
Quiz
1. What is the difference between the compiler and the preprocessor?2. Why is the function main() special?
3. What are the two types of comments, and how do they differ?
4. Can comments be nested?
5. Can comments be longer than one line?
Exercises
1. Write a program that writes I love C++ to the screen.
2. Write the smallest program that can be compiled, linked, and run.
3. BUG BUSTERS: Enter this program and compile it. Why does it fail? How can you fix it?
1:
2:
3:
4:
5:
#include <iostream.h>
void main()
{
cout << Is there a bug here?";
}
4. Fix the bug in Exercise 3 and recompile, link, and run it.(+)
Day 3
Variables and Constants
What Is a Variable?
Figure 3.1.
Setting Aside Memory
Size of Integers
Listing 3.1. Determining the size of variable types
on your computer.
signed and unsigned
Fundamental Variable Types
Defining a Variable
Case Sensitivity
Keywords
Creating More Than One Variable at a Time
Assigning Values to Your Variables
Listing 3.2. A demonstration of the use of variables.
typedef
Listing 3.3. A demonstration of typedef.
When to Use short and When to Use long
Wrapping Around an unsigned Integer
Listing 3.4.
A demonstration of putting too large a value in an unsigned integer.
Wrapping Around a signed Integer
Listing 3.5.
A demonstration of adding too large a number to a signed integer.
Characters
Characters and Numbers
Listing 3.6. Printing characters based on numbers.
Special Printing Characters
Constants
Literal Constants
Symbolic Constants
Enumerated Constants
Listing 3.7. A demonstration of enumerated constants
Summary
Q&A
Workshop
Quiz
Exercises
Day 3
Variables and Constants
Programs need a way to store the data they use. Variables and constants offer various ways to
represent and manipulate that data.
Today you will learn
How to declare and define variables and constants.
How to assign values to variables and manipulate those values.
How to write the value of a variable to the screen.
What Is a Variable?
In C++ a variable is a place to store information. A variable is a location in your computer's memory
in which you can store a value and from which you can later retrieve that value.
Your computer's memory can be viewed as a series of cubbyholes. Each cubbyhole is one of many,
many such holes all lined up. Each cubbyhole--or memory location--is numbered sequentially. These
numbers are known as memory addresses. A variable reserves one or more cubbyholes in which you
may store a value.
Your variable's name (for example, myVariable) is a label on one of these cubbyholes, so that you
can find it easily without knowing its actual memory address. Figure 3.1 is a schematic representation
of this idea. As you can see from the figure, myVariable starts at memory address 103. Depending
on the size of myVariable, it can take up one or more memory addresses.
Figure 3.1. A schematic representation of memory.
NOTE: RAM is random access memory. When you run your program, it is loaded into
RAM from the disk file. All variables are also created in RAM. When programmers talk
of memory, it is usually RAM to which they are referring.Setting Aside Memory
When you define a variable in C++, you must tell the compiler what kind of variable it is: an integer, a
character, and so forth. This information tells the compiler how much room to set aside and what kind
of value you want to store in your variable.
Each cubbyhole is one byte large. If the type of variable you create is two bytes in size, it needs two
bytes of memory, or two cubbyholes. The type of the variable (for example, integer) tells the compiler
how much memory (how many cubbyholes) to set aside for the variable.
Because computers use bits and bytes to represent values, and because memory is measured in bytes,
it is important that you understand and are comfortable with these concepts. For a full review of this
topic, please read Appendix B, "C++ Keywords."
Size of Integers
On any one computer, each variable type takes up a single, unchanging amount of room. That is, an
integer might be two bytes on one machine, and four on another, but on either computer it is always
the same, day in and day out.
A char variable (used to hold characters) is most often one byte long. A short integer is two bytes
on most computers, a long integer is usually four bytes, and an integer (without the keyword short
or long) can be two or four bytes. Listing 3.1 should help you determine the exact size of these types
on your computer.
New Term: A character is a single letter, number, or symbol that takes up one byte of
memory.
Listing 3.1. Determining the size of variable types on your computer.
1:
#include <iostream.h>
2:
3:
int main()
4:
{
5:
cout << "The size of
" bytes.\n";
6:
cout << "The size of
" bytes.\n";
7:
cout << "The size of
" bytes.\n";
8:
cout << "The size of
" bytes.\n";
9:
cout << "The size of
an int is:\t\t"
<< sizeof(int)
<<
a short int is:\t" << sizeof(short) <<
a long int is:\t" << sizeof(long) <<
a char is:\t\t" << sizeof(char) <<
a float is:\t\t" << sizeof(float) <<" bytes.\n";
10:
cout << "The size of a double is:\t"
<< sizeof(double) <<
" bytes.\n";
11:
12:
return 0;
13: }
Output: The size of an int is:
2 bytes.
The size of a short int is:
2 bytes.
The size of a long int is:
4 bytes.
The size of a char is:
1 bytes.
The size of a float is:
4 bytes.
The size of a double is:
8 bytes.
NOTE: On your computer, the number of bytes presented might be different.
Analysis: Most of Listing 3.1 should be pretty familiar. The one new feature is the use of the
sizeof() function in lines 5 through 10. sizeof() is provided by your compiler, and it
tells you the size of the object you pass in as a parameter. For example, on line 5 the keyword
int is passed into sizeof(). Using sizeof(), I was able to determine that on my
computer an int is equal to a short int, which is 2 bytes.
signed and unsigned
In addition, all integer types come in two varieties: signed and unsigned. The idea here is that
sometimes you need negative numbers, and sometimes you don't. Integers (short and long)
without the word "unsigned" are assumed to be signed. Signed integers are either negative or
positive. Unsigned integers are always positive.
Because you have the same number of bytes for both signed and unsigned integers, the largest
number you can store in an unsigned integer is twice as big as the largest positive number you can
store in a signed integer. An unsigned short integer can handle numbers from 0 to 65,535.
Half the numbers represented by a signed short are negative, thus a signed short can only
represent numbers from -32,768 to 32,767. If this is confusing, be sure to read Appendix A, "Operator
Precedence."
Fundamental Variable Types
Several other variable types are built into C++. They can be conveniently divided into integer
variables (the type discussed so far), floating-point variables, and character variables.
Floating-point variables have values that can be expressed as fractions--that is, they are real numbers.Character variables hold a single byte and are used for holding the 256 characters and symbols of the
ASCII and extended ASCII character sets.
New Term: The ASCII character set is the set of characters standardized for use on computers.
ASCII is an acronym for American Standard Code for Information Interchange. Nearly every
computer operating system supports ASCII, though many support other international character
sets as well.
The types of variables used in C++ programs are described in Table 3.1. This table shows the variable
type, how much room this book assumes it takes in memory, and what kinds of values can be stored in
these variables. The values that can be stored are determined by the size of the variable types, so
check your output from Listing 3.1.
Table 3.1. Variable Types.
Type
unsigned short
int
short int
unsigned long
int
long int
int (16 bit)
int (32 bit)
unsigned int (16
bit)
unsigned int (32
bit)
char
float
double
Size Values
2 bytes 0 to 65,535
2 bytes -32,768 to 32,767
4 bytes 0 to 4,294,967,295
4 bytes
2 bytes
4 bytes -2,147,483,648 to 2,147,483,647
-32,768 to 32,767
-2,147,483,648 to 2,147,483,647
2 bytes 0 to 65,535
2 bytes 0 to 4,294,967,295
1 byte
4 bytes
8 bytes 256 character values
1.2e-38 to 3.4e38
2.2e-308 to 1.8e308
NOTE: The sizes of variables might be different from those shown in Table 3.1,
depending on the compiler and the computer you are using. If your computer had the
same output as was presented in Listing 3.1, Table 3.1 should apply to your compiler. If
your output from Listing 3.1 was different, you should consult your compiler's manual
for the values that your variable types can hold.Defining a Variable
You create or define a variable by stating its type, followed by one or more spaces, followed by the
variable name and a semicolon. The variable name can be virtually any combination of letters, but
cannot contain spaces. Legal variable names include x, J23qrsnf, and myAge. Good variable
names tell you what the variables are for; using good names makes it easier to understand the flow of
your program. The following statement defines an integer variable called myAge:
int myAge;
As a general programming practice, avoid such horrific names as J23qrsnf, and restrict single-
letter variable names (such as x or i) to variables that are used only very briefly. Try to use
expressive names such as myAge or howMany. Such names are easier to understand three weeks later
when you are scratching your head trying to figure out what you meant when you wrote that line of
code.
Try this experiment: Guess what these pieces of programs do, based on the first few lines of code:
Example 1
main()
{
unsigned short x;
unsigned short y;
ULONG z;
z = x * y;
}
Example 2
main ()
{
unsigned short
unsigned short
unsigned short
Area = Width *
}
Width;
Length;
Area;
Length;
Clearly, the second program is easier to understand, and the inconvenience of having to type the
longer variable names is more than made up for by how much easier it is to maintain the second
program.
Case SensitivityC++ is case-sensitive. In other words, uppercase and lowercase letters are considered to be different.
A variable named age is different from Age, which is different from AGE.
NOTE: Some compilers allow you to turn case sensitivity off. Don't be tempted to do
this; your programs won't work with other compilers, and other C++ programmers will
be very confused by your code.
There are various conventions for how to name variables, and although it doesn't much matter which
method you adopt, it is important to be consistent throughout your program.
Many programmers prefer to use all lowercase letters for their variable names. If the name requires
two words (for example, my car), there are two popular conventions: my_car or myCar. The latter
form is called camel-notation, because the capitalization looks something like a camel's hump.
Some people find the underscore character (my_car) to be easier to read, while others prefer to avoid
the underscore, because it is more difficult to type. This book uses camel-notation, in which the
second and all subsequent words are capitalized: myCar, theQuickBrownFox, and so forth.
NOTE: Many advanced programmers employ a notation style that is often referred to
as Hungarian notation. The idea behind Hungarian notation is to prefix every variable
with a set of characters that describes its type. Integer variables might begin with a
lowercase letter i, longs might begin with a lowercase l. Other notations indicate
constants, globals, pointers, and so forth. Most of this is much more important in C
programming, because C++ supports the creation of user-defined types (see Day 6,
"Basic Classes") and because C++ is strongly typed.
Keywords
Some words are reserved by C++, and you may not use them as variable names. These are keywords
used by the compiler to control your program. Keywords include if, while, for, and main. Your
compiler manual should provide a complete list, but generally, any reasonable name for a variable is
almost certainly not a keyword.
DO define a variable by writing the type, then the variable name. DO use meaningful
variable names. DO remember that C++ is case sensitive. DON'T use C++ keywords as
variable names. DO understand the number of bytes each variable type consumes in
memory, and what values can be stored in variables of that type. DON'T use
unsigned variables for negative numbers.Creating More Than One Variable at a Time
You can create more than one variable of the same type in one statement by writing the type and then
the variable names, separated by commas. For example:
unsigned int myAge, myWeight;
long area, width, length;
// two unsigned int variables
// three longs
As you can see, myAge and myWeight are each declared as unsigned integer variables. The
second line declares three individual long variables named area, width, and length. The type
(long) is assigned to all the variables, so you cannot mix types in one definition statement.
Assigning Values to Your Variables
You assign a value to a variable by using the assignment operator (=). Thus, you would assign 5 to
Width by writing
unsigned short Width;
Width = 5;
You can combine these steps and initialize Width when you define it by writing
unsigned short Width = 5;
Initialization looks very much like assignment, and with integer variables, the difference is minor.
Later, when constants are covered, you will see that some values must be initialized because they
cannot be assigned to. The essential difference is that initialization takes place at the moment you
create the variable.
Just as you can define more than one variable at a time, you can initialize more than one variable at
creation. For example:
// create two long variables and initialize them
$)long width = 5, length = 7;
This example initializes the long integer variable width to the value 5 and the long integer
variable length to the value 7. You can even mix definitions and initializations:
int myAge = 39, yourAge, hisAge = 40;
This example creates three type int variables, and it initializes the first and third.
Listing 3.2 shows a complete program, ready to compile, that computes the area of a rectangle and
writes the answer to the screen.Listing 3.2. A demonstration of the use of variables.
1:
// Demonstration of variables
2:
#include <iostream.h>
3:
4:
int main()
5:
{
6:
unsigned short int Width = 5, Length;
7:
Length = 10;
8:
9:
// create an unsigned short and initialize with result
10:
// of multiplying Width by Length
11:
unsigned short int Area = Width * Length;
12:
13:
cout << "Width:" << Width << "\n";
14:
cout << "Length: " << Length << endl;
15:
cout << "Area: " << Area << endl;
16:
return 0;
17: }
Output: Width:5
Length: 10
Area: 50
Analysis: Line 2 includes the required include statement for the iostream's library so that cout
will work. Line 4 begins the program.
On line 6, Width is defined as an unsigned short integer, and its value is initialized to 5.
Another unsigned short integer, Length, is also defined, but it is not initialized. On line 7, the
value 10 is assigned to Length.
On line 11, an unsigned short integer, Area, is defined, and it is initialized with the value
obtained by multiplying Width times Length. On lines 13-15, the values of the variables are printed
to the screen. Note that the special word endl creates a new line.
typedef
It can become tedious, repetitious, and, most important, error-prone to keep writing unsigned
short int. C++ enables you to create an alias for this phrase by using the keyword typedef,
which stands for type definition.
In effect, you are creating a synonym, and it is important to distinguish this from creating a new type
(which you will do on Day 6). typedef is used by writing the keyword typedef, followed by the
existing type and then the new name. For exampletypedef unsigned short int USHORT
creates the new name USHORT that you can use anywhere you might have written unsigned
short int. Listing 3.3 is a replay of Listing 3.2, using the type definition USHORT rather than
unsigned short int.
Listing 3.3. A demonstration of typedef .
1:
// *****************
2:
// Demonstrates typedef keyword
3:
#include <iostream.h>
4:
5:
typedef unsigned short int USHORT;
//typedef defined
6:
7:
void main()
8:
{
9:
USHORT Width = 5;
10:
USHORT Length;
11:
Length = 10;
12:
USHORT Area = Width * Length;
13:
cout << "Width:" << Width << "\n";
14:
cout << "Length: " << Length << endl;
15:
cout << "Area: " << Area <<endl;
16: }
Output: Width:5
Length: 10
Area: 50
Analysis: On line 5, USHORT is typedefined as a synonym for unsigned short int. The
program is very much like Listing 3.2, and the output is the same.
When to Use short and When to Use long
One source of confusion for new C++ programmers is when to declare a variable to be type long and
when to declare it to be type short. The rule, when understood, is fairly straightforward: If there is
any chance that the value you'll want to put into your variable will be too big for its type, use a larger
type.
As seen in Table 3.1, unsigned short integers, assuming that they are two bytes, can hold a
value only up to 65,535. Signed short integers can hold only half that. Although unsigned
long integers can hold an extremely large number (4,294,967,295) that is still quite finite. If you
need a larger number, you'll have to go to float or double, and then you lose some precision.
Floats and doubles can hold extremely large numbers, but only the first 7 or 19 digits are significanton most computers. That means that the number is rounded off after that many digits.
Wrapping Around an unsigned Integer
The fact that unsigned long integers have a limit to the values they can hold is only rarely a
problem, but what happens if you do run out of room?
When an unsigned integer reaches its maximum value, it wraps around and starts over, much as a
car odometer might. Listing 3.4 shows what happens if you try to put too large a value into a short
integer.
Listing 3.4.A demonstration of putting too large a value in an unsigned
integer.
1: #include <iostream.h>
2: int main()
3: {
4:
unsigned short int smallNumber;
5:
smallNumber = 65535;
6:
cout << "small number:" << smallNumber << endl;
7:
smallNumber++;
8:
cout << "small number:" << smallNumber << endl;
9:
smallNumber++;
10:
cout << "small number:" << smallNumber << endl;
11:
return 0;
12: }
Output: small number:65535
small number:0
small number:1
Analysis: On line 4, smallNumber is declared to be an unsigned short int, which on my
computer is a two-byte variable, able to hold a value between 0 and 65,535. On line 5, the maximum
value is assigned to smallNumber, and it is printed on line 6.
On line 7, smallNumber is incremented; that is, 1 is added to it. The symbol for incrementing is ++
(as in the name C++--an incremental increase from C). Thus, the value in smallNumber would be
65,536. However, unsigned short integers can't hold a number larger than 65,535, so the value
is wrapped around to 0, which is printed on line 8.
On line 9 smallNumber is incremented again, and then its new value, 1, is printed.
Wrapping Around a signed Integer
A signed integer is different from an unsigned integer, in that half of the values you canrepresent are negative. Instead of picturing a traditional car odometer, you might picture one that
rotates up for positive numbers and down for negative numbers. One mile from 0 is either 1 or -1.
When you run out of positive numbers, you run right into the largest negative numbers and then count
back down to 0. Listing 3.5 shows what happens when you add 1 to the maximum positive number in
an unsigned short integer.
Listing 3.5. A demonstration of adding too large a number to a signed
integer.
1: #include <iostream.h>
2: int main()
3: {
4:
short int smallNumber;
5:
smallNumber = 32767;
6:
cout << "small number:" << smallNumber << endl;
7:
smallNumber++;
8:
cout << "small number:" << smallNumber << endl;
9:
smallNumber++;
10:
cout << "small number:" << smallNumber << endl;
11:
return 0;
12: }
Output: small number:32767
small number:-32768
small number:-32767
Analysis: On line 4, smallNumber is declared this time to be a signed short integer (if you
don't explicitly say that it is unsigned, it is assumed to be signed). The program proceeds much
as the preceding one, but the output is quite different. To fully understand this output, you must be
comfortable with how signed numbers are represented as bits in a two-byte integer. For details,
check Appendix C, "Binary and Hexadecimal."
The bottom line, however, is that just like an unsigned integer, the signed integer wraps around
from its highest positive value to its highest negative value.
Characters
Character variables (type char) are typically 1 byte, enough to hold 256 values (see Appendix C).
A char can be interpreted as a small number (0-255) or as a member of the ASCII set. ASCII stands
for the American Standard Code for Information Interchange. The ASCII character set and its ISO
(International Standards Organization) equivalent are a way to encode all the letters, numerals, and
punctuation marks.
Computers do not know about letters, punctuation, or sentences. All they understand are
numbers. In fact, all they really know about is whether or not a sufficient amount ofelectricity is at a particular junction of wires. If so, it is represented internally as a 1; if
not, it is represented as a 0. By grouping ones and zeros, the computer is able to
generate patterns that can be interpreted as numbers, and these in turn can be assigned
to letters and punctuation.
In the ASCII code, the lowercase letter "a" is assigned the value 97. All the lower- and uppercase
letters, all the numerals, and all the punctuation marks are assigned values between 1 and 128.
Another 128 marks and symbols are reserved for use by the computer maker, although the IBM
extended character set has become something of a standard.
Characters and Numbers
When you put a character, for example, `a', into a char variable, what is really there is just a
number between 0 and 255. The compiler knows, however, how to translate back and forth between
characters (represented by a single quotation mark and then a letter, numeral, or punctuation mark,
followed by a closing single quotation mark) and one of the ASCII values.
The value/letter relationship is arbitrary; there is no particular reason that the lowercase "a" is
assigned the value 97. As long as everyone (your keyboard, compiler, and screen) agrees, there is no
problem. It is important to realize, however, that there is a big difference between the value 5 and the
character `5'. The latter is actually valued at 53, much as the letter `a' is valued at 97.
Listing 3.6. Printing characters based on numbers
1:
#include <iostream.h>
2:
int main()
3:
{
4:
for (int i = 32; i<128; i++)
5:
cout << (char) i;
6:
return 0;
7: }
Output: !"#$%G'()*+,./0123456789:;<>?@ABCDEFGHIJKLMNOP
_QRSTUVWXYZ[\]^'abcdefghijklmnopqrstuvwxyz<|>~s
This simple program prints the character values for the integers 32 through 127.
Special Printing Characters
The C++ compiler recognizes some special characters for formatting. Table 3.2 shows the most
common ones. You put these into your code by typing the backslash (called the escape character),
followed by the character. Thus, to put a tab character into your code, you would enter a single
quotation mark, the slash, the letter t, and then a closing single quotation mark:
char tabCharacter = `\t';This example declares a char variable (tabCharacter) and initializes it with the character value
\t, which is recognized as a tab. The special printing characters are used when printing either to the
screen or to a file or other output device.
New Term: An escape character changes the meaning of the character that follows it. For
example, normally the character n means the letter n, but when it is preceded by the escape
character (\) it means new line.
Table 3.2. The Escape Characters .
Character What it means
new line
\n
tab
\t
backspace
\b
double quote
\"
single quote
\'
question mark
\?
backslash
\\
Constants
Like variables, constants are data storage locations. Unlike variables, and as the name implies,
constants don't change. You must initialize a constant when you create it, and you cannot assign a new
value later.
Literal Constants
C++ has two types of constants: literal and symbolic.
A literal constant is a value typed directly into your program wherever it is needed. For example
int myAge = 39;
myAge is a variable of type int; 39 is a literal constant. You can't assign a value to 39, and its value
can't be changed.
Symbolic Constants
A symbolic constant is a constant that is represented by a name, just as a variable is represented.Unlike a variable, however, after a constant is initialized, its value can't be changed.
If your program has one integer variable named students and another named classes, you could
compute how many students you have, given a known number of classes, if you knew there were 15
students per class:
students = classes * 15;
NOTE: * indicates multiplication.
In this example, 15 is a literal constant. Your code would be easier to read, and easier to maintain, if
you substituted a symbolic constant for this value:
students = classes * studentsPerClass
If you later decided to change the number of students in each class, you could do so where you define
the constant studentsPerClass without having to make a change every place you used that
value.
There are two ways to declare a symbolic constant in C++. The old, traditional, and now obsolete way
is with a preprocessor directive, #define. Defining Constants with #define To define a constant the
traditional way, you would enter this:
#define studentsPerClass 15
Note that studentsPerClass is of no particular type (int, char, and so on). #define does a
simple text substitution. Every time the preprocessor sees the word studentsPerClass, it puts in
the text 15.
Because the preprocessor runs before the compiler, your compiler never sees your constant; it sees the
number 15. Defining Constants with const Although #define works, there is a new, much better
way to define constants in C++:
const unsigned short int studentsPerClass = 15;
This example also declares a symbolic constant named studentsPerClass, but this time
studentsPerClass is typed as an unsigned short int. This method has several
advantages in making your code easier to maintain and in preventing bugs. The biggest difference is
that this constant has a type, and the compiler can enforce that it is used according to its type.
NOTE: Constants cannot be changed while the program is running. If you need to
change studentsPerClass, for example, you need to change the code andrecompile.
DON'T use the term int. Use short and long to make it clear which size number
you intended. DO watch for numbers overrunning the size of the integer and wrapping
around incorrect values. DO give your variables meaningful names that reflect their
use. DON'T use keywords as variable names.
Enumerated Constants
Enumerated constants enable you to create new types and then to define variables of those types
whose values are restricted to a set of possible values. For example, you can declare COLOR to be an
enumeration, and you can define that there are five values for COLOR: RED, BLUE, GREEN, WHITE,
and BLACK.
The syntax for enumerated constants is to write the keyword enum, followed by the type name, an
open brace, each of the legal values separated by a comma, and finally a closing brace and a
semicolon. Here's an example:
enum COLOR { RED, BLUE, GREEN, WHITE, BLACK };
This statement performs two tasks:
1. It makes COLOR the name of an enumeration, that is, a new type.
2. It makes RED a symbolic constant with the value 0, BLUE a symbolic constant with the
value 1, GREEN a symbolic constant with the value 2, and so forth.
Every enumerated constant has an integer value. If you don't specify otherwise, the first constant will
have the value 0, and the rest will count up from there. Any one of the constants can be initialized
with a particular value, however, and those that are not initialized will count upward from the ones
before them. Thus, if you write
enum Color { RED=100, BLUE, GREEN=500, WHITE, BLACK=700 };
then RED will have the value 100; BLUE, the value 101; GREEN, the value 500; WHITE, the value
501; and BLACK, the value 700.
You can define variables of type COLOR, but they can be assigned only one of the enumerated values
(in this case, RED, BLUE, GREEN, WHITE, or BLACK, or else 100, 101, 500, 501, or 700). You
can assign any color value to your COLOR variable. In fact, you can assign any integer value, even if it
is not a legal color, although a good compiler will issue a warning if you do. It is important to realize
that enumerator variables actually are of type unsigned int, and that the enumerated constantsequate to integer variables. It is, however, very convenient to be able to name these values when
working with colors, days of the week, or similar sets of values. Listing 3.7 presents a program that
uses an enumerated type.
Listing 3.7. A demonstration of enumerated constants .
1: #include <iostream.h>
2: int main()
3: {
4:
enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday,
Friday,
#,_Saturday };
5:
6:
Days DayOff;
7:
int x;
8:
9:
cout << "What day would you like off (0-6)? ";
10:
cin >> x;
11:
DayOff = Days(x);
12:
13:
if (DayOff == Sunday || DayOff == Saturday)
14:
cout << "\nYou're already off on weekends!\n";
15:
else
16:
cout << "\nOkay, I'll put in the vacation day.\n";
17:
return 0;
18: }
Output: What day would you like off (0-6)? 1
Okay, I'll put in the vacation day.
What day would you like off (0-6)?
0
You're already off on weekends!
Analysis: On line 4, the enumerated constant DAYS is defined, with seven values counting upward
from 0. The user is prompted for a day on line 9. The chosen value, a number between 0 and 6, is
compared on line 13 to the enumerated values for Sunday and Saturday, and action is taken
accordingly.
The if statement will be covered in more detail on Day 4, "Expressions and Statements."
You cannot type the word "Sunday" when prompted for a day; the program does not know how to
translate the characters in Sunday into one of the enumerated values.
NOTE: For this and all the small programs in this book, I've left out all the code you
would normally write to deal with what happens when the user types inappropriate data.For example, this program doesn't check, as it would in a real program, to make sure
that the user types a number between 0 and 6. This detail has been left out to keep these
programs small and simple, and to focus on the issue at hand.
Summary
This chapter has discussed numeric and character variables and constants, which are used by C++ to
store data during the execution of your program. Numeric variables are either integral (char, short,
and long int) or they are floating point (float and double). Numeric variables can also be
signed or unsigned. Although all the types can be of various sizes among different computers,
the type specifies an exact size on any given computer.
You must declare a variable before it can be used, and then you must store the type of data that you've
declared as correct for that variable. If you put too large a number into an integral variable, it wraps
around and produces an incorrect result.
This chapter also reviewed literal and symbolic constants, as well as enumerated constants, and
showed two ways to declare a symbolic constant: using #define and using the keyword const.
Q&A
Q. If a short int can run out of room and wrap around, why not always use long integers?
A .Both short integers and long integers will run out of room and wrap around, but a long
integer will do so with a much larger number. For example, an unsigned short int will
wrap around after 65,535, whereas an unsigned long int will not wrap around until
4,294,967,295. However, on most machines, a long integer takes up twice as much memory
every time you declare one (4 bytes versus 2 bytes), and a program with 100 such variables
will consume an extra 200 bytes of RAM. Frankly, this is less of a problem than it used to be,
because most personal computers now come with many thousands (if not millions) of bytes of
memory.
Q. What happens if I assign a number with a decimal point to an integer rather than to a
float? Consider the following line of code:
int aNumber = 5.4;
A. A good compiler will issue a warning, but the assignment is completely legal. The number
you've assigned will be truncated into an integer. Thus, if you assign 5.4 to an integer
variable, that variable will have the value 5. Information will be lost, however, and if you then
try to assign the value in that integer variable to a float variable, the float variable will
have only 5.
Q. Why not use literal constants; why go to the bother of using symbolic constants?A. If you use the value in many places throughout your program, a symbolic constant allows
all the values to change just by changing the one definition of the constant. Symbolic constants
also speak for themselves. It might be hard to understand why a number is being multiplied by
360, but it's much easier to understand what's going on if the number is being multiplied by
degreesInACircle.
Q. What happens if I assign a negative number to an unsigned variable? Consider the
following line of code:
unsigned int aPositiveNumber = -1;
A. A good compiler will warn, but the assignment is legal. The negative number will be
assessed as a bit pattern and assigned to the variable. The value of that variable will then be
interpreted as an unsigned number. Thus, -1, whose bit pattern is 11111111 11111111
(0xFF in hex), will be assessed as the unsigned value 65,535. If this information confuses
you, refer to Appendix C.
Q. Can I work with C++ without understanding bit patterns, binary arithmetic, and
hexadecimal?
A. Yes, but not as effectively as if you do understand these topics. C++ does not do as good a
job as some languages at "protecting" you from what the computer is really doing. This is
actually a benefit, because it provides you with tremendous power that other languages don't.
As with any power tool, however, to get the most out of C++ you must understand how it
works. Programmers who try to program in C++ without understanding the fundamentals of
the binary system often are confused by their results.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material
covered, and exercises to provide you with experience in using what you've learned. Try to answer the
quiz and exercise questions before checking the answers in Appendix D, and make sure that you
understand the answers before continuing to the next chapter.
Quiz
1. What is the difference between an integral variable and a floating-point variable?
2. What are the differences between an unsigned short int and a long int?
3. What are the advantages of using a symbolic constant rather than a literal constant?
4. What are the advantages of using the const keyword rather than #define?
5. What makes for a good or bad variable name?6. Given this enum, what is the value of BLUE?
enum COLOR { WHITE, BLACK = 100, RED, BLUE, GREEN = 300 };
7. Which of the following variable names are good, which are bad, and which are invalid?
a. Age
b. !ex
c. R79J
d. TotalIncome
e. __Invalid
Exercises
1. What would be the correct variable type in which to store the following information?
a. Your age.
b. The area of your backyard.
c. The number of stars in the galaxy.
d. The average rainfall for the month of January.
2. Create good variable names for this information.
3. Declare a constant for pi as 3.14159.
4. Declare a float variable and initialize it using your pi constant.
Although this last variation is perfectly legal, it is also perfectly foolish. Whitespace can be used to
make your programs more readable and easier to maintain, or it can be used to create horrific and
indecipherable code. In this, as in all things, C++ provides the power; you supply the judgment.
New Term: Whitespace characters (spaces, tabs, and newlines) cannot be seen. If these
characters are printed, you see only the white of the paper.
Blocks and Compound Statements
Any place you can put a single statement, you can put a compound statement, also called a block. A
block begins with an opening brace ({) and ends with a closing brace (}). Although every statement
in the block must end with a semicolon, the block itself does not end with a semicolon. For example
{
temp = a;
a = b;
b = temp;
}
This block of code acts as one statement and swaps the values in the variables a and b.
DO use a closing brace any time you have an opening brace. DO end your statements
with a semicolon. DO use whitespace judiciously to make your code clearer.
ExpressionsAnything that evaluates to a value is an expression in C++. An expression is said to return a value.
Thus, 3+2; returns the value 5 and so is an expression. All expressions are statements.
The myriad pieces of code that qualify as expressions might surprise you. Here are three examples:
3.2
PI
3.14
SecondsPerMinute
// returns the value 3.2
// float const that returns the value
// int const that returns 60
Assuming that PI is a constant equal to 3.14 and SecondsPerMinute is a constant equal to 60,
all three of these statements are expressions.
The complicated expression
x = a + b;
not only adds a and b and assigns the result to x, but returns the value of that assignment (the value of
x) as well. Thus, this statement is also an expression. Because it is an expression, it can be on the right
side of an assignment operator:
y = x = a + b;
This line is evaluated in the following order: Add a to b.
Assign the result of the expression a + b to x.
Assign the result of the assignment expression x = a + b to y.
If a, b, x, and y are all integers, and if a has the value 2 and b has the value 5, both x and y will be
assigned the value 7.
Listing 4.1. Evaluating complex expressions.
1:
2:
3:
4:
5:
6:
7:
8:
9:
#include <iostream.h>
int main()
{
int a=0, b=0, x=0, y=35;
cout << "a: " << a << " b: " << b;
cout << " x: " << x << " y: " << y << endl;
a = 9;
b = 7;
y = x = a+b;10:
cout << "a: " << a << " b: " << b;
11:
cout << " x: " << x << " y: " << y << endl;
12:
return 0;
13: }
Output: a: 0 b: 0 x: 0 y: 35
a: 9 b: 7 x: 16 y: 16
Analysis: On line 4, the four variables are declared and initialized. Their values are printed on lines 5
and 6. On line 7, a is assigned the value 9. One line 8, b is assigned the value 7. On line 9, the values
of a and b are summed and the result is assigned to x. This expression (x = a+b) evaluates to a
value (the sum of a + b), and that value is in turn assigned to y.
Operators
An operator is a symbol that causes the compiler to take an action. Operators act on operands, and in
C++ all operands are expressions. In C++ there are several different categories of operators. Two of
these categories are
Assignment operators.
Mathematical operators.
Assignment Operator
The assignment operator (=) causes the operand on the left side of the assignment operator to have its
value changed to the value on the right side of the assignment operator. The expression
x = a + b;
assigns the value that is the result of adding a and b to the operand x.
An operand that legally can be on the left side of an assignment operator is called an lvalue. That
which can be on the right side is called (you guessed it) an rvalue.
Constants are r-values. They cannot be l-values. Thus, you can write
x = 35;
// ok
but you can't legally write
35 = x;
// error, not an lvalue!
New Term: An lvalue is an operand that can be on the left side of an expression. An rvalue isan operand that can be on the right side of an expression. Note that all l-values are r-values, but
not all r-values are l-values. An example of an rvalue that is not an lvalue is a literal. Thus, you
can write x = 5;, but you cannot write 5 = x;.
Mathematical Operators
There are five mathematical operators: addition (+), subtraction (-), multiplication (*), division (/),
and modulus (%).
Addition and subtraction work as you would expect, although subtraction with unsigned integers
can lead to surprising results, if the result is a negative number. You saw something much like this
yesterday, when variable overflow was described. Listing 4.2 shows what happens when you subtract
a large unsigned number from a small unsigned number.
Listing 4.2. A demonstration of subtraction and integer overflow .
1: // Listing 4.2 - demonstrates subtraction and
2: // integer overflow
3: #include <iostream.h>
4:
5: int main()
6: {
7:
unsigned int difference;
8:
unsigned int bigNumber = 100;
9:
unsigned int smallNumber = 50;
10:
difference = bigNumber - smallNumber;
11:
cout << "Difference is: " << difference;
12:
difference = smallNumber - bigNumber;
13:
cout << "\nNow difference is: " << difference <<endl;
14:
return 0;
15: }
Output: Difference is: 50
Now difference is: 4294967246
Analysis: The subtraction operator is invoked on line 10, and the result is printed on line 11, much as
we might expect. The subtraction operator is called again on line 12, but this time a large unsigned
number is subtracted from a small unsigned number. The result would be negative, but because it is
evaluated (and printed) as an unsigned number, the result is an overflow, as described yesterday.
This topic is reviewed in detail in Appendix A, "Operator Precedence."
Integer Division and Modulus
Integer division is somewhat different from everyday division. When you divide 21 by 4, the result is
a real number (a number with a fraction). Integers don't have fractions, and so the "remainder" islopped off. The answer is therefore 5. To get the remainder, you take 21 modulus 4 (21 % 4) and the
result is 1. The modulus operator tells you the remainder after an integer division.
Finding the modulus can be very useful. For example, you might want to print a statement on every
10th action. Any number whose value is 0 when you modulus 10 with that number is an exact
multiple of 10. Thus 1 % 10 is 1, 2 % 10 is 2, and so forth, until 10 % 10, whose result is 0. 11 % 10 is
back to 1, and this pattern continues until the next multiple of 10, which is 20. We'll use this technique
when looping is discussed on Day 7, "More Program Flow."
WARNING: Many novice C++ programmers inadvertently put a semicolon after their if
statements:
if(SomeValue < 10);
SomeValue = 10;
What was intended here was to test whether SomeValue is less than 10, and if so, to set it to
10, making 10 the minimum value for SomeValue. Running this code snippet will show that
SomeValue is always set to 10! Why? The if statement terminates with the semicolon (the
do-nothing operator). Remember that indentation has no meaning to the compiler. This snippet
could more accurately have been written as:
if (SomeValue < 10) // test
; // do nothing
SomeValue = 10; // assign
Removing the semicolon will make the final line part of the if statement and will make this
code do what was intended.
Combining the Assignment and Mathematical Operators
It is not uncommon to want to add a value to a variable, and then to assign the result back into the
variable. If you have a variable myAge and you want to increase the value by two, you can write
int myAge = 5;
int temp;
temp = myAge + 2;
myAge = temp;
// add 5 + 2 and put it in temp
// put it back in myAge
This method, however, is terribly convoluted and wasteful. In C++, you can put the same variable on
both sides of the assignment operator, and thus the preceding becomes
myAge = myAge + 2;which is much better. In algebra this expression would be meaningless, but in C++ it is read as "add
two to the value in myAge and assign the result to myAge."
Even simpler to write, but perhaps a bit harder to read is
myAge += 2;
The self-assigned addition operator (+=) adds the rvalue to the lvalue and then reassigns the result
into the lvalue. This operator is pronounced "plus-equals." The statement would be read "myAge plus-
equals two." If myAge had the value 4 to start, it would have 6 after this statement.
There are self-assigned subtraction (-=), division (/=), multiplication (*=), and modulus (%=)
operators as well.
Increment and Decrement
The most common value to add (or subtract) and then reassign into a variable is 1. In C++, increasing
a value by 1 is called incrementing, and decreasing by 1 is called decrementing. There are special
operators to perform these actions.
The increment operator (++) increases the value of the variable by 1, and the decrement operator (--)
decreases it by 1. Thus, if you have a variable, C, and you want to increment it, you would use this
statement:
C++;
// Start with C and increment it.
This statement is equivalent to the more verbose statement
C = C + 1;
which you learned is also equivalent to the moderately verbose statement
C += 1;
Prefix and Postfix
Both the increment operator (++) and the decrement operator(--) come in two varieties: prefix and
postfix. The prefix variety is written before the variable name (++myAge); the postfix variety is
written after (myAge++).
In a simple statement, it doesn't much matter which you use, but in a complex statement, when you
are incrementing (or decrementing) a variable and then assigning the result to another variable, it
matters very much. The prefix operator is evaluated before the assignment, the postfix is evaluatedafter.
The semantics of prefix is this: Increment the value and then fetch it. The semantics of postfix is
different: Fetch the value and then increment the original.
This can be confusing at first, but if x is an integer whose value is 5 and you write
int a = ++x;
you have told the compiler to increment x (making it 6) and then fetch that value and assign it to a.
Thus, a is now 6 and x is now 6.
If, after doing this, you write
int b = x++;
you have now told the compiler to fetch the value in x (6) and assign it to b, and then go back and
increment x. Thus, b is now 6, but x is now 7. Listing 4.3 shows the use and implications of both
types.
Listing 4.3. A demonstration of prefix and postfix operators.
// Listing 4.3 - demonstrates use of
// prefix and postfix increment and
// decrement operators
#include <iostream.h>
int main()
{
int myAge = 39;
// initialize two integers
int yourAge = 39;
cout << "I am: " << myAge << " years old.\n";
cout << "You are: " << yourAge << " years old\n";
myAge++;
// postfix increment
++yourAge;
// prefix increment
cout << "One year passes...\n";
cout << "I am: " << myAge << " years old.\n";
cout << "You are: " << yourAge << " years old\n";
cout << "Another year passes\n";
cout << "I am: " << myAge++ << " years old.\n";
cout << "You are: " << ++yourAge << " years old\n";
cout << "Let's print it again.\n";
cout << "I am: " << myAge << " years old.\n";
cout << "You are: " << yourAge << " years old\n";
return 0;
}Output: I am
39 years old
You are
39 years old
One year passes
I am
40 years old
You are
40 years old
Another year passes
I am
40 years old
You are
41 years old
Let's print it again
I am
41 years old
You are
41 years old
Analysis: On lines 7 and 8, two integer variables are declared, and each is initialized with the value
39. Their values are printed on lines 9 and 10.
On line 11, myAge is incremented using the postfix increment operator, and on line 12, yourAge is
incremented using the prefix increment operator. The results are printed on lines 14 and 15, and they
are identical (both 40).
On line 17, myAge is incremented as part of the printing statement, using the postfix increment
operator. Because it is postfix, the increment happens after the print, and so the value 40 is printed
again. In contrast, on line 18, yourAge is incremented using the prefix increment operator. Thus, it is
incremented before being printed, and the value displays as 41.
Finally, on lines 20 and 21, the values are printed again. Because the increment statement has
completed, the value in myAge is now 41, as is the value in yourAge.
Precedence
In the complex statement
x = 5 + 3 * 8;
which is performed first, the addition or the multiplication? If the addition is performed first, the
answer is 8 * 8, or 64. If the multiplication is performed first, the answer is 5 + 24, or 29.
Every operator has a precedence value, and the complete list is shown in Appendix A, "Operator
Precedence." Multiplication has higher precedence than addition, and thus the value of the expression
is 29.
When two mathematical operators have the same precedence, they are performed in left-to-right order.
Thus
x = 5 + 3 + 8 * 9 + 6 * 4;
is evaluated multiplication first, left to right. Thus, 8*9 = 72, and 6*4 = 24. Now the expression isessentially
x = 5 + 3 + 72 + 24;
Now the addition, left to right, is 5 + 3 = 8; 8 + 72 = 80; 80 + 24 = 104.
Be careful with this. Some operators, such as assignment, are evaluated in right-to-left order! In any
case, what if the precedence order doesn't meet your needs? Consider the expression
TotalSeconds = NumMinutesToThink + NumMinutesToType * 60
In this expression, you do not want to multiply the NumMinutesToType variable by 60 and then
add it to NumMinutesToThink. You want to add the two variables to get the total number of
minutes, and then you want to multiply that number by 60 to get the total seconds.
In this case, you use parentheses to change the precedence order. Items in parentheses are evaluated at
a higher precedence than any of the mathematical operators. Thus
TotalSeconds = (NumMinutesToThink + NumMinutesToType) * 60
will accomplish what you want.
Nesting Parentheses
For complex expressions, you might need to nest parentheses one within another. For example, you
might need to compute the total seconds and then compute the total number of people who are
involved before multiplying seconds times people:
TotalPersonSeconds = ( ( (NumMinutesToThink + NumMinutesToType) *
60) * #,(PeopleInTheOffice + PeopleOnVacation) )
This complicated expression is read from the inside out. First, NumMinutesToThink is added to
NumMinutesToType, because these are in the innermost parentheses. Then this sum is multiplied
by 60. Next, PeopleInTheOffice is added to PeopleOnVacation. Finally, the total number
of people found is multiplied by the total number of seconds.
This example raises an important related issue. This expression is easy for a computer to understand,
but very difficult for a human to read, understand, or modify. Here is the same expression rewritten,
using some temporary integer variables:
TotalMinutes = NumMinutesToThink + NumMinutesToType;
TotalSeconds = TotalMinutes * 60;
TotalPeople = PeopleInTheOffice + PeopleOnVacation;
TotalPersonSeconds = TotalPeople * TotalSeconds;This example takes longer to write and uses more temporary variables than the preceding example,
but it is far easier to understand. Add a comment at the top to explain what this code does, and change
the 60 to a symbolic constant. You then will have code that is easy to understand and maintain.
DO remember that expressions have a value. DO use the prefix operator (++variable)
to increment or decrement the variable before it is used in the expression. DO use the
postfix operator (variable++) to increment or decrement the variable after it is used. DO
use parentheses to change the order of precedence. DON'T nest too deeply, because the
expression becomes hard to understand and maintain.
The Nature of Truth
In C++, zero is considered false, and all other values are considered true, although true is usually
represented by 1. Thus, if an expression is false, it is equal to zero, and if an expression is equal to
zero, it is false. If a statement is true, all you know is that it is nonzero, and any nonzero statement is
true.
Relational Operators
The relational operators are used to determine whether two numbers are equal, or if one is greater or
less than the other. Every relational statement evaluates to either 1 (TRUE) or 0 (FALSE). The
relational operators are presented later, in Table 4.1.
If the integer variable myAge has the value 39, and the integer variable yourAge has the value 40,
you can determine whether they are equal by using the relational "equals" operator:
myAge == yourAge;
// is the value in myAge the same as in yourAge?
This expression evaluates to 0, or false, because the variables are not equal. The expression
myAge > yourAge;
// is myAge greater than yourAge?
evaluates to 0 or false.
WARNING: Many novice C++ programmers confuse the assignment operator (=) with
the equals operator (==). This can create a nasty bug in your program.
There are six relational operators: equals (==), less than (<), greater than (>), less than or equal to
(<=), greater than or equal to (>=), and not equals (!=). Table 4.1 shows each relational operator, its
use, and a sample code use.Table 4.1. The Relational Operators.
Name
Equals
Operator Sample
Evaluates
==
100 == 50; false
50 == 50; true
Not Equals !=
100 != 50; true
50 != 50; false
Greater Than >
100 > 50; true
50 > 50; false
Greater Than >=
100 >= 50; true
or Equals
50 >= 50; true
Less Than <
100 < 50; false
50 < 50; false
Less Than <=
100 <= 50; false
or Equals
50 <= 50; true
DO remember that relational operators return the value 1 (true) or 0 (false).
DON'T confuse the assignment operator (=) with the equals relational operator (==).
This is one of the most common C++ programming mistakes--be on guard for it.
The if Statement
Normally, your program flows along line by line in the order in which it appears in your source code.
The if statement enables you to test for a condition (such as whether two variables are equal) and
branch to different parts of your code, depending on the result.
The simplest form of an if statement is this:
if (expression)
statement;
The expression in the parentheses can be any expression at all, but it usually contains one of the
relational expressions. If the expression has the value 0, it is considered false, and the statement is
skipped. If it has any nonzero value, it is considered true, and the statement is executed. Consider the
following example:
if (bigNumber > smallNumber)
bigNumber = smallNumber;This code compares bigNumber and smallNumber. If bigNumber is larger, the second line sets
its value to the value of smallNumber.
Because a block of statements surrounded by braces is exactly equivalent to a single statement, the
following type of branch can be quite large and powerful:
if (expression)
{
statement1;
statement2;
statement3;
}
Here's a simple example of this usage:
if (bigNumber > smallNumber)
{
bigNumber = smallNumber;
cout << "bigNumber: " << bigNumber << "\n";
cout << "smallNumber: " << smallNumber << "\n";
}
This time, if bigNumber is larger than smallNumber, not only is it set to the value of
smallNumber, but an informational message is printed. Listing 4.4 shows a more detailed example
of branching based on relational operators.
// Listing 4.4 - demonstrates if statement
// used with relational operators
#include <iostream.h>
int main()
{
int RedSoxScore, YankeesScore;
cout << "Enter the score for the Red Sox: ";
cin >> RedSoxScore;
cout << "\nEnter the score for the Yankees: ";
cin >> YankeesScore;
cout << "\n";
if (RedSoxScore > YankeesScore)
cout << "Go Sox!\n";17:
18:
if (RedSoxScore < YankeesScore)
19:
{
20:
cout << "Go Yankees!\n";
21:
cout << "Happy days in New York!\n";
22:
}
23:
24:
if (RedSoxScore == YankeesScore)
25:
{
26:
cout << "A tie? Naah, can't be.\n";
27:
cout << "Give me the real score for the Yanks: ";
28:
cin >> YankeesScore;
29:
30:
if (RedSoxScore > YankeesScore)
31:
cout << "Knew it! Go Sox!";
32:
33:
if (YankeesScore > RedSoxScore)
34:
cout << "Knew it! Go Yanks!";
35:
36:
if (YankeesScore == RedSoxScore)
37:
cout << "Wow, it really was a tie!";
38:
}
39:
40:
cout << "\nThanks for telling me.\n";
41:
return 0;
42: }
Output: Enter the score for the Red Sox: 10
Enter the score for the Yankees: 10
A tie? Naah, can't be
Give me the real score for the Yanks: 8
Knew it! Go Sox!
Thanks for telling me.
Analysis: This program asks for user input of scores for two baseball teams, which are stored in
integer variables. The variables are compared in the if statement on lines 15, 18, and 24.
If one score is higher than the other, an informational message is printed. If the scores are equal, the
block of code that begins on line 24 and ends on line 38 is entered. The second score is requested
again, and then the scores are compared again.
Note that if the initial Yankees score was higher than the Red Sox score, the if statement on line 15
would evaluate as FALSE, and line 16 would not be invoked. The test on line 18 would evaluate as
true, and the statements on lines 20 and 21 would be invoked. Then the if statement on line 24
would be tested, and this would be false (if line 18 was true). Thus, the program would skip the entire
block, falling through to line 39.In this example, getting a true result in one if statement does not stop other if statements from
being tested.
Indentation Styles
Listing 4.3 shows one style of indenting if statements. Nothing is more likely to create a religious
war, however, than to ask a group of programmers what is the best style for brace alignment.
Although there are dozens of variations, these appear to be the favorite three:
Putting the initial brace after the condition and aligning the closing brace under the if to close
the statement block.
if (expression){
statements
}
Aligning the braces under the if and indenting the statements.
if (expression)
{
statements
}
Indenting the braces and statements.
if (expression)
{
statements
}
This book uses the middle alternative, because I find it easier to understand where blocks of
statements begin and end if the braces line up with each other and with the condition being tested.
Again, it doesn't matter much which style you choose, as long as you are consistent with it.
else
Often your program will want to take one branch if your condition is true, another if it is false. In
Listing 4.3, you wanted to print one message (Go Sox!) if the first test (RedSoxScore >
Yankees) evaluated TRUE, and another message (Go Yanks!) if it evaluated FALSE.
The method shown so far, testing first one condition and then the other, works fine but is a bit
cumbersome. The keyword else can make for far more readable code:
if (expression)statement;
else
statement;
Listing 4.5 demonstrates the use of the keyword else.
Listing 4.5. Demonstrating the else keyword.
1:
// Listing 4.5 - demonstrates if statement
2:
// with else clause
3:
#include <iostream.h>
4:
int main()
5:
{
6:
int firstNumber, secondNumber;
7:
cout << "Please enter a big number: ";
8:
cin >> firstNumber;
9:
cout << "\nPlease enter a smaller number: ";
10:
cin >> secondNumber;
11:
if (firstNumber > secondNumber)
12:
cout << "\nThanks!\n";
13:
else
14:
cout << "\nOops. The second is bigger!";
15:
16:
return 0;
17: }
Output: Please enter a big number: 10
Please enter a smaller number: 12
Oops. The second is bigger!
Analysis: The if statement on line 11 is evaluated. If the condition is true, the statement on line 12 is
run; if it is false, the statement on line 14 is run. If the else clause on line 13 were removed, the
statement on line 14 would run whether or not the if statement was true. Remember, the if
statement ends after line 12. If the else was not there, line 14 would just be the next line in the
program.
Remember that either or both of these statements could be replaced with a block of code in braces.
The if Statement
The syntax for the if statement is as follows: Form 1
if (expression)
statement;next statement;
If the expression is evaluated as TRUE, the statement is executed and the program continues with the
next statement. If the expression is not true, the statement is ignored and the program jumps to the
next statement. Remember that the statement can be a single statement ending with a semicolon or a
block enclosed in braces. Form 2
if (expression)
statement1;
else
statement2;
next statement;
If the expression evaluates TRUE, statement1 is executed; otherwise, statement2 is executed.
Afterwards, the program continues with the next statement. Example 1
Example
if (SomeValue < 10)
cout << "SomeValue is less than 10");
else
cout << "SomeValue is not less than 10!");
cout << "Done." << endl;
Advanced if Statements
It is worth noting that any statement can be used in an if or else clause, even another if or else
statement. Thus, you might see complex if statements in the following form:
if (expression1)
{
if (expression2)
statement1;
else
{
if (expression3)
statement2;
else
statement3;
}
}
else
statement4;
This cumbersome if statement says, "If expression1 is true and expression2 is true, execute
statement1. If expression1 is true but expression2 is not true, then if expression3 is true executestatement2. If expression1 is true but expression2 and expression3 are false, execute statement3.
Finally, if expression1 is not true, execute statement4." As you can see, complex if statements can be
confusing!
Listing 4.6 gives an example of such a complex if statement.
Listing 4.6. A complex, nested if statement.
1: // Listing 4.5 - a complex nested
2: // if statement
3: #include <iostream.h>
4: int main()
5: {
6:
// Ask for two numbers
7:
// Assign the numbers to bigNumber and littleNumber
8:
// If bigNumber is bigger than littleNumber,
9:
// see if they are evenly divisible
10:
// If they are, see if they are the same number
11:
12:
int firstNumber, secondNumber;
13:
cout << "Enter two numbers.\nFirst: ";
14:
cin >> firstNumber;
15:
cout << "\nSecond: ";
16:
cin >> secondNumber;
17:
cout << "\n\n";
18:
19:
if (firstNumber >= secondNumber)
20:
{
21:
if ( (firstNumber % secondNumber) == 0) // evenly
divisible?
22:
{
23:
if (firstNumber == secondNumber)
24:
cout << "They are the same!\n";
25:
else
26:
cout << "They are evenly divisible!\n";
27:
}
28:
else
29:
cout << "They are not evenly divisible!\n";
30:
}
31:
else
32:
cout << "Hey! The second one is larger!\n";
33:
return 0;
34: }
Output: Enter two numbers.
First: 10Second: 2
They are evenly divisible!
Analysis: Two numbers are prompted for one at a time, and then compared. The first if statement,
on line 19, checks to ensure that the first number is greater than or equal to the second. If not, the
else clause on line 31 is executed.
If the first if is true, the block of code beginning on line 20 is executed, and the second if statement
is tested, on line 21. This checks to see whether the first number modulo the second number yields no
remainder. If so, the numbers are either evenly divisible or equal. The if statement on line 23 checks
for equality and displays the appropriate message either way.
If the if statement on line 21 fails, the else statement on line 28 is executed.
Using Braces in Nested if Statements
Although it is legal to leave out the braces on if statements that are only a single statement, and it is
legal to nest if statements, such as
if (x > y)
if (x < z)
x = y;
// if x is bigger than y
// and if x is smaller than z
// then set x to the value in z
when writing large nested statements, this can cause enormous confusion. Remember, whitespace and
indentation are a convenience for the programmer; they make no difference to the compiler. It is easy
to confuse the logic and inadvertently assign an else statement to the wrong if statement. Listing
4.7 illustrates this problem.
Listing 4.7. A demonstration of why braces help clarify which else
statement goes with which if statement.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
// Listing 4.7 - demonstrates why braces
// are important in nested if statements
#include <iostream.h>
int main()
{
int x;
cout << "Enter a number less than 10 or greater than 100: ";
cin >> x;
cout << "\n";
if (x > 10)
if (x > 100)13:
14:
15:
16:
17:
18: }
cout << "More than 100, Thanks!\n";
else
// not the else intended!
cout << "Less than 10, Thanks!\n";
return 0;
Output: Enter a number less than 10 or greater than 100: 20
Less than 10, Thanks!
Analysis: The programmer intended to ask for a number between 10 and 100, check for the correct
value, and then print a thank-you note.
If the if statement on line 11 evaluates TRUE, the following statement (line 12) is executed. In this
case, line 12 executes when the number entered is greater than 10. Line 12 contains an if statement
also. This if statement evaluates TRUE if the number entered is greater than 100. If the number is not
greater than 100, the statement on line 13 is executed.
If the number entered is less than or equal to 10, the if statement on line 10 evaluates to FALSE.
Program control goes to the next line following the if statement, in this case line 16. If you enter a
number less than 10, the output is as follows:
Enter a number less than 10 or greater than 100: 9
The else clause on line 14 was clearly intended to be attached to the if statement on line 11, and
thus is indented accordingly. Unfortunately, the else statement is really attached to the if statement
on line 12, and thus this program has a subtle bug.
It is a subtle bug because the compiler will not complain. This is a legal C++ program, but it just
doesn't do what was intended. Further, most of the times the programmer tests this program, it will
appear to work. As long as a number that is greater than 100 is entered, the program will seem to work
just fine.
Listing 4.8 fixes the problem by putting in the necessary braces.
Listing 4.8. A demonstration of the proper use of braces with an if
statement
1:
2:
3:
4:
5:
6:
7:
// Listing 4.8 - demonstrates proper use of braces
// in nested if statements
#include <iostream.h>
int main()
{
int x;
cout << "Enter a number less than 10 or greater than 100:";
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19: }
Output:
cin >> x;
cout << "\n";
if (x > 10)
{
if (x > 100)
cout << "More than 100, Thanks!\n";
}
else
// not the else intended!
cout << "Less than 10, Thanks!\n";
return 0;
Enter a number less than 10 or greater than 100: 20
Analysis: The braces on lines 12 and 15 make everything between them into one statement, and now
the else on line 16 applies to the if on line 11 as intended.
The user typed 20, so the if statement on line 11 is true; however, the if statement on line 13 is
false, so nothing is printed. It would be better if the programmer put another else clause after line 14
so that errors would be caught and a message printed.
NOTE: The programs shown in this book are written to demonstrate the particular
issues being discussed. They are kept intentionally simple; there is no attempt to
"bulletproof" the code to protect against user error. In professional-quality code, every
possible user error is anticipated and handled gracefully.
Logical Operators
Often you want to ask more than one relational question at a time. "Is it true that x is greater than y,
and also true that y is greater than z?" A program might need to determine that both of these
conditions are true, or that some other condition is true, in order to take an action.
Imagine a sophisticated alarm system that has this logic: "If the door alarm sounds AND it is after six
p.m. AND it is NOT a holiday, OR if it is a weekend, then call the police." C++'s three logical
operators are used to make this kind of evaluation. These operators are listed in Table 4.2.
Table 4.2. The Logical Operators.
Operator Symbol Example
expression1 && expression2
AND
&&
expression1 || expression2
OR
||
!expression
NOT
!Logical AND
A logical AND statement evaluates two expressions, and if both expressions are true, the logical AND
statement is true as well. If it is true that you are hungry, AND it is true that you have money, THEN
it is true that you can buy lunch. Thus,
if ( (x == 5) && (y == 5) )
would evaluate TRUE if both x and y are equal to 5, and it would evaluate FALSE if either one is not
equal to 5. Note that both sides must be true for the entire expression to be true.
Note that the logical AND is two && symbols. A single & symbol is a different operator, discussed on
Day 21, "What's Next."
Logical OR
A logical OR statement evaluates two expressions. If either one is true, the expression is true. If you
have money OR you have a credit card, you can pay the bill. You don't need both money and a credit
card; you need only one, although having both would be fine as well. Thus,
if ( (x == 5) || (y == 5) )
evaluates TRUE if either x or y is equal to 5, or if both are.
Note that the logical OR is two || symbols. A single | symbol is a different operator, discussed on
Day 21.
Logical NOT
A logical NOT statement evaluates true if the expression being tested is false. Again, if the
expression being tested is false, the value of the test is TRUE! Thus
if ( !(x == 5) )
is true only if x is not equal to 5. This is exactly the same as writing
if (x != 5)
Relational Precedence
Relational operators and logical operators, being C++ expressions, each return a value: 1 (TRUE) or 0
(FALSE). Like all expressions, they have a precedence order (see Appendix A) that determines which
relations are evaluated first. This fact is important when determining the value of the statementif ( x > 5 &&
y > 5
|| z > 5)
It might be that the programmer wanted this expression to evaluate TRUE if both x and y are greater
than 5 or if z is greater than 5. On the other hand, the programmer might have wanted this expression
to evaluate TRUE only if x is greater than 5 and if it is also true that either y is greater than 5 or z is
greater than 5.
If x is 3, and y and z are both 10, the first interpretation will be true (z is greater than 5, so ignore x
and y), but the second will be false (it isn't true that both x and y are greater than 5 nor is it true that z
is greater than 5).
Although precedence will determine which relation is evaluated first, parentheses can both change the
order and make the statement clearer:
if (
(x > 5)
&& (y > 5 ||
z > 5) )
Using the values from earlier, this statement is false. Because it is not true that x is greater than 5, the
left side of the AND statement fails, and thus the entire statement is false. Remember that an AND
statement requires that both sides be true--something isn't both "good tasting" AND "good for you" if
it isn't good tasting.
NOTE: It is often a good idea to use extra parentheses to clarify what you want to
group. Remember, the goal is to write programs that work and that are easy to read and
understand.
More About Truth and Falsehood
In C++, zero is false, and any other value is true. Because an expression always has a value, many
C++ programmers take advantage of this feature in their if statements. A statement such as
if (x)
x = 0;
// if x is true (nonzero)
can be read as "If x has a nonzero value, set it to 0." This is a bit of a cheat; it would be clearer if
written
if (x != 0)
x = 0;
// if x is nonzero
Both statements are legal, but the latter is clearer. It is good programming practice to reserve the
former method for true tests of logic, rather than for testing for nonzero values.These two statements also are equivalent:
if (!x)
if (x == 0)
// if x is false (zero)
// if x is zero
The second statement, however, is somewhat easier to understand and is more explicit.
DO put parentheses around your logical tests to make them clearer and to make the
precedence explicit. DO use braces in nested if statements to make the else
statements clearer and to avoid bugs. DON'T use if(x) as a synonym for if(x !=
0); the latter is clearer. DON'T use if(!x) as a synonym for if(x == 0); the
latter is clearer.
NOTE: It is common to define your own enumerated Boolean (logical) type with enum
Bool {FALSE, TRUE};. This serves to set FALSE to 0 and TRUE to 1.
Conditional (Ternary) Operator
The conditional operator (?:) is C++'s only ternary operator; that is, it is the only operator to take
three terms.
The conditional operator takes three expressions and returns a value:
(expression1) ? (expression2) : (expression3)
This line is read as "If expression1 is true, return the value of expression2; otherwise, return the value
of expression3." Typically, this value would be assigned to a variable.
Listing 4.9 shows an if statement rewritten using the conditional operator.
Listing 4.9. A demonstration of the conditional operator .
1:
2:
3:
4:
5:
6:
7:
8:
// Listing 4.9 - demonstrates the conditional operator
//
#include <iostream.h>
int main()
{
int x, y, z;
cout << "Enter two numbers.\n";
cout << "First: ";9:
cin >> x;
10:
cout << "\nSecond: ";
11:
cin >> y;
12:
cout << "\n";
13:
14:
if (x > y)
15:
z = x;
16:
else
17:
z = y;
18:
19:
cout << "z: " << z;
20:
cout << "\n";
21:
22:
z = (x > y) ? x : y;
23:
24:
cout << "z: " << z;
25:
cout << "\n";
26:
return 0;
27: }
Output: Enter two numbers.
First: 5
Second: 8
z: 8
z: 8
Analysis: Three integer variables are created: x, y, and z. The first two are given values by the user.
The if statement on line 14 tests to see which is larger and assigns the larger value to z. This value is
printed on line 19.
The conditional operator on line 22 makes the same test and assigns z the larger value. It is read like
this: "If x is greater than y, return the value of x; otherwise, return the value of y." The value returned
is assigned to z. That value is printed on line 24. As you can see, the conditional statement is a shorter
equivalent to the if...else statement.
Summary
This chapter has covered a lot of material. You have learned what C++ statements and expressions
are, what C++ operators do, and how C++ if statements work.
You have seen that a block of statements enclosed by a pair of braces can be used anywhere a single
statement can be used.
You have learned that every expression evaluates to a value, and that value can be tested in an if
statement or by using the conditional operator. You've also seen how to evaluate multiple statementsusing the logical operator, how to compare values using the relational operators, and how to assign
values using the assignment operator.
You have explored operator precedence. And you have seen how parentheses can be used to change
the precedence and to make precedence explicit and thus easier to manage.
Q&A
Q. Why use unnecessary parentheses when precedence will determine which operators
are acted on first?
A. Although it is true that the compiler will know the precedence and that a programmer can
look up the precedence order, code that is easy to understand is easier to maintain.
Q. If the relational operators always return 1 or 0, why are other values considered true?
A. The relational operators return 1 or 0, but every expression returns a value, and those values
can also be evaluated in an if statement. Here's an example:
if ( (x = a + b) == 35 )
This is a perfectly legal C++ statement. It evaluates to a value even if the sum of a and b is not
equal to 35. Also note that x is assigned the value that is the sum of a and b in any case.
Q. What effect do tabs, spaces, and new lines have on the program?
A. Tabs, spaces, and new lines (known as whitespace) have no effect on the program, although
judicious use of whitespace can make the program easier to read.
Q. Are negative numbers true or false?
A. All nonzero numbers, positive and negative, are true.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material
covered, and exercises to provide you with experience in using what you've learned. Try to answer the
quiz and exercise questions before checking the answers in Appendix D, and make sure that you
understand the answers before continuing to the next chapter.
Quiz
1. What is an expression?
2. Is x = 5 + 7 an expression? What is its value?3. What is the value of 201 / 4?
4. What is the value of 201 % 4?
5. If myAge, a, and b are all int variables, what are their values after:
myAge = 39;
a = myAge++;
b = ++myAge;
6. What is the value of 8+2*3?
7. What is the difference between x = 3 and x == 3?
8. Do the following values evaluate to TRUE or FALSE?
a. 0
b. 1
c. -1
d. x = 0
e. x == 0 // assume that x has the value of 0
Exercises
1. Write a single if statement that examines two integer variables and changes the larger to
the smaller, using only one else clause.
2. Examine the following program. Imagine entering three numbers, and write what output you
expect.
1: #include <iostream.h>
2: int main()
3: { 4: int a, b, c;
5: cout << "Please enter three numbers\n";
6: cout << "a: ";
7: cin >> a;
8: cout << "\nb: ";
9: cin >> b;
10: cout << "\nc: ";
11: cin >> c;
12:
13: if (c = (a-b))
14: {cout << "a: ";
15: cout << a;
16: cout << "minus b: ";
17: cout << b;18:
19:
20:
21:
22:
23:
cout << "equals c: ";
cout << c << endl;}
else
cout << "a-b does not equal c: " << endl;
return 0;
}
3. Enter the program from Exercise 2; compile, link, and run it. Enter the numbers 20, 10, and
50. Did you get the output you expected? Why not?
4. Examine this program and anticipate the output:
#include <iostream.h>
int main()
{
int a = 1, b = 1, c;
if (c = (a-b))
cout << "The value of c is: " << c;
return 0;
}
5. Enter, compile, link, and run the program from Exercise 4. What was the output? Why?
Day 5
Functions
Although object-oriented programming has shifted attention from functions and toward objects,
functions nonetheless remain a central component of any program. Today you will learn
What a function is and what its parts are.
How to declare and define functions.
How to pass parameters into functions.
How to return a value from a function.
What Is a Function?
A function is, in effect, a subprogram that can act on data and return a value. Every C++ program has
at least one function, main(). When your program starts, main() is called automatically. main()
might call other functions, some of which might call still others.
Each function has its own name, and when that name is encountered, the execution of the program
branches to the body of that function. When the function returns, execution resumes on the next line
of the calling function. This flow is illustrated in Figure 5.1.
Figure 5.1. Illusrtation of flowWhen a program calls a function, execution switches to the function and then resumes at the line after
the function call. Well-designed functions perform a specific and easily understood task. Complicated
tasks should be broken down into multiple functions, and then each can be called in turn.
Functions come in two varieties: user-defined and built-in. Built-in functions are part of your compiler
package--they are supplied by the manufacturer for your use.
Declaring and Defining Functions
Using functions in your program requires that you first declare the function and that you then define
the function. The declaration tells the compiler the name, return type, and parameters of the function.
The definition tells the compiler how the function works. No function can be called from any other
function that hasn't first been declared. The declaration of a function is called its prototype.
Declaring the Function
There are three ways to declare a function:
Write your prototype into a file, and then use the #include directive to include it in your
program.
Write the prototype into the file in which your function is used.
Define the function before it is called by any other function. When you do this, the definition
acts as its own declaration.
Although you can define the function before using it, and thus avoid the necessity of creating a
function prototype, this is not good programming practice for three reasons.
First, it is a bad idea to require that functions appear in a file in a particular order. Doing so makes it
hard to maintain the program as requirements change.
Second, it is possible that function A() needs to be able to call function B(), but function B() also
needs to be able to call function A() under some circumstances. It is not possible to define function
A() before you define function B() and also to define function B() before you define function A(),
so at least one of them must be declared in any case.
Third, function prototypes are a good and powerful debugging technique. If your prototype declares
that your function takes a particular set of parameters, or that it returns a particular type of value, and
then your function does not match the prototype, the compiler can flag your error instead of waiting
for it to show itself when you run the program.
Function PrototypesMany of the built-in functions you use will have their function prototypes already written in the files
you include in your program by using #include. For functions you write yourself, you must include
the prototype.
The function prototype is a statement, which means it ends with a semicolon. It consists of the
function's return type, name, and parameter list.
The parameter list is a list of all the parameters and their types, separated by commas. Figure 5.2
illustrates the parts of the function prototype.
Figure 5.2. Parts of a function prototype.
The function prototype and the function definition must agree exactly about the return type, the name,
and the parameter list. If they do not agree, you will get a compile-time error. Note, however, that the
function prototype does not need to contain the names of the parameters, just their types. A prototype
that looks like this is perfectly legal:
long Area(int, int);
This prototype declares a function named Area() that returns a long and that has two parameters,
both integers. Although this is legal, it is not a good idea. Adding parameter names makes your
prototype clearer. The same function with named parameters might be
long Area(int length, int width);
It is now obvious what this function does and what the parameters are.
Note that all functions have a return type. If none is explicitly stated, the return type defaults to int.
Your programs will be easier to understand, however, if you explicitly declare the return type of every
function, including main(). Listing 5.1 demonstrates a program that includes a function prototype
for the Area() function.
Listing 5.1. A function declaration and the definition and use of that
function.
1:
// Listing 5.1 - demonstrates the use of function prototypes
2:
3:
typedef unsigned short USHORT;
4:
#include <iostream.h>
5:
USHORT FindArea(USHORT length, USHORT width); //function
prototype
6:
7:
int main()
8:
{
9:
USHORT lengthOfYard;10:
USHORT widthOfYard;
11:
USHORT areaOfYard;
12:
13:
cout << "\nHow wide is your yard? ";
14:
cin >> widthOfYard;
15:
cout << "\nHow long is your yard? ";
16:
cin >> lengthOfYard;
17:
18:
areaOfYard= FindArea(lengthOfYard,widthOfYard);
19:
20:
cout << "\nYour yard is ";
21:
cout << areaOfYard;
22:
cout << " square feet\n\n";
23:
return 0;
24: }
25:
26: USHORT FindArea(USHORT l, USHORT w)
27: {
28:
return l * w;
29: }
Output: How wide is your yard? 100
How long is your yard? 200
Your yard is 20000 square feet
Analysis: The prototype for the FindArea() function is on line 5. Compare the prototype with the
definition of the function on line 26. Note that the name, the return type, and the parameter types are
the same. If they were different, a compiler error would have been generated. In fact, the only required
difference is that the function prototype ends with a semicolon and has no body.
Also note that the parameter names in the prototype are length and width, but the parameter
names in the definition are l and w. As discussed, the names in the prototype are not used; they are
there as information to the programmer. When they are included, they should match the
implementation when possible. This is a matter of good programming style and reduces confusion, but
it is not required, as you see here.
The arguments are passed in to the function in the order in which they are declared and defined, but
there is no matching of the names. Had you passed in widthOfYard, followed by
lengthOfYard, the FindArea() function would have used the value in widthOfYard for
length and lengthOfYard for width. The body of the function is always enclosed in braces,
even when it consists of only one statement, as in this case.
Defining the Function
The definition of a function consists of the function header and its body. The header is exactly like the
function prototype, except that the parameters must be named, and there is no terminating semicolon.The body of the function is a set of statements enclosed in braces. Figure 5.3 shows the header and
body of a function.
Figure 5.3. The header and body of a function.
Functions
Function Prototype Syntax
return_type function_name ( [type [parameterName]]...);
Function Definition Syntax
return_type function_name ( [type parameterName]...)
{
statements;
}
A function prototype tells the compiler the return type, name, and parameter list. Func-tions are not
required to have parameters, and if they do, the prototype is not required to list their names, only their
types. A prototype always ends with a semicolon (;). A function definition must agree in return type
and parameter list with its prototype. It must provide names for all the parameters, and the body of the
function definition must be surrounded by braces. All statements within the body of the function must
be terminated with semicolons, but the function itself is not ended with a semicolon; it ends with a
closing brace. If the function returns a value, it should end with a return statement, although
return statements can legally appear anywhere in the body of the function. Every function has a
return type. If one is not explicitly designated, the return type will be int. Be sure to give every
function an explicit return type. If a function does not return a value, its return type will be void.
Function Prototype Examples
long FindArea(long length, long width); // returns long, has two
parameters
void PrintMessage(int messageNumber); // returns void, has one
parameter
int GetChoice();
// returns int, has no
parameters
BadFunction();
parameters
// returns int, has noFunction Definition Examples
long Area(long l, long w)
{
return l * w;
}
void PrintMessage(int whichMsg)
{
if (whichMsg == 0)
cout << "Hello.\n";
if (whichMsg == 1)
cout << "Goodbye.\n";
if (whichMsg > 1)
cout << "I'm confused.\n";
}
Execution of Functions
When you call a function, execution begins with the first statement after the opening brace ({).
Branching can be accomplished by using the if statement (and related statements that will be
discussed on Day 7, "More Program Flow"). Functions can also call other functions and can even call
themselves (see the section "Recursion," later in this chapter).
Local Variables
Not only can you pass in variables to the function, but you also can declare variables within the body
of the function. This is done using local variables, so named because they exist only locally within the
function itself. When the function returns, the local variables are no longer available.
Local variables are defined like any other variables. The parameters passed in to the function are also
considered local variables and can be used exactly as if they had been defined within the body of the
function. Listing 5.2 is an example of using parameters and locally defined variables within a
function.
Listing 5.2. The use of local variables and parameters.
1:
2:
3:
#include <iostream.h>
float Convert(float);4:
22: }
int main()
{
float TempFer;
float TempCel;
cout << "Please enter the temperature in Fahrenheit: ";
cin >> TempFer;
TempCel = Convert(TempFer);
cout << "\nHere's the temperature in Celsius: ";
cout << TempCel << endl;
return 0;
}
float Convert(float TempFer)
{
float TempCel;
TempCel = ((TempFer - 32) * 5) / 9;
return TempCel;
Output: Please enter the temperature in Fahrenheit: 212
Here's the temperature in Celsius: 100
Please enter the temperature in Fahrenheit: 32
Here's the temperature in Celsius: 0
Please enter the temperature in Fahrenheit: 85
Here's the temperature in Celsius: 29.4444
Analysis: On lines 6 and 7, two float variables are declared, one to hold the temperature in
Fahrenheit and one to hold the temperature in degrees Celsius. The user is prompted to enter a
Fahrenheit temperature on line 9, and that value is passed to the function Convert().
Execution jumps to the first line of the function Convert() on line 19, where a local variable, also
named TempCel, is declared. Note that this local variable is not the same as the variable TempCel
on line 7. This variable exists only within the function Convert(). The value passed as a parameter,
TempFer, is also just a local copy of the variable passed in by main().
This function could have named the parameter FerTemp and the local variable CelTemp, and the
program would work equally well. You can enter these names again and recompile the program to see
this work.
The local function variable TempCel is assigned the value that results from subtracting 32 from the
parameter TempFer, multiplying by 5, and then dividing by 9. This value is then returned as the
return value of the function, and on line 11 it is assigned to the variable TempCel in the main()function. The value is printed on line 13.
The program is run three times. The first time, the value 212 is passed in to ensure that the boiling
point of water in degrees Fahrenheit (212) generates the correct answer in degrees Celsius (100). The
second test is the freezing point of water. The third test is a random number chosen to generate a
fractional result.
As an exercise, try entering the program again with other variable names as illustrated here:
#include <iostream.h>
float Convert(float);
int main()
{
float TempFer;
float TempCel;
cout << "Please enter the temperature in Fahrenheit: ";
cin >> TempFer;
TempCel = Convert(TempFer);
cout << "\nHere's the temperature in Celsius: ";
cout << TempCel << endl;
}
float Convert(float Fer)
{
float Cel;
Cel = ((Fer - 32) * 5) / 9;
return Cel;
}
You should get the same results.
New Term: A variable has scope, which determines how long it is available to your program
and where it can be accessed. Variables declared within a block are scoped to that block; they
can be accessed only within that block and "go out of existence" when that block ends. Global
variables have global scope and are available anywhere within your program.
Normally scope is obvious, but there are some tricky exceptions. Currently, variables declared within
the header of a for loop (for int i = 0; i<SomeValue; i++) are scoped to the block in
which the for loop is created, but there is talk of changing this in the official C++ standard.
None of this matters very much if you are careful not to reuse your variable names within any given
function.Global Variables
Variables defined outside of any function have global scope and thus are available from any function
in the program, including main().
Local variables with the same name as global variables do not change the global variables. A local
variable with the same name as a global variable hides the global variable, however. If a function has
a variable with the same name as a global variable, the name refers to the local variable--not the
global--when used within the function. Listing 5.3 illustrates these points.
Listing 5.3. Demonstrating global and local variables .
1:
#include <iostream.h>
2:
void myFunction();
// prototype
3:
4:
int x = 5, y = 7;
// global variables
5:
int main()
6:
{
7:
8:
cout << "x from main: " << x << "\n";
9:
cout << "y from main: " << y << "\n\n";
10:
myFunction();
11:
cout << "Back from myFunction!\n\n";
12:
cout << "x from main: " << x << "\n";
13:
cout << "y from main: " << y << "\n";
14:
return 0;
15: }
16:
17: void myFunction()
18: {
19:
int y = 10;
20:
21:
cout << "x from myFunction: " << x << "\n";
22:
cout << "y from myFunction: " << y << "\n\n";
23: }
Output: x from main: 5
y from main: 7
x from myFunction: 5
y from myFunction: 10
Back from myFunction!
x from main: 5y from main: 7
Analysis: This simple program illustrates a few key, and potentially confusing, points about local and
global variables. On line 1, two global variables, x and y, are declared. The global variable x is
initialized with the value 5, and the global variable y is initialized with the value 7.
On lines 8 and 9 in the function main(), these values are printed to the screen. Note that the function
main() defines neither variable; because they are global, they are already available to main().
When myFunction() is called on line 10, program execution passes to line 18, and a local variable,
y, is defined and initialized with the value 10. On line 21, myFunction() prints the value of the
variable x, and the global variable x is used, just as it was in main(). On line 22, however, when the
variable name y is used, the local variable y is used, hiding the global variable with the same name.
The function call ends, and control returns to main(), which again prints the values in the global
variables. Note that the global variable y was totally unaffected by the value assigned to
myFunction()'s local y variable.
Global Variables: A Word of Caution
In C++, global variables are legal, but they are almost never used. C++ grew out of C, and in C global
variables are a dangerous but necessary tool. They are necessary because there are times when the
programmer needs to make data available to many functions and he does not want to pass that data as
a parameter from function to function.
Globals are dangerous because they are shared data, and one function can change a global variable in
a way that is invisible to another function. This can and does create bugs that are very difficult to find.
On Day 14, "Special Classes and Functions," you'll see a powerful alternative to global variables that
C++ offers, but that is unavailable in C.
More on Local Variables
Variables declared within the function are said to have "local scope." That means, as discussed, that
they are visible and usable only within the function in which they are defined. In fact, in C++ you can
define variables anywhere within the function, not just at its top. The scope of the variable is the block
in which it is defined. Thus, if you define a variable inside a set of braces within the function, that
variable is available only within that block. Listing 5.4 illustrates this idea.
Listing 5.4. Variables scoped within a block.
1:
2:
3:
4:
// Listing 5.4 - demonstrates variables
// scoped within a block
#include <iostream.h>5:
34: }
void myFunc();
int main()
{
int x = 5;
cout << "\nIn main x is: " << x;
myFunc();
cout << "\nBack in main, x is: " << x;
return 0;
}
void myFunc()
{
int x = 8;
cout << "\nIn myFunc, local x: " << x << endl;
{
cout << "\nIn block in myFunc, x is: " << x;
int x = 9;
cout << "\nVery local x: " << x;
}
cout << "\nOut of block, in myFunc, x: " << x << endl;
Output: In main x is: 5
In myFunc, local x: 8
In block in myFunc, x is: 8
Very local x: 9
Out of block, in myFunc, x: 8
Back in main, x is: 5
Analysis: This program begins with the initialization of a local variable, x, on line 10, in main().
The printout on line 11 verifies that x was initialized with the value 5.
MyFunc() is called, and a local variable, also named x, is initialized with the value 8 on line 22. Its
value is printed on line 23.
A block is started on line 25, and the variable x from the function is printed again on line 26. A newvariable also named x, but local to the block, is created on line 28 and initialized with the value 9.
The value of the newest variable x is printed on line 30. The local block ends on line 31, and the
variable created on line 28 goes "out of scope" and is no longer visible.
When x is printed on line 33, it is the x that was declared on line 22. This x was unaffected by the x
that was defined on line 28; its value is still 8.
On line 34, MyFunc() goes out of scope, and its local variable x becomes unavailable. Execution
returns to line 15, and the value of the local variable x, which was created on line 10, is printed. It was
unaffected by either of the variables defined in MyFunc().
Needless to say, this program would be far less confusing if these three variables were given unique
names!
Function Statements
There is virtually no limit to the number or types of statements that can be in a function body.
Although you can't define another function from within a function, you can call a function, and of
course main() does just that in nearly every C++ program. Functions can even call themselves,
which is discussed soon, in the section on recursion.
Although there is no limit to the size of a function in C++, well-designed functions tend to be small.
Many programmers advise keeping your functions short enough to fit on a single screen so that you
can see the entire function at one time. This is a rule of thumb, often broken by very good
programmers, but a smaller function is easier to understand and maintain.
Each function should carry out a single, easily understood task. If your functions start getting large,
look for places where you can divide them into component tasks.
Function Arguments
Function arguments do not have to all be of the same type. It is perfectly reasonable to write a
function that takes an integer, two longs, and a character as its arguments.
Any valid C++ expression can be a function argument, including constants, mathematical and logical
expressions, and other functions that return a value.
Using Functions as Parameters to Functions
Although it is legal for one function to take as a parameter a second function that returns a value, it
can make for code that is hard to read and hard to debug.
As an example, say you have the functions double(), triple(), square(), and cube(), eachof which returns a value. You could write
Answer = (double(triple(square(cube(myValue)))));
This statement takes a variable, myValue, and passes it as an argument to the function cube(),
whose return value is passed as an argument to the function square(), whose return value is in turn
passed to triple(), and that return value is passed to double(). The return value of this doubled,
tripled, squared, and cubed number is now passed to Answer.
It is difficult to be certain what this code does (was the value tripled before or after it was squared?),
and if the answer is wrong it will be hard to figure out which function failed.
An alternative is to assign each step to its own intermediate variable:
unsigned
long
myValue =
cubed =
squared =
tripled =
Answer =
2;
double(tripled);
//
//
//
//
cubed = 8
squared = 64
tripled = 196
Answer = 392
Now each intermediate result can be examined, and the order of execution is explicit.
Parameters Are Local Variables
The arguments passed in to the function are local to the function. Changes made to the arguments do
not affect the values in the calling function. This is known as passing by value, which means a local
copy of each argument is made in the function. These local copies are treated just like any other local
variables. Listing 5.5 illustrates this point.
Listing 5.5. A demonstration of passing by value.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
"\n";
12:
// Listing 5.5 - demonstrates passing by value
#include <iostream.h>
void swap(int x, int y);
int main()
{
int x = 5, y = 10;
cout << "Main. Before swap, x: " << x << " y: " << y <<
swap(x,y);13:
"\n";
"\n";
28:
29: }
cout << "Main. After swap, x: " << x << " y: " << y <<
return 0;
}
void swap (int x, int y)
{
int temp;
cout << "Swap. Before swap, x: " << x << " y: " << y <<
temp = x;
x = y;
y = temp;
cout << "Swap. After swap, x: " << x << " y: " << y <<
Output: Main. Before swap, x: 5 y: 10
Swap. Before swap, x: 5 y: 10
Swap. After swap, x: 10 y: 5
Main. After swap, x: 5 y: 10
Analysis: This program initializes two variables in main() and then passes them to the swap()
function, which appears to swap them. When they are examined again in main(), however, they are
unchanged!
The variables are initialized on line 9, and their values are displayed on line 11. swap() is called,
and the variables are passed in.
Execution of the program switches to the swap() function, where on line 21 the values are printed
again. They are in the same order as they were in main(), as expected. On lines 23 to 25 the values
are swapped, and this action is confirmed by the printout on line 27. Indeed, while in the swap()
function, the values are swapped.
Execution then returns to line 13, back in main(), where the values are no longer swapped.
As you've figured out, the values passed in to the swap() function are passed by value, meaning that
copies of the values are made that are local to swap(). These local variables are swapped in lines 23
to 25, but the variables back in main() are unaffected.
On Days 8 and 10 you'll see alternatives to passing by value that will allow the values in main() to
be changed.Return Values
Functions return a value or return void. Void is a signal to the compiler that no value will be
returned.
To return a value from a function, write the keyword return followed by the value you want to
return. The value might itself be an expression that returns a value. For example:
return 5;
return (x > 5);
return (MyFunction());
These are all legal return statements, assuming that the function MyFunction() itself returns a
value. The value in the second statement, return (x > 5), will be zero if x is not greater than 5,
or it will be 1. What is returned is the value of the expression, 0 (false) or 1 (true), not the value
of x.
When the return keyword is encountered, the expression following return is returned as the
value of the function. Program execution returns immediately to the calling function, and any
statements following the return are not executed.
It is legal to have more than one return statement in a single function. Listing 5.6 illustrates this
idea.
Listing 5.6. A demonstration of multiple return statements .
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
";
15:
16:
17:
// Listing 5.6 - demonstrates multiple return
// statements
#include <iostream.h>
int Doubler(int AmountToDouble);
int main()
{
int result = 0;
int input;
cout << "Enter a number between 0 and 10,000 to double:
cin >> input;
cout << "\nBefore doubler is called... ";18:
cout << "\ninput: " << input << " doubled: " << result
<< "\n";
19:
20:
result = Doubler(input);
21:
22:
cout << "\nBack from Doubler...\n";
23:
cout << "\ninput: " << input << "
doubled: " <<
result << "\n";
24:
25:
26:
return 0;
27:
}
28:
29:
int Doubler(int original)
30:
{
31:
if (original <= 10000)
32:
return original * 2;
33:
else
34:
return -1;
35:
cout << "You can't get here!\n";
36: }
Output: Enter a number between 0 and 10,000 to double: 9000
Before doubler is called...
input: 9000 doubled: 0
Back from doubler...
input: 9000
doubled: 18000
Enter a number between 0 and 10,000 to double: 11000
Before doubler is called...
input: 11000 doubled: 0
Back from doubler...
input: 11000 doubled: -1
Analysis: A number is requested on lines 14 and 15, and printed on line 18, along with the local
variable result. The function Doubler() is called on line 20, and the input value is passed as a
parameter. The result will be assigned to the local variable result, and the values will be reprinted
on lines 22 and 23.
On line 31, in the function Doubler(), the parameter is tested to see whether it is greater than
10,000. If it is not, the function returns twice the original number. If it is greater than 10,000, the
function returns -1 as an error value.
The statement on line 35 is never reached, because whether or not the value is greater than 10,000, thefunction returns before it gets to line 35, on either line 32 or line 34. A good compiler will warn that
this statement cannot be executed, and a good programmer will take it out!
Default Parameters
For every parameter you declare in a function prototype and definition, the calling function must pass
in a value. The value passed in must be of the declared type. Thus, if you have a function declared as
long myFunction(int);
the function must in fact take an integer variable. If the function definition differs, or if you fail to
pass in an integer, you will get a compiler error.
The one exception to this rule is if the function prototype declares a default value for the parameter. A
default value is a value to use if none is supplied. The preceding declaration could be rewritten as
long myFunction (int x = 50);
This prototype says, "myFunction() returns a long and takes an integer parameter. If an
argument is not supplied, use the default value of 50." Because parameter names are not required in
function prototypes, this declaration could have been written as
long myFunction (int = 50);
The function definition is not changed by declaring a default parameter. The function definition
header for this function would be
long myFunction (int x)
If the calling function did not include a parameter, the compiler would fill x with the default value of
50. The name of the default parameter in the prototype need not be the same as the name in the
function header; the default value is assigned by position, not name.
Any or all of the function's parameters can be assigned default values. The one restriction is this: If
any of the parameters does not have a default value, no previous parameter may have a default value.
If the function prototype looks like
long myFunction (int Param1, int Param2, int Param3);
you can assign a default value to Param2 only if you have assigned a default value to Param3. You
can assign a default value to Param1 only if you've assigned default values to both Param2 and
Param3. Listing 5.7 demonstrates the use of default values.Listing 5.7. A demonstration of default parameter values.
1:
// Listing 5.7 - demonstrates use
2:
// of default parameter values
3:
4:
#include <iostream.h>
5:
6:
int AreaCube(int length, int width = 25, int height = 1);
7:
8:
int main()
9:
{
10:
int length = 100;
11:
int width = 50;
12:
int height = 2;
13:
int area;
14:
15:
area = AreaCube(length, width, height);
16:
cout << "First area equals: " << area << "\n";
17:
18:
area = AreaCube(length, width);
19:
cout << "Second time area equals: " << area << "\n";
20:
21:
area = AreaCube(length);
22:
cout << "Third time area equals: " << area << "\n";
23:
return 0;
24:
}
25:
26:
AreaCube(int length, int width, int height)
27:
{
28:
29:
return (length * width * height);
30: }
Output: First area equals: 10000
Second time area equals: 5000
Third time area equals: 2500
Analysis: On line 6, the AreaCube() prototype specifies that the AreaCube() function takes
three integer parameters. The last two have default values.
This function computes the area of the cube whose dimensions are passed in. If no width is passed
in, a width of 25 is used and a height of 1 is used. If the width but not the height is passed in,
a height of 1 is used. It is not possible to pass in the height without passing in a width.
On lines 10-12, the dimensions length, height, and width are initialized, and they are passed to
the AreaCube() function on line 15. The values are computed, and the result is printed on line 16.Execution returns to line 18, where AreaCube() is called again, but with no value for height. The
default value is used, and again the dimensions are computed and printed.
Execution returns to line 21, and this time neither the width nor the height is passed in. Execution
branches for a third time to line 27. The default values are used. The area is computed and then
printed.
DO remember that function parameters act as local variables within the function.
DON'T try to create a default value for a first parameter if there is no default value for
the second. DON'T forget that arguments passed by value can not affect the variables in
the calling function. DON'T forget that changes to a global variable in one function
change that variable for all functions.
Overloading Functions
C++ enables you to create more than one function with the same name. This is called function
overloading. The functions must differ in their parameter list, with a different type of parameter, a
different number of parameters, or both. Here's an example:
int myFunction (int, int);
int myFunction (long, long);
int myFunction (long);
myFunction() is overloaded with three different parameter lists. The first and second versions
differ in the types of the parameters, and the third differs in the number of parameters.
The return types can be the same or different on overloaded functions. You should note that two
functions with the same name and parameter list, but different return types, generate a compiler error.
New Term: Function overloading i s also called function polymorphism. Poly means many,
and morph means form: a polymorphic function is many-formed.
Function polymorphism refers to the ability to "overload" a function with more than one meaning. By
changing the number or type of the parameters, you can give two or more functions the same function
name, and the right one will be called by matching the parameters used. This allows you to create a
function that can average integers, doubles, and other values without having to create individual
names for each function, such as AverageInts(), AverageDoubles(), and so on.
Suppose you write a function that doubles whatever input you give it. You would like to be able to
pass in an int, a long, a float, or a double. Without function overloading, you would have tocreate four function names:
int DoubleInt(int);
long DoubleLong(long);
float DoubleFloat(float);
double DoubleDouble(double);
With function overloading, you make this declaration:
int Double(int);
long Double(long);
float Double(float);
double Double(double);
This is easier to read and easier to use. You don't have to worry about which one to call; you just pass
in a variable, and the right function is called automatically. Listing 5.8 illustrates the use of function
overloading.
Listing 5.8. A demonstration of function polymorphism .
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
// Listing 5.8 - demonstrates
// function polymorphism
#include <iostream.h>
int Double(int);
long Double(long);
float Double(float);
double Double(double);
int main()
{
int
long
float
double
int
long
float
double
myInt = 6500;
myLong = 65000;
myFloat = 6.5F;
myDouble = 6.5e20;
doubledInt;
doubledLong;
doubledFloat;
doubledDouble;
cout << "myInt: " << myInt << "\n";
cout << "myLong: " << myLong << "\n";
cout << "myFloat: " << myFloat << "\n";26:
cout << "myDouble: " << myDouble << "\n";
27:
28:
doubledInt = Double(myInt);
29:
doubledLong = Double(myLong);
30:
doubledFloat = Double(myFloat);
31:
doubledDouble = Double(myDouble);
32:
33:
cout << "doubledInt: " << doubledInt << "\n";
34:
cout << "doubledLong: " << doubledLong << "\n";
35:
cout << "doubledFloat: " << doubledFloat << "\n";
36:
cout << "doubledDouble: " << doubledDouble << "\n";
37:
38:
return 0;
39:
}
40:
41: int Double(int original)
42: {
43:
cout << "In Double(int)\n";
44:
return 2 * original;
45: }
46:
47: long Double(long original)
48: {
49:
cout << "In Double(long)\n";
50:
return 2 * original;
51: }
52:
53: float Double(float original)
54: {
55:
cout << "In Double(float)\n";
56:
return 2 * original;
57: }
58:
59: double Double(double original)
60: {
61:
cout << "In Double(double)\n";
62:
return 2 * original;
63: }
Output: myInt: 6500
myLong: 65000
myFloat: 6.5
myDouble: 6.5e+20
In Double(int)
In Double(long)
In Double(float)In Double(double)
DoubledInt: 13000
DoubledLong: 130000
DoubledFloat: 13
DoubledDouble: 1.3e+21
Analysis: The Double()function is overloaded with int, long, float, and double. The
prototypes are on lines 6-9, and the definitions are on lines 41-63.
In the body of the main program, eight local variables are declared. On lines 13-16, four of the values
are initialized, and on lines 28-31, the other four are assigned the results of passing the first four to the
Double() function. Note that when Double() is called, the calling function does not distinguish
which one to call; it just passes in an argument, and the correct one is invoked.
The compiler examines the arguments and chooses which of the four Double() functions to call.
The output reveals that each of the four was called in turn, as you would expect.
Special Topics About Functions
Because functions are so central to programming, a few special topics arise which might be of interest
when you confront unusual problems. Used wisely, inline functions can help you squeak out that last
bit of performance. Function recursion is one of those wonderful, esoteric bits of programming which,
every once in a while, can cut through a thorny problem otherwise not easily solved.
Inline Functions
When you define a function, normally the compiler creates just one set of instructions in memory.
When you call the function, execution of the program jumps to those instructions, and when the
function returns, execution jumps back to the next line in the calling function. If you call the function
10 times, your program jumps to the same set of instructions each time. This means there is only one
copy of the function, not 10.
There is some performance overhead in jumping in and out of functions. It turns out that some
functions are very small, just a line or two of code, and some efficiency can be gained if the program
can avoid making these jumps just to execute one or two instructions. When programmers speak of
efficiency, they usually mean speed: the program runs faster if the function call can be avoided.
If a function is declared with the keyword inline, the compiler does not create a real function: it
copies the code from the inline function directly into the calling function. No jump is made; it is just
as if you had written the statements of the function right into the calling function.
Note that inline functions can bring a heavy cost. If the function is called 10 times, the inline code is
copied into the calling functions each of those 10 times. The tiny improvement in speed you might
achieve is more than swamped by the increase in size of the executable program. Even the speed
increase might be illusory. First, today's optimizing compilers do a terrific job on their own, and there
is almost never a big gain from declaring a function inline. More important, the increased sizebrings its own performance cost.
What's the rule of thumb? If you have a small function, one or two statements, it is a candidate for
inline. When in doubt, though, leave it out. Listing 5.9 demonstrates an inline function.
Listing 5.9. Demonstrates an inline function.
1:
// Listing 5.9 - demonstrates inline functions
2:
3:
#include <iostream.h>
4:
5:
inline int Double(int);
6:
7:
int main()
8:
{
9:
int target;
10:
11:
cout << "Enter a number to work with: ";
12:
cin >> target;
13:
cout << "\n";
14:
15:
target = Double(target);
16:
cout << "Target: " << target << endl;
17:
18:
target = Double(target);
19:
cout << "Target: " << target << endl;
20:
21:
22:
target = Double(target);
23:
cout << "Target: " << target << endl;
24:
return 0;
25: }
26:
27: int Double(int target)
28: {
29:
return 2*target;
30: }
Output: Enter a number to work with: 20
Target: 40
Target: 80
Target: 160
Analysis: On line 5, Double() is declared to be an inline function taking an int parameterand returning an int. The declaration is just like any other prototype except that the keyword
inline is prepended just before the return value.
This compiles into code that is the same as if you had written the following:
target = 2 * target;
everywhere you entered
target = Double(target);
By the time your program executes, the instructions are already in place, compiled into the
OBJ file. This saves a jump in the execution of the code, at the cost of a larger program.
NOTE: Inline is a hint to the compiler that you would like the function to be inlined.
The compiler is free to ignore the hint and make a real function call.
Recursion
A function can call itself. This is called recursion, and recursion can be direct or indirect. It is direct
when a function calls itself; it is indirect recursion when a function calls another function that then
calls the first function.
Some problems are most easily solved by recursion, usually those in which you act on data and then
act in the same way on the result. Both types of recursion, direct and indirect, come in two varieties:
those that eventually end and produce an answer, and those that never end and produce a runtime
failure. Programmers think that the latter is quite funny (when it happens to someone else).
It is important to note that when a function calls itself, a new copy of that function is run. The local
variables in the second version are independent of the local variables in the first, and they cannot
affect one another directly, any more than the local variables in main() can affect the local variables
in any function it calls, as was illustrated in Listing 5.4.
To illustrate solving a problem using recursion, consider the Fibonacci series:
1,1,2,3,5,8,13,21,34...
Each number, after the second, is the sum of the two numbers before it. A Fibonacci problem might
be to determine what the 12th number in the series is.One way to solve this problem is to examine the series carefully. The first two numbers are 1. Each
subsequent number is the sum of the previous two numbers. Thus, the seventh number is the sum of
the sixth and fifth numbers. More generally, the nth number is the sum of n - 2 and n - 1, as long as n
> 2.
Recursive functions need a stop condition. Something must happen to cause the program to stop
recursing, or it will never end. In the Fibonacci series, n < 3 is a stop condition.
The algorithm to use is this:
1. Ask the user for a position in the series.
2. Call the fib() function with that position, passing in the value the user entered.
3. The fib() function examines the argument (n). If n < 3 it returns 1; otherwise, fib()
calls itself (recursively) passing in n-2, calls itself again passing in n-1, and returns the sum.
If you call fib(1), it returns 1. If you call fib(2), it returns 1. If you call fib(3), it returns the
sum of calling fib(2) and fib(1). Because fib(2) returns 1 and fib(1) returns 1, fib(3)
will return 2.
If you call fib(4), it returns the sum of calling fib(3) and fib(2). We've established that
fib(3) returns 2 (by calling fib(2) and fib(1)) and that fib(2) returns 1, so fib(4) will
sum these numbers and return 3, which is the fourth number in the series.
Taking this one more step, if you call fib(5), it will return the sum of fib(4) and fib(3).
We've established that fib(4) returns 3 and fib(3) returns 2, so the sum returned will be 5.
This method is not the most efficient way to solve this problem (in fib(20) the fib() function is
called 13,529 times!), but it does work. Be careful: if you feed in too large a number, you'll run out of
memory. Every time fib() is called, memory is set aside. When it returns, memory is freed. With
recursion, memory continues to be set aside before it is freed, and this system can eat memory very
quickly. Listing 5.10 implements the fib() function.
WARNING: When you run Listing 5.10, use a small number (less than 15). Because
this uses recursion, it can consume a lot of memory.
Listing 5.10. Demonstrates recursion using the Fibonacci series .
1:
2:
3:
4:
//
//
//
//
Listing 5.10 - demonstrates recursion
Fibonacci find.
Finds the nth Fibonacci number
Uses this algorithm: Fib(n) = fib(n-1) + fib(n-2)5:
// Stop conditions: n = 2 || n = 1
6:
7:
#include <iostream.h>
8:
9:
int fib(int n);
10:
11:
int main()
12:
{
13:
14:
int n, answer;
15:
cout << "Enter number to find: ";
16:
cin >> n;
17:
18:
cout << "\n\n";
19:
20:
answer = fib(n);
21:
22:
cout << answer << " is the " << n << "th Fibonacci
number\n";
23:
return 0;
24:
}
25:
26:
int fib (int n)
27:
{
28:
cout << "Processing fib(" << n << ")... ";
29:
30:
if (n < 3 )
31:
{
32:
cout << "Return 1!\n";
33:
return (1);
34:
}
35:
else
36:
{
37:
cout << "Call fib(" << n-2 << ") and fib(" << n-1 <<
").\n";
38:
return( fib(n-2) + fib(n-1));
39:
}
40: }
Output: Enter number to find:
Processing
Processing
Processing
Processing
Processing
fib(5)...
fib(3)...
fib(1)...
fib(2)...
fib(4)...
5
Call fib(3) and fib(4).
Call fib(1) and fib(2).
Return 1!
Return 1!
Call fib(2) and fib(3).Processing fib(2)... Return 1!
Processing fib(3)... Call fib(1) and fib(2).
Processing fib(1)... Return 1!
Processing fib(2)... Return 1!
5 is the 5th Fibonacci number
Analysis: The program asks for a number to find on line 15 and assigns that number to target. It
then calls fib() with the target. Execution branches to the fib() function, where, on line 28, it
prints its argument.
The argument n is tested to see whether it equals 1 or 2 on line 30; if so, fib() returns. Otherwise,
it returns the sums of the values returned by calling fib() on n-2 and n-1.
In the example, n is 5 so fib(5) is called from main(). Execution jumps to the fib() function,
and n is tested for a value less than 3 on line 30. The test fails, so fib(5) returns the sum of the
values returned by fib(3) and fib(4). That is, fib() is called on n-2 (5 - 2 = 3) and n-1 (5 - 1
= 4). fib(4) will return 3 and fib(3) will return 2, so the final answer will be 5.
Because fib(4) passes in an argument that is not less than 3, fib() will be called again, this time
with 3 and 2. fib(3) will in turn call fib(2) and fib(1). Finally, the calls to fib(2) and
fib(1) will both return 1, because these are the stop conditions.
The output traces these calls and the return values. Compile, link, and run this program, entering first
1, then 2, then 3, building up to 6, and watch the output carefully. Then, just for fun, try the number
20. If you don't run out of memory, it makes quite a show!
Recursion is not used often in C++ programming, but it can be a powerful and elegant tool for certain
needs.
NOTE: Recursion is a very tricky part of advanced programming. It is presented here
because it can be very useful to understand the fundamentals of how it works, but don't
worry too much if you don't fully understand all the details.
How Functions WorkA Look Under the Hood
When you call a function, the code branches to the called function, parameters are passed in, and the
body of the function is executed. When the function completes, a value is returned (unless the
function returns void), and control returns to the calling function.
How is this task accomplished? How does the code know where to branch to? Where are the variables
kept when they are passed in? What happens to variables that are declared in the body of the function?
How is the return value passed back out? How does the code know where to resume?
Most introductory books don't try to answer these questions, but without understanding thisinformation, you'll find that programming remains a fuzzy mystery. The explanation requires a brief
tangent into a discussion of computer memory.
Levels of Abstraction
One of the principal hurdles for new programmers is grappling with the many layers of intellectual
abstraction. Computers, of course, are just electronic machines. They don't know about windows and
menus, they don't know about programs or instructions, and they don't even know about 1s and 0s. All
that is really going on is that voltage is being measured at various places on an integrated circuit. Even
this is an abstraction: electricity itself is just an intellectual concept, representing the behavior of
subatomic particles.
Few programmers bother much with any level of detail below the idea of values in RAM. After all,
you don't need to understand particle physics to drive a car, make toast, or hit a baseball, and you
don't need to understand the electronics of a computer to program one.
You do need to understand how memory is organized, however. Without a reasonably strong mental
picture of where your variables are when they are created, and how values are passed among
functions, it will all remain an unmanageable mystery.
Partitioning RAM
When you begin your program, your operating system (such as DOS or Microsoft Windows) sets up
various areas of memory based on the requirements of your compiler. As a C++ programmer, you'll
often be concerned with the global name space, the free store, the registers, the code space, and the
stack.
Global variables are in global name space. We'll talk more about global name space and the free store
in coming days, but for now we'll focus on the registers, code space, and stack.
Registers are a special area of memory built right into the Central Processing Unit (or CPU). They
take care of internal housekeeping. A lot of what goes on in the registers is beyond the scope of this
book, but what we are concerned about is the set of registers responsible for pointing, at any given
moment, to the next line of code. We'll call these registers, together, the instruction pointer. It is the
job of the instruction pointer to keep track of which line of code is to be executed next.
The code itself is in code space, which is that part of memory set aside to hold the binary form of the
instructions you created in your program. Each line of source code is translated into a series of
instructions, and each of these instructions is at a particular address in memory. The instruction
pointer has the address of the next instruction to execute. Figure 5.4 illustrates this idea.
Figure 5.4.The instruction pointer.
The stack is a special area of memory allocated for your program to hold the data required by each of
the functions in your program. It is called a stack because it is a last-in, first-out queue, much like astack of dishes at a cafeteria, as shown in Figure 5.5.
Last-in, first-out means that whatever is added to the stack last will be the first thing taken off. Most
queues are like a line at a theater: the first one on line is the first one off. A stack is more like a stack
of coins: if you stack 10 pennies on a tabletop and then take some back, the last three you put on will
be the first three you take off.
When data is "pushed" onto the stack, the stack grows; as data is "popped" off the stack, the stack
shrinks. It isn't possible to pop a dish off the stack without first popping off all the dishes placed on
after that dish.
Figure 5.5. A stack.
A stack of dishes is the common analogy. It is fine as far as it goes, but it is wrong in a fundamental
way. A more accurate mental picture is of a series of cubbyholes aligned top to bottom. The top of the
stack is whatever cubby the stack pointer (which is another register) happens to be pointing to.
Each of the cubbies has a sequential address, and one of those addresses is kept in the stack pointer
register. Everything below that magic address, known as the top of the stack, is considered to be on
the stack. Everything above the top of the stack is considered to be off the stack and invalid. Figure
5.6 illustrates this idea.
Figure 5.6.The stack pointer.
When data is put on the stack, it is placed into a cubby above the stack pointer, and then the stack
pointer is moved to the new data. When data is popped off the stack, all that really happens is that the
address of the stack pointer is changed by moving it down the stack. Figure 5.7 makes this rule clear.
Figure 5.7. Moving the stack pointer.
The Stack and Functions
Here's what happens when a program, running on a PC under DOS, branches to a function:
1. The address in the instruction pointer is incremented to the next instruction past the function
call. That address is then placed on the stack, and it will be the return address when the
function returns.
2. Room is made on the stack for the return type you've declared. On a system with two-byte
integers, if the return type is declared to be int, another two bytes are added to the stack, but
no value is placed in these bytes.
3. The address of the called function, which is kept in a special area of memory set aside for
that purpose, is loaded into the instruction pointer, so the next instruction executed will be in
the called function.4. The current top of the stack is now noted and is held in a special pointer called the stack
frame. Everything added to the stack from now until the function returns will be considered
"local" to the function.
5. All the arguments to the function are placed on the stack.
6. The instruction now in the instruction pointer is executed, thus executing the first instruction
in the function.
7. Local variables are pushed onto the stack as they are defined.
When the function is ready to return, the return value is placed in the area of the stack reserved at step
2. The stack is then popped all the way up to the stack frame pointer, which effectively throws away
all the local variables and the arguments to the function.
The return value is popped off the stack and assigned as the value of the function call itself, and the
address stashed away in step 1 is retrieved and put into the instruction pointer. The program thus
resumes immediately after the function call, with the value of the function retrieved.
Some of the details of this process change from compiler to compiler, or between computers, but the
essential ideas are consistent across environments. In general, when you call a function, the return
address and the parameters are put on the stack. During the life of the function, local variables are
added to the stack. When the function returns, these are all removed by popping the stack.
In coming days we'll look at other places in memory that are used to hold data that must persist
beyond the life of the function.
Summary
This chapter introduced functions. A function is, in effect, a subprogram into which you can pass
parameters and from which you can return a value. Every C++ program starts in the main()
function, and main() in turn can call other functions.
A function is declared with a function prototype, which describes the return value, the function name,
and its parameter types. A function can optionally be declared inline. A function prototype can also
declare default variables for one or more of the parameters.
The function definition must match the function prototype in return type, name, and parameter list.
Function names can be overloaded by changing the number or type of parameters; the compiler finds
the right function based on the argument list.
Local function variables, and the arguments passed in to the function, are local to the block in which
they are declared. Parameters passed by value are copies and cannot affect the value of variables in
the calling function.Q&A
Q. Why not make all variables global?
A. There was a time when this was exactly how programming was done. As programs became
more complex, however, it became very difficult to find bugs in programs because data could
be corrupted by any of the functions--global data can be changed anywhere in the program.
Years of experience have convinced programmers that data should be kept as local as possible,
and access to changing that data should be narrowly defined.
Q. When should the keyword inline be used in a function prototype?
A. If the function is very small, no more than a line or two, and won't be called from many
places in your program, it is a candidate for inlining.
Q. Why aren't changes to the value of function arguments reflected in the calling
function?
A. Arguments passed to a function are passed by value. That means that the argument in the
function is actually a copy of the original value. This concept is explained in depth in the
"Extra Credit" section that follows the Workshop.
Q. If arguments are passed by value, what do I do if I need to reflect the changes back in
the calling function?
A. On Day 8, pointers will be discussed. Use of pointers will solve this problem, as well as
provide a way around the limitation of returning only a single value from a function.
Q. What happens if I have the following two functions?
int Area (int width, int length = 1); int Area (int size);
Will these overload? There are a different number of parameters, but the first one has a default
value.
A. The declarations will compile, but if you invoke Area with one parameter you will receive
a compile-time error: ambiguity between Area(int, int) and Area(int).
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material
covered, and exercises to provide you with experience in using what you've learned. Try to answer the
quiz and exercise questions before checking the answers in Appendix D, and make sure that you
understand the answers before continuing to the next chapter.
Quiz1. What are the differences between the function prototype and the function definition?
2. Do the names of parameters have to agree in the prototype, definition, and call to the
function?
3. If a function doesn't return a value, how do you declare the function?
4. If you don't declare a return value, what type of return value is assumed?
5. What is a local variable?
6. What is scope?
7. What is recursion?
8. When should you use global variables?
9. What is function overloading?
10. What is polymorphism?
Exercises
1. Write the prototype for a function named Perimeter(), which returns an unsigned
long int and that takes two parameters, both unsigned short ints.
2. Write the definition of the function Perimeter() as described in Exercise 1. The two
parameters represent the length and width of a rectangle. Have the function return the
perimeter (twice the length plus twice the width).
3. BUG BUSTER: What is wrong with the function in the following code?
#include <iostream.h>
void myFunc(unsigned short int x);
int main()
{
unsigned short int x, y;
y = myFunc(int);
cout << "x: " << x << " y: " << y << "\n";
}
void myFunc(unsigned short int x)
{
return (4*x);
}
4. BUG BUSTER: What is wrong with the function in the following code?#include <iostream.h>
int myFunc(unsigned short int x);
int main()
{
unsigned short int x, y;
y = myFunc(x);
cout << "x: " << x << " y: " << y << "\n";
}
int myFunc(unsigned short int x);
{
return (4*x);
}
5. Write a function that takes two unsigned short integer arguments and returns the result
of dividing the first by the second. Do not do the division if the second number is zero, but do
return -1.
6. Write a program that asks the user for two numbers and calls the function you wrote in
Exercise 5. Print the answer, or print an error message if you get -1.
7. Write a program that asks for a number and a power. Write a recursive function that takes
the number to the power. Thus, if the number is 2 and the power is 4, the function will return
16.
Day 6
Basic Classes
Creating New Types
Why Create a New Type?
Classes and Members
Declaring a Class
A Word on Naming Conventions
Defining an Object
Classes Versus Objects
Accessing Class Members
Assign to Objects, Not to Classes
If You Dont Declare It, Your Class Wont Have It
Private Versus Public
Listing 6.1. Accessing the public members
of a simple class.
Make Member Data Private
Listing 6.2. A class with accessor methods.
Privacy Versus Security
The class keyword
Implementing Class Methods
Listing 6.3. Implementing
the methods of a simple class.
Constructors and Destructors
Default Constructors and Destructors
Listing 6.4. Using constructors and destructors.
const Member Functions
Interface Versus Implementation
Listing 6.5. A demonstration of violations of the interface.
Why Use the Compiler to Catch Errors?
Where to Put Class Declarations and Method Definitions
Inline Implementation
Listing 6.6. Cat class declaration in CAT.HPP.
Listing 6.7. Cat implementation in CAT.CPP.
Classes with Other Classes as Member Data
Listing 6.8. Declaring a complete class.
Listing 6.9. RECT.CPP.
Structures
Why Two Keywords Do the Same Thing
Summary 
Q&A
Workshop
Quiz
Exercises
Day 6
Basic Classes
Classes extend the built-in capabilities of C++ to assist you in representing and solving complex, real-
world problems. Today you will learn
What classes and objects are.
How to define a new class and create objects of that class.
What member functions and member data are.
What constructors are and how to use them.
Creating New Types
You've already learned about a number of variable types, including unsigned integers and characters.
The type of a variable tells you quite a bit about it. For example, if you declare Height and Width
to be unsigned integers, you know that each one can hold a number between 0 and 65,535, assuming
an integer is two bytes. That is the meaning of saying they are unsigned integers; trying to hold
anything else in these variables causes an error. You can't store your name in an unsigned short
integer, and you shouldn't try.
Just by declaring these variables to be unsigned short integers, you know that it is possible to add
Height to Width and to assign that number to another number.
The type of these variables tells you:
Their size in memory.
What information they can hold.
W What actions can be performed on them.More generally, a type is a category. Familiar types include car, house, person, fruit, and shape. In
C++, the programmer can create any type needed, and each of these new types can have all the
functionality and power of the built-in types.
Why Create a New Type?
Programs are usually written to solve real-world problems, such as keeping track of employee records
or simulating the workings of a heating system. Although it is possible to solve complex problems by
using programs written with only integers and characters, it is far easier to grapple with large, complex
problems if you can create representations of the objects that you are talking about. In other words,
simulating the workings of a heating system is easier if you can create variables that represent rooms,
heat sensors, thermostats, and boilers. The closer these variables correspond to reality, the easier it is
to write the program.
Classes and Members
You make a new type by declaring a class. A class is just a collection of variables--often of different
types--combined with a set of related functions.
One way to think about a car is as a collection of wheels, doors, seats, windows, and so forth. Another
way is to think about what a car can do: It can move, speed up, slow down, stop, park, and so on. A
class enables you to encapsulate, or bundle, these various parts and various functions into one
collection, which is called an object.
Encapsulating everything you know about a car into one class has a number of advantages for a
programmer. Everything is in one place, which makes it easy to refer to, copy, and manipulate the
data. Likewise, clients of your class--that is, the parts of the program that use your class--can use your
object without worry about what is in it or how it works.
A class can consist of any combination of the variable types and also other class types. The variables
in the class are referred to as the member variables or data members. A Car class might have member
variables representing the seats, radio type, tires, and so forth.
New Term: Member variables , also known as data members , are the variables in your class.
Member variables are part of your class, just like the wheels and engine are part of your car.
The functions in the class typically manipulate the member variables. They are referred to as member
functions or methods of the class. Methods of the Car class might include Start() and Brake().
A Cat class might have data members that represent age and weight; its methods might include
Sleep(), Meow(), and ChaseMice().
New Term: Member functions , also known as methods , are the functions in your class.Member functions are as much a part of your class as the member variables. They determine
what the objects of your class can do.
Declaring a Class
To declare a class, use the class keyword followed by an opening brace, and then list the data
members and methods of that class. End the declaration with a closing brace and a semicolon. Here's
the declaration of a class called Cat:
class Cat
{
unsigned int
unsigned int
Meow();
};
itsAge;
itsWeight;
Declaring this class doesn't allocate memory for a Cat. It just tells the compiler what a Cat is, what
data it contains (itsAge and itsWeight), and what it can do (Meow()). It also tells the compiler
how big a Cat is--that is, how much room the compiler must set aside for each Cat that you create.
In this example, if an integer is two bytes, a Cat is only four bytes big: itsAge is two bytes, and
itsWeight is another two bytes. Meow() takes up no room, because no storage space is set aside
for member functions (methods).
A Word on Naming Conventions
As a programmer, you must name all your member variables, member functions, and classes. As you
learned on Day 3, "Variables and Constants," these should be easily understood and meaningful
names. Cat, Rectangle, and Employee are good class names. Meow(), ChaseMice(), and
StopEngine() are good function names, because they tell you what the functions do. Many
programmers name the member variables with the prefix its, as in itsAge, itsWeight, and
itsSpeed. This helps to distinguish member variables from nonmember variables.
C++ is case-sensitive, and all class names should follow the same pattern. That way you never have to
check how to spell your class name; was it Rectangle, rectangle, or RECTANGLE? Some
programmers like to prefix every class name with a particular letter--for example, cCat or cPerson--
whereas others put the name in all uppercase or all lowercase. The convention that I use is to name all
classes with initial-capitalization, as in Cat and Person.
Similarly, many programmers begin all functions with capital letters and all variables with lowercase.
Words are usually separated with an underbar--as in Chase_Mice--or by capitalizing each word--for
example, ChaseMice or DrawCircle.
The important idea is that you should pick one style and stay with it through each program. Over time,
your style will evolve to include not only naming conventions, but also indentation, alignment ofbraces, and commenting style.
NOTE: It's common for development companies to have house standards for many
style issues. This ensures that all developers can easily read one another's code.
Defining an Object
You define an object of your new type just as you define an integer variable:
unsigned int GrossWeight;
Cat Frisky;
// define an unsigned integer
// define a Cat
This code defines a variable called Gross Weight whose type is an unsigned integer. It also
defines Frisky, which is an object whose class (or type) is Cat.
Classes Versus Objects
You never pet the definition of a cat; you pet individual cats. You draw a distinction between the idea
of a cat, and the particular cat that right now is shedding all over your living room. In the same way,
C++ differentiates between the class Cat, which is the idea of a cat, and each individual Cat object.
Thus, Frisky is an object of type Cat in the same way in which GrossWeight is a variable of type
unsigned int.
New Term: An object is an individual instance of a class.
Accessing Class Members
Once you define an actual Cat object--for example, Frisky--you use the dot operator (.) to access the
members of that object. Therefore, to assign 50 to Frisky's Weight member variable, you would
write
Frisky.Weight = 50;
In the same way, to call the Meow() function, you would write
Frisky.Meow();
When you use a class method, you call the method. In this example, you are calling Meow() on
Frisky.Assign to Objects, Not to Classes
In C++ you don't assign values to types; you assign values to variables. For example, you would never
write
int = 5;
// wrong
The compiler would flag this as an error, because you can't assign 5 to an integer. Rather, you must
define an integer variable and assign 5 to that variable. For example,
int x;
x = 5;
// define x to be an int
// set x's value to 5
This is a shorthand way of saying, "Assign 5 to the variable x, which is of type int." In the same
way, you wouldn't write
Cat.age=5;
???
// wrong
The compiler would flag this as an error, because you can't assign 5 to the age part of a Cat. Rather,
you must define a Cat object and assign 5 to that object. For example,
Cat Frisky;
Frisky.age = 5;
// just like
// just like
int x;
x = 5;
If You Dont Declare It, Your Class Wont Have It
Try this experiment: Walk up to a three-year-old and show her a cat. Then say, "This is Frisky. Frisky
knows a trick. Frisky, bark." The child will giggle and say, "No, silly, cats can't bark."
If you wrote
Cat Frisky;
Frisky.Bark()
// make a Cat named Frisky
// tell Frisky to bark
the compiler would say, No, silly, Cats can't bark. (Your compiler's wording may vary).
The compiler knows that Frisky can't bark because the Cat class doesn't have a Bark() function.
The compiler wouldn't even let Frisky meow if you didn't define a Meow() function.
DO use the keyword class to declare a class. DON'T confuse a declaration with a
definition. A declaration says what a class is. A definition sets aside memory for an
object. DON'T confuse a class with an object. DON'T assign values to a class. Assign
values to the data members of an object. DO use the dot operator (.) to access classmembers and functions.
Private Versus Public
Other keywords are used in the declaration of a class. Two of the most important are public and
private.
All members of a class--data and methods--are private by default. Private members can be accessed
only within methods of the class itself. Public members can be accessed through any object of the
class. This distinction is both important and confusing. To make it a bit clearer, consider an example
from earlier in this chapter:
class Cat
{
unsigned int
unsigned int
Meow();
};
itsAge;
itsWeight;
In this declaration, itsAge, itsWeight, and Meow() are all private, because all members of a
class are private by default. This means that unless you specify otherwise, they are private.
However, if you write
Cat Boots;
Boots.itsAge=5;
// error! can't access private data!
the compiler flags this as an error. In effect, you've said to the compiler, "I'll access itsAge,
itsWeight, and Meow() only from within member functions of the Cat class." Yet here you've
accessed the itsAge member variable of the Boots object from outside a Cat method. Just because
Boots is an object of class Cat, that doesn't mean that you can access the parts of Boots that are
private.
This is a source of endless confusion to new C++ programmers. I can almost hear you yelling, "Hey! I
just said Boots is a cat. Why can't Boots access his own age?" The answer is that Boots can, but you
can't. Boots, in his own methods, can access all his parts--public and private. Even though you've
created a Cat, that doesn't mean that you can see or change the parts of it that are private.
The way to use Cat so that you can access the data members is
class Cat
{
public:
unsigned int
itsAge;unsigned int
Meow();
};
itsWeight;
Now itsAge, itsWeight, and Meow() are all public. Boots.itsAge=5 compiles without
problems.
Listing 6.1 shows the declaration of a Cat class with public member variables.
Listing 6.1. Accessing the public members of a simple class.
1:
// Demonstrates declaration of a class and
2:
// definition of an object of the class,
3:
4:
#include <iostream.h>
// for cout
5:
6:
class Cat
// declare the class object
7:
{
8:
public:
// members which follow are public
9:
int itsAge;
10:
int itsWeight;
11: };
12:
13:
14: void main()
15: {
16:
Cat Frisky;
17:
Frisky.itsAge = 5;
// assign to the member variable
18:
cout << "Frisky is a cat who is " ;
19:
cout << Frisky.itsAge << " years old.\n";
20:
Output: Frisky is a cat who is 5 years old.
Analysis: Line 6 contains the keyword class. This tells the compiler that what follows is a
declaration. The name of the new class comes after the keyword class. In this case, it is Cat.
The body of the declaration begins with the opening brace in line 7 and ends with a closing brace and
a semicolon in line 11. Line 8 contains the keyword public, which indicates that everything that
follows is public until the keyword private or the end of the class declaration.
Lines 9 and 10 contain the declarations of the class members itsAge and itsWeight.
Line 14 begins the main function of the program. Frisky is defined in line 16 as an instance of a
Cat--that is, as a Cat object. Frisky's age is set in line 17 to 5. In lines 18 and 19, the itsAge
member variable is used to print out a message about Frisky.NOTE: Try commenting out line 8 and try to recompile. You will receive an error on
line 17 because itsAge will no longer have public access. The default for classes is
private access.
Make Member Data Private
As a general rule of design, you should keep the member data of a class private. Therefore, you must
create public functions known as accessor methods to set and get the private member variables. These
accessor methods are the member functions that other parts of your program call to get and set your
private member variables.
New Term: A public accessor method is a class member function used either to read the value
of a private class member variable or to set its value.
Why bother with this extra level of indirect access? After all, it is simpler and easier to use the data,
instead of working through accessor functions.
Accessor functions enable you to separate the details of how the data is stored from how it is used.
This enables you to change how the data is stored without having to rewrite functions that use the
data.
If a function that needs to know a Cat's age accesses itsAge directly, that function would need to be
rewritten if you, as the author of the Cat class, decided to change how that data is stored. By having
the function call GetAge(), your Cat class can easily return the right value no matter how you
arrive at the age. The calling function doesn't need to know whether you are storing it as an unsigned
integer or a long, or whether you are computing it as needed.
This technique makes your program easier to maintain. It gives your code a longer life because design
changes don't make your program obsolete.
Listing 6.2 shows the Cat class modified to include private member data and public accessor
methods. Note that this is not an executable listing.
Listing 6.2. A class with accessor methods.
1:
// Cat class declaration
2:
// Data members are private, public accessor methods
3:
// mediate setting and getting the values of the private
data
4:
5: class Cat6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
{
public:
// public accessors
unsigned int GetAge();
void SetAge(unsigned int Age);
unsigned int GetWeight();
void SetWeight(unsigned int Weight);
// public member functions
Meow();
// private member data
private:
unsigned int itsAge;
unsigned int itsWeight;
};
Analysis: This class has five public methods. Lines 9 and 10 contain the accessor methods for
itsAge. Lines 12 and 13 contain the accessor methods for itsWeight. These accessor functions
set the member variables and return their values.
The public member function Meow() is declared in line 16. Meow() is not an accessor function. It
doesn't get or set a member variable; it performs another service for the class, printing the word Meow.
The member variables themselves are declared in lines 20 and 21.
To set Frisky's age, you would pass the value to the SetAge() method, as in
Cat Frisky;
Frisky.SetAge(5);
// set Frisky's age using the public accessor
Privacy Versus Security
Declaring methods or data private enables the compiler to find programming mistakes before they
become bugs. Any programmer worth his consulting fees can find a way around privacy if he wants
to. Stroustrup, the inventor of C++, said, "The C++ access control mechanisms provide protection
against accident--not against fraud." (ARM, 1990.)
The class keyword
Syntax for the class keyword is as follows.
class class_name
{// access control keywords here
// class variables and methods declared here
};
You use the class keyword to declare new types. A class is a collection of class member data, which
are variables of various types, including other classes. The class also contains class functions--or
methods--which are functions used to manipulate the data in the class and to perform other services
for the class. You define objects of the new type in much the same way in which you define any
variable. State the type (class) and then the variable name (the object). You access the class members
and functions by using the dot (.) operator. You use access control keywords to declare sections of
the class as public or private. The default for access control is private. Each keyword changes the
access control from that point on to the end of the class or until the next access control keyword. Class
declarations end with a closing brace and a semicolon. Example 1
class Cat
{
public:
unsigned int Age;
unsigned int Weight;
void Meow();
};
Cat Frisky;
Frisky.Age = 8;
Frisky.Weight = 18;
Frisky.Meow();
Example
class Car
{
public:
// the next five are public
void Start();
void Accelerate();
void Brake();
void SetYear(int year);
int GetYear();
private: // the rest is private
int Year;
Char Model [255];
}; // end of class declaration
Car OldFaithful; // make an instance of carint bought;
OldFaithful.SetYear(84) ;
bought = OldFaithful.GetYear();
OldFaithful.Start();
//
//
//
//
a local variable of type int
assign 84 to the year
set bought to 84
call the start method
DO declare member variables private. DO use public accessor methods. DON'T try to
use private member variables from outside the class. DO access private member
variables from within class member functions.
Implementing Class Methods
As you've seen, an accessor function provides a public interface to the private member data of the
class. Each accessor function, along with any other class methods that you declare, must have an
implementation. The implementation is called the function definition.
A member function definition begins with the name of the class, followed by two colons, the name of
the function, and its parameters. Listing 6.3 shows the complete declaration of a simple Cat class and
the implementation of its accessor function and one general class member function.
Listing 6.3. Implementing the methods of a simple class.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
// Demonstrates declaration of a class and
// definition of class methods,
#include <iostream.h>
class Cat
{
public:
int GetAge();
void SetAge (int age);
void Meow();
private:
int itsAge;
};
// for cout
// begin declaration of the class
//
//
//
//
//
//
begin public section
accessor function
accessor function
general function
begin private section
member variable
// GetAge, Public accessor function
// returns value of itsAge member
int Cat::GetAge()
{
return itsAge;
}23: // definition of SetAge, public
24: // accessor function
25: // returns sets itsAge member
26: void Cat::SetAge(int age)
27: {
28:
// set member variable its age to
29:
// value passed in by parameter age
30:
itsAge = age;
31: }
32:
33: // definition of Meow method
34: // returns: void
35: // parameters: None
36: // action: Prints "meow" to screen
37: void Cat::Meow()
38: {
39:
cout << "Meow.\n";
40: }
41:
42: // create a cat, set its age, have it
43: // meow, tell us its age, then meow again.
44: int main()
45: {
46:
Cat Frisky;
47:
Frisky.SetAge(5);
48:
Frisky.Meow();
49:
cout << "Frisky is a cat who is " ;
50:
cout << Frisky.GetAge() << " years old.\n";
51:
Frisky.Meow();
52;
return 0;
53: }
Output: Meow.
Frisky is a cat who is 5 years old.
Meow.
Analysis: Lines 6-14 contain the definition of the Cat class. Line 8 contains the keyword public,
which tells the compiler that what follows is a set of public members. Line 9 has the declaration of the
public accessor method GetAge(). GetAge() provides access to the private member variable
itsAge, which is declared in line 13. Line 10 has the public accessor function SetAge().
SetAge() takes an integer as an argument and sets itsAge to the value of that argument.
Line 11 has the declaration of the class method Meow(). Meow() is not an accessor function. Here it
is a general method that prints the word Meow to the screen.
Line 12 begins the private section, which includes only the declaration in line 13 of the private
member variable itsAge. The class declaration ends with a closing brace and semicolon in line 14.Lines 18-21 contain the definition of the member function GetAge(). This method takes no
parameters; it returns an integer. Note that class methods include the class name followed by two
colons and the function name (Line 18). This syntax tells the compiler that the GetAge() function
that you are defining here is the one that you declared in the Cat class. With the exception of this
header line, the GetAge() function is created like any other function.
The GetAge() function takes only one line; it returns the value in itsAge. Note that the main()
function cannot access itsAge because itsAge is private to the Cat class. The main() function
has access to the public method GetAge(). Because GetAge() is a member function of the Cat
class, it has full access to the itsAge variable. This access enables GetAge() to return the value of
itsAge to main().
Line 26 contains the definition of the SetAge() member function. It takes an integer parameter and
sets the value of itsAge to the value of that parameter in line 30. Because it is a member of the Cat
class, SetAge() has direct access to the member variable itsAge.
Line 37 begins the definition, or implementation, of the Meow() method of the Cat class. It is a one-
line function that prints the word Meow to the screen, followed by a new line. Remember that the \n
character prints a new line to the screen.
Line 44 begins the body of the program with the familiar main() function. In this case, it takes no
arguments and returns void. In line 46, main() declares a Cat named Frisky. In line 47, the
value 5 is assigned to the itsAge member variable by way of the SetAge() accessor method. Note
that the method is called by using the class name (Frisky) followed by the member operator (.) and
the method name (SetAge()). In this same way, you can call any of the other methods in a class.
Line 48 calls the Meow() member function, and line 49 prints a message using the GetAge()
accessor. Line 51 calls Meow() again.
Constructors and Destructors
There are two ways to define an integer variable. You can define the variable and then assign a value
to it later in the program. For example,
int Weight;
...
Weight = 7;
// define a variable
// other code here
// assign it a value
Or you can define the integer and immediately initialize it. For example,
int Weight = 7;
// define and initialize to 7
Initialization combines the definition of the variable with its initial assignment. Nothing stops you
from changing that value later. Initialization ensures that your variable is never without a meaningfulvalue.
How do you initialize the member data of a class? Classes have a special member function called a
constructor. The constructor can take parameters as needed, but it cannot have a return value--not even
void. The constructor is a class method with the same name as the class itself.
Whenever you declare a constructor, you'll also want to declare a destructor. Just as constructors
create and initialize objects of your class, destructors clean up after your object and free any memory
you might have allocated. A destructor always has the name of the class, preceded by a tilde (~).
Destructors take no arguments and have no return value. Therefore, the Cat declaration includes
~Cat();
Default Constructors and Destructors
If you don't declare a constructor or a destructor, the compiler makes one for you. The default
constructor and destructor take no arguments and do nothing.
What good is a constructor that does nothing? In part, it is a matter of form. All objects must be
constructed and destructed, and these do-nothing functions are called at the right time. However, to
declare an object without passing in parameters, such as
Cat Rags;
// Rags gets no parameters
you must have a constructor in the form
Cat();
When you define an object of a class, the constructor is called. If the Cat constructor took two
parameters, you might define a Cat object by writing
Cat Frisky (5,7);
If the constructor took one parameter, you would write
Cat Frisky (3);
In the event that the constructor takes no parameters at all, you leave off the parentheses and write
Cat Frisky ;
This is an exception to the rule that states all functions require parentheses, even if they take no
parameters. This is why you are able to writeCat Frisky;
which is a call to the default constructor. It provides no parameters, and it leaves off the parentheses.
You don't have to use the compiler-provided default constructor. You are always free to write your
own constructor with no parameters. Even constructors with no parameters can have a function body
in which they initialize their objects or do other work.
As a matter of form, if you declare a constructor, be sure to declare a destructor, even if your
destructor does nothing. Although it is true that the default destructor would work correctly, it doesn't
hurt to declare your own. It makes your code clearer.
Listing 6.4 rewrites the Cat class to use a constructor to initialize the Cat object, setting its age to
whatever initial age you provide, and it demonstrates where the destructor is called.
Listing 6.4. Using constructors and destructors.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
// Demonstrates declaration of a constructors and
// destructor for the Cat class
#include <iostream.h>
class Cat
{
public:
Cat(int initialAge);
~Cat();
int GetAge();
void SetAge(int age);
void Meow();
private:
int itsAge;
};
// for cout
// begin declaration of the class
//
//
//
//
//
begin public section
constructor
destructor
accessor function
accessor function
// begin private section
// member variable
// constructor of Cat,
Cat::Cat(int initialAge)
{
itsAge = initialAge;
}
Cat::~Cat()
{
}
// destructor, takes no action
// GetAge, Public accessor function
// returns value of itsAge member30: int Cat::GetAge()
31: {
32:
return itsAge;
33: }
34:
35: // Definition of SetAge, public
36: // accessor function
37:
38: void Cat::SetAge(int age)
39: {
40:
// set member variable its age to
41:
// value passed in by parameter age
42:
itsAge = age;
43: }
44:
45: // definition of Meow method
46: // returns: void
47: // parameters: None
48: // action: Prints "meow" to screen
49: void Cat::Meow()
50: {
51:
cout << "Meow.\n";
52: }
53:
54: // create a cat, set its age, have it
55
// meow, tell us its age, then meow again.
56: int main()
57: {
58:
Cat Frisky(5);
59:
Frisky.Meow();
60:
cout << "Frisky is a cat who is " ;
61:
cout << Frisky.GetAge() << " years old.\n";
62:
Frisky.Meow();
63:
Frisky.SetAge(7);
64:
cout << "Now Frisky is " ;
65:
cout << Frisky.GetAge() << " years old.\n";
66;
return 0;
67: }
Output: Meow.
Frisky is a cat who is 5 years old.
Meow.
Now Frisky is 7 years old.
Analysis: Listing 6.4 is similar to 6.3, except that line 9 adds a constructor that takes an integer. Line
10 declares the destructor, which takes no parameters. Destructors never take parameters, and neitherconstructors nor destructors return a value--not even void.
Lines 19-22 show the implementation of the constructor. It is similar to the implementation of the
SetAge() accessor function. There is no return value.
Lines 24-26 show the implementation of the destructor ~Cat(). This function does nothing, but you
must include the definition of the function if you declare it in the class declaration.
Line 58 contains the definition of a Cat object, Frisky. The value 5 is passed in to Frisky's
constructor. There is no need to call SetAge(), because Frisky was created with the value 5 in its
member variable itsAge, as shown in line 61. In line 63, Frisky's itsAge variable is reassigned to
7. Line 65 prints the new value.
DO use constructors to initialize your objects. DON'T give constructors or destructors a
return value. DON'T give destructors parameters.
const Member Functions
If you declare a class method const, you are promising that the method won't change the value of
any of the members of the class. To declare a class method constant, put the keyword const after the
parentheses but before the semicolon. The declaration of the constant member function
SomeFunction() takes no arguments and returns void. It looks like this:
void SomeFunction() const;
Accessor functions are often declared as constant functions by using the const modifier. The Cat
class has two accessor functions:
void SetAge(int anAge);
int GetAge();
SetAge() cannot be const because it changes the member variable itsAge. GetAge(), on the
other hand, can and should be const because it doesn't change the class at all. GetAge() simply
returns the current value of the member variable itsAge. Therefore, the declaration of these
functions should be written like this:
void SetAge(int anAge);
int GetAge() const;
If you declare a function to be const, and the implementation of that function changes the object by
changing the value of any of its members, the compiler flags it as an error. For example, if you wrote
GetAge() in such a way that it kept count of the number of times that the Cat was asked its age, it
would generate a compiler error. This is because you would be changing the Cat object by calling
this method.NOTE: Use const whenever possible. Declare member functions to be const
whenever they should not change the object. This lets the compiler help you find errors;
it's faster and less expensive than doing it yourself.
It is good programming practice to declare as many methods to be const as possible. Each time you
do, you enable the compiler to catch your errors, instead of letting your errors become bugs that will
show up when your program is running.
Interface Versus Implementation
As you've learned, clients are the parts of the program that create and use objects of your class. You
can think of the interface to your class--the class declaration--as a contract with these clients. The
contract tells what data your class has available and how your class will behave.
For example, in the Cat class declaration, you create a contract that every Cat will have a member
variable itsAge that can be initialized in its constructor, assigned to by its SetAge() accessor
function, and read by its GetAge() accessor. You also promise that every Cat will know how to
Meow().
If you make GetAge() a const function--as you should--the contract also promises that
GetAge() won't change the Cat on which it is called.
C++ is strongly typed, which means that the compiler enforces these contracts by giving you a
compiler error when you violate them. Listing 6.5 demonstrates a program that doesn't compile
because of violations of these contracts.
WARNING: Listing 6.5 does not compile!
Listing 6.5. A demonstration of violations of the interface .
1:
2:
3:
4:
5:
6:
7:
8:
9:
// Demonstrates compiler errors
#include <iostream.h>
class Cat
{
public:
Cat(int initialAge);
// for cout10:
~Cat();
11:
int GetAge() const;
// const accessor function
12:
void SetAge (int age);
13:
void Meow();
14: private:
15:
int itsAge;
16: };
17:
18:
// constructor of Cat,
19:
Cat::Cat(int initialAge)
20:
{
21:
itsAge = initialAge;
21:
cout << "Cat Constructor\n";
22:
}
23:
24:
Cat::~Cat()
// destructor, takes no action
25:
{
26:
cout << "Cat Destructor\n";
27:
}
28:
// GetAge, const function
29:
// but we violate const!
30:
int Cat::GetAge() const
31:
{
32:
return (itsAge++);
// violates const!
33:
}
34:
35:
// definition of SetAge, public
36:
// accessor function
37:
38:
void Cat::SetAge(int age)
39:
{
40:
// set member variable its age to
41:
// value passed in by parameter age
42:
itsAge = age;
43:
}
44:
45: // definition of Meow method
46: // returns: void
47: // parameters: None
48: // action: Prints "meow" to screen
49: void Cat::Meow()
50: {
51:
cout << "Meow.\n";
52: }
53:
54: // demonstrate various violations of the55
// interface, and resulting compiler errors
56: int main()
57: {
58:
Cat Frisky;
// doesn't match declaration
59:
Frisky.Meow();
60:
Frisky.Bark();
// No, silly, cat's can't bark.
61:
Frisky.itsAge = 7;
// itsAge is private
62:
return 0;
63: }
Analysis: As it is written, this program doesn't compile. Therefore, there is no output.
This program was fun to write because there are so many errors in it.
Line 11 declares GetAge() to be a const accessor function--as it should be. In the body of
GetAge(), however, in line 32, the member variable itsAge is incremented. Because this method
is declared to be const, it must not change the value of itsAge. Therefore, it is flagged as an error
when the program is compiled.
In line 13, Meow() is not declared const. Although this is not an error, it is bad programming
practice. A better design takes into account that this method doesn't change the member variables of
Cat. Therefore, Meow() should be const.
Line 58 shows the definition of a Cat object, Frisky. Cats now have a constructor, which takes an
integer as a parameter. This means that you must pass in a parameter. Because there is no parameter in
line 58, it is flagged as an error.
Line 60 shows a call to a class method, Bark(). Bark() was never declared. Therefore, it is illegal.
Line 61 shows itsAge being assigned the value 7. Because itsAge is a private data member, it is
flagged as an error when the program is compiled.
Why Use the Compiler to Catch Errors?
While it would be wonderful to write 100 percent bug-free code, few programmers have been able to
do so. However, many programmers have developed a system to help minimize bugs by catching and
fixing them early in the process. Although compiler errors are infuriating and are the bane of a
programmer's existence, they are far better than the alternative. A weakly typed language enables you
to violate your contracts without a peep from the compiler, but your program will crash at run-time--
when, for example, your boss is watching. Compile-time errors--that is, errors found while you are
compiling--are far better than run-time errors--that is, errors found while you are executing the
program. This is because compile-time errors can be found much more reliably. It is possible to run a
program many times without going down every possible code path. Thus, a run-time error can hide for
quite a while. Compile-time errors are found every time you compile. Thus, they are easier to identify
and fix. It is the goal of quality programming to ensure that the code has no runtime bugs. One tried-
and-true technique to accomplish this is to use the compiler to catch your mistakes early in thedevelopment process.
Where to Put Class Declarations and Method Definitions
Each function that you declare for your class must have a definition. The definition is also called the
function implementation. Like other functions, the definition of a class method has a function header
and a function body.
The definition must be in a file that the compiler can find. Most C++ compilers want that file to end
with .C or .CPP. This book uses .CPP, but check your compiler to see what it prefers.
NOTE: Many compilers assume that files ending with .C are C programs, and that
C++ program files end with .CPP. You can use any extension, but .CPP will minimize
confusion.
You are free to put the declaration in this file as well, but that is not good programming practice. The
convention that most programmers adopt is to put the declaration into what is called a header file,
usually with the same name but ending in .H, .HP, or .HPP. This book names the header files with
.HPP, but check your compiler to see what it prefers.
For example, you put the declaration of the Cat class into a file named CAT.HPP, and you put the
definition of the class methods into a file called CAT.CPP. You then attach the header file to the
.CPP file by putting the following code at the top of CAT.CPP:
#include Cat.hpp
This tells the compiler to read CAT.HPP into the file, just as if you had typed in its contents at this
point. Why bother separating them if you're just going to read them back in? Most of the time, clients
of your class don't care about the implementation specifics. Reading the header file tells them
everything they need to know; they can ignore the implementation files.
NOTE: The declaration of a class tells the compiler what the class is, what data it holds,
and what functions it has. The declaration of the class is called its interface because it
tells the user how to interact with the class. The interface is usually stored in an .HPP
file, which is referred to as a header file. The function definition tells the compiler how
the function works. The function definition is called the implementation of the class
method, and it is kept in a .CPP file. The implementation details of the class are of
concern only to the author of the class. Clients of the class--that is, the parts of the
program that use the class--don't need to know, and don't care, how the functions are
implemented.Inline Implementation
Just as you can ask the compiler to make a regular function inline, you can make class methods inline.
The keyword inline appears before the return value. The inline implementation of the
GetWeight() function, for example, looks like this:
inline int Cat::GetWeight()
{
return itsWeight;
// return the Weight data member
}
You can also put the definition of a function into the declaration of the class, which automatically
makes that function inline. For example,
class Cat
{
public:
int GetWeight() { return itsWeight; }
void SetWeight(int aWeight);
};
// inline
Note the syntax of the GetWeight() definition. The body of the inline function begins im-
mediately after the declaration of the class method; there is no semicolon after the paren-theses. Like
any function, the definition begins with an opening brace and ends with a closing brace. As usual,
whitespace doesn't matter; you could have written the declaration as
class Cat
{
public:
int GetWeight()
{
return itsWeight;
}
// inline
void SetWeight(int aWeight);
};
Listings 6.6 and 6.7 re-create the Cat class, but they put the declaration in CAT.HPP and the
implementation of the functions in CAT.CPP. Listing 6.7 also changes the accessor functions and the
Meow() function to inline.
Listing 6.6. Cat class declaration in CAT.HPP
1:
2:
#include <iostream.h>
class Cat3:
{
4: public:
5:
Cat (int initialAge);
6:
~Cat();
7:
int GetAge() { return itsAge;}
8:
void SetAge (int age) { itsAge = age;}
9:
void Meow() { cout << "Meow.\n";}
10: private:
11: int itsAge;
12: };
// inline!
// inline!
// inline!
Listing 6.7. Cat implementation in CAT.CPP .
1:
// Demonstrates inline functions
2:
// and inclusion of header files
3:
4:
#include "cat.hpp" // be sure to include the header files!
5:
6:
7:
Cat::Cat(int initialAge)
//constructor
8:
{
9:
itsAge = initialAge;
10: }
11:
12: Cat::~Cat()
//destructor, takes no action
13: {
14: }
15:
16: // Create a cat, set its age, have it
17: // meow, tell us its age, then meow again.
18: int main()
19: {
20:
Cat Frisky(5);
21:
Frisky.Meow();
22:
cout << "Frisky is a cat who is " ;
23:
cout << Frisky.GetAge() << " years old.\n";
24:
Frisky.Meow();
25:
Frisky.SetAge(7);
26:
cout << "Now Frisky is " ;
27:
cout << Frisky.GetAge() << " years old.\n";
28:
return 0;
29: }
Output: Meow.
Frisky is a cat who is 5 years old.
Meow.Now Frisky is 7 years old.
Analysis: The code presented in Listing 6.6 and Listing 6.7 is similar to the code in Listing 6.4, except
that three of the methods are written inline in the declaration file and the declaration has been
separated into CAT.HPP.
GetAge() is declared in line 7, and its inline implementation is provided. Lines 8 and 9 provide
more inline functions, but the functionality of these functions is unchanged from the previous
"outline" implementations.
Line 4 of Listing 6.7 shows #include "cat.hpp", which brings in the listings from CAT.HPP.
By including cat.hpp, you have told the precompiler to read cat.hpp into the file as if it had been
typed there, starting on line 5.
This technique allows you to put your declarations into a different file from your implementation, yet
have that declaration available when the compiler needs it. This is a very common technique in C++
programming. Typically, class declarations are in an .HPP file that is then #included into the
associated CPP file.
Lines 18-29 repeat the main function from Listing 6.4. This shows that making these functions inline
doesn't change their performance.
Classes with Other Classes as Member Data
It is not uncommon to build up a complex class by declaring simpler classes and including them in the
declaration of the more complicated class. For example, you might declare a wheel class, a motor
class, a transmission class, and so forth, and then combine them into a car class. This declares a has-a
relationship. A car has a motor, it has wheels, and it has a transmission.
Consider a second example. A rectangle is composed of lines. A line is defined by two points. A point
is defined by an x-coordinate and a y-coordinate. Listing 6.8 shows a complete declaration of a
Rectangle class, as might appear in RECTANGLE.HPP. Because a rectangle is defined as four
lines connecting four points and each point refers to a coordinate on a graph, we first declare a Point
class, to hold the x,y coordinates of each point. Listing 6.9 shows a complete declaration of both
classes.
Listing 6.8. Declaring a complete class.
1:
2:
3:
4:
5:
6:
7:
// Begin Rect.hpp
#include <iostream.h>
class Point
// holds x,y coordinates
{
// no constructor, use default
public:
void SetX(int x) { itsX = x; }8:
void SetY(int y) { itsY = y; }
9:
int GetX()const { return itsX;}
10:
int GetY()const { return itsY;}
11:
private:
12:
int itsX;
13:
int itsY;
14: };
// end of Point class declaration
15:
16:
17: class Rectangle
18: {
19:
public:
20:
Rectangle (int top, int left, int bottom, int right);
21:
~Rectangle () {}
22:
23:
int GetTop() const { return itsTop; }
24:
int GetLeft() const { return itsLeft; }
25:
int GetBottom() const { return itsBottom; }
26:
int GetRight() const { return itsRight; }
27:
28:
Point GetUpperLeft() const { return itsUpperLeft; }
29:
Point GetLowerLeft() const { return itsLowerLeft; }
30:
Point GetUpperRight() const { return itsUpperRight; }
31:
Point GetLowerRight() const { return itsLowerRight; }
32:
33:
void SetUpperLeft(Point Location) {itsUpperLeft =
Location;}
34:
void SetLowerLeft(Point Location) {itsLowerLeft =
Location;}
35:
void SetUpperRight(Point Location) {itsUpperRight =
Location;}
36:
void SetLowerRight(Point Location) {itsLowerRight =
Location;}
37:
38:
void SetTop(int top) { itsTop = top; }
39:
void SetLeft (int left) { itsLeft = left; }
40:
void SetBottom (int bottom) { itsBottom = bottom; }
41:
void SetRight (int right) { itsRight = right; }
42:
43:
int GetArea() const;
44:
45:
private:
46:
Point itsUpperLeft;
47:
Point itsUpperRight;
48:
Point itsLowerLeft;
49:
Point itsLowerRight;50:
51:
52:
53:
54: };
55: // end
int
int
int
int
itsTop;
itsLeft;
itsBottom;
itsRight;
Rect.hpp
Listing 6.9. RECT.CPP.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
// Begin rect.cpp
#include "rect.hpp"
Rectangle::Rectangle(int top, int left, int bottom, int right)
{
itsTop = top;
itsLeft = left;
itsBottom = bottom;
itsRight = right;
itsUpperLeft.SetX(left);
itsUpperLeft.SetY(top);
itsUpperRight.SetX(right);
itsUpperRight.SetY(top);
itsLowerLeft.SetX(left);
itsLowerLeft.SetY(bottom);
itsLowerRight.SetX(right);
itsLowerRight.SetY(bottom);
}
// compute area of the rectangle by finding corners,
// establish width and height and then multiply
int Rectangle::GetArea() const
{
int Width = itsRight-itsLeft;
int Height = itsTop - itsBottom;
return (Width * Height);
}
int main()
{
//initialize a local Rectangle variable
Rectangle MyRectangle (100, 20, 50, 80 );38:
int Area = MyRectangle.GetArea();
39:
40:
cout << "Area: " << Area << "\n";
41:
cout << "Upper Left X Coordinate: ";
42:
cout << MyRectangle.GetUpperLeft().GetX();
43:
return 0;
44: }
Output: Area: 3000
Upper Left X Coordinate: 20
Analysis: Lines 3-14 in Listing 6.8 declare the class Point, which is used to hold a specific x,y
coordinate on a graph. As written, this program doesn't use Points much. However, other drawing
methods require Points.
Within the declaration of the class Point, you declare two member variables (itsX and itsY) on
lines 12 and 13. These variables hold the values of the coordinates. As the x-coordinate increases, you
move to the right on the graph. As the y-coordinate increases, you move upward on the graph. Other
graphs use different systems. Some windowing programs, for example, increase the y-coordinate as
you move down in the window.
The Point class uses inline accessor functions to get and set the X and Y points declared on lines 7-
10. Points use the default constructor and destructor. Therefore, you must set their coordinates
explicitly.
Line 17 begins the declaration of a Rectangle class. A Rectangle consists of four points that
represent the corners of the Rectangle.
The constructor for the Rectangle (line 20) takes four integers, known as top, left, bottom,
and right. The four parameters to the constructor are copied into four member variables (Listing
6.9) and then the four Points are established.
In addition to the usual accessor functions, Rectangle has a function GetArea() declared in line
43. Instead of storing the area as a variable, the GetArea() function computes the area on lines 28-
29 of Listing 6.9. To do this, it computes the width and the height of the rectangle, and then it
multiplies these two values.
Getting the x-coordinate of the upper-left corner of the rectangle requires that you access the
UpperLeft point, and ask that point for its X value. Because GetUpperLeft()is ()a method of
Rectangle, it can directly access the private data of Rectangle, including itsUpperLeft.
Because itsUpperLeft is a Point and Point's itsX value is private, GetUpperLeft()
cannot directly access this data. Rather, it must use the public accessor function GetX() to obtain
that value.
Line 33 of Listing 6.9 is the beginning of the body of the actual program. Until line 36, no memory
has been allocated, and nothing has really happened. The only thing you've done is tell the compiler
how to make a point and how to make a rectangle, in case one is ever needed.In line 36, you define a Rectangle by passing in values for Top, Left, Bottom, and Right.
In line 38, you make a local variable, Area, of type int. This variable holds the area of the
Rectangle that you've created. You initialize Area with the value returned by Rectangle's
GetArea() function.
A client of Rectangle could create a Rectangle object and get its area without ever looking at
the implementation of GetArea().
RECT.HPP is shown in Listing 6.8. Just by looking at the header file, which contains the declaration
of the Rectangle class, the programmer knows that GetArea() returns an int. How
GetArea() does its magic is not of concern to the user of class Rectangle. In fact, the author of
Rectangle could change GetArea() without affecting the programs that use the Rectangle
class.
Structures
A very close cousin to the class keyword is the keyword struct, which is used to declare a
structure. In C++, a structure is exactly like a class, except that its members are public by default. You
can declare a structure exactly as you declare a class, and you can give it exactly the same data
members and functions. In fact, if you follow the good programming practice of always explicitly
declaring the private and public sections of your class, there will be no difference whatsoever.
Try re-entering Listing 6.8 with these changes:
In line 3, change class Point to struct Point.
In line 17, change class Rectangle to struct Rectangle.
Now run the program again and compare the output. There should be no change.
Why Two Keywords Do the Same Thing
You're probably wondering why two keywords do the same thing. This is an accident of history. When
C++ was developed, it was built as an extension of the C language. C has structures, although C
structures don't have class methods. Bjarne Stroustrup, the creator of C++, built upon structs, but
he changed the name to class to represent the new, expanded functionality.
DO put your class declaration in an HPP file and your member functions in a CPP file.
DO use const whenever you can. DO understand classes before you move on.
SummaryToday you learned how to create new data types called classes. You learned how to define variables of
these new types, which are called objects.
A class has data members, which are variables of various types, including other classes. A class also
includes member functions--also known as methods. You use these member functions to manipulate
the member data and to perform other services.
Class members, both data and functions, can be public or private. Public members are accessible to
any part of your program. Private members are accessible only to the member functions of the class.
It is good programming practice to isolate the interface, or declaration, of the class in a header file.
You usually do this in a file with an .HPP extension. The implementation of the class methods is
written in a file with a .CPP extension.
Class constructors initialize objects. Class destructors destroy objects and are often used to free
memory allocated by methods of the class.
Q&A
Q. How big is a class object?
A. A class object's size in memory is determined by the sum of the sizes of its member
variables. Class methods don't take up room as part of the memory set aside for the object.
Some compilers align variables in memory in such a way that two-byte variables actually
consume somewhat more than two bytes. Check your compiler manual to be sure, but at this
point there is no reason to be concerned with these details.
Q. If I declare a class Cat with a private member itsAge and then define two Cat objects,
Frisky and Boots, can Boots access Frisky's itsAge member variable?
A. No. While private data is available to the member functions of a class, different instances of
the class cannot access each other's data. In other words, Frisky's member functions can
access Frisky's data, but not Boots'. In fact, Frisky is a completely independent cat from
Boots, and that is just as it should be.
Q. Why shouldn't I make all the member data public?
A. Making member data private enables the client of the class to use the data without worrying
about how it is stored or computed. For example, if the Cat class has a method GetAge(),
clients of the Cat class can ask for the cat's age without knowing or caring if the cat stores its
age in a member variable, or computes its age on the fly.
Q. If using a const function to change the class causes a compiler error, why shouldn't I
just leave out the word const and be sure to avoid errors?A. If your member function logically shouldn't change the class, using the keyword const is a
good way to enlist the compiler in helping you find silly mistakes. For example, GetAge()
might have no reason to change the Cat class, but your implementation has this line:
if (itsAge = 100) cout << "Hey! You're 100 years old\n";
Declaring GetAge() to be const causes this code to be flagged as an error. You meant to
check whether itsAge is equal to 100, but instead you inadvertently assigned 100 to
itsAge. Because this assignment changes the class--and you said this method would not
change the class--the compiler is able to find the error.
This kind of mistake can be hard to find just by scanning the code. The eye often sees only
what it expects to see. More importantly, the program might appear to run correctly, but
itsAge has now been set to a bogus number. This will cause problems sooner or later.
Q. Is there ever a reason to use a structure in a C++ program?
A. Many C++ programmers reserve the struct keyword for classes that have no functions.
This is a throwback to the old C structures, which could not have functions. Frankly, I find it
confusing and poor programming practice. Today's methodless structure might need methods
tomorrow. Then you'll be forced either to change the type to class or to break your rule and
end up with a structure with methods.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material
covered and exercises to provide you with experience in using what you've learned. Try to answer the
quiz and exercise questions before checking the answers in Appendix D, and make sure you
understand the answers before continuing to the next chapter.
Quiz
1. What is the dot operator, and what is it used for?
2. Which sets aside memory--declaration or definition?
3. Is the declaration of a class its interface or its implementation?
4. What is the difference between public and private data members?
5. Can member functions be private?
6. Can member data be public?
7. If you declare two Cat objects, can they have different values in their itsAge member
data?
8. Do class declarations end with a semicolon? Do class method definitions?9. What would the header for a Cat function, Meow, that takes no parameters and returns
void look like?
10. What function is called to initialize a class?
Exercises
1. Write the code that declares a class called Employee with these data members: age,
yearsOfService, and Salary.
2. Rewrite the Employee class to make the data members private, and provide public accessor
methods to get and set each of the data members.
3. Write a program with the Employee class that makes two Employees; sets their age,
YearsOfService, and Salary; and prints their values.
4. Continuing from Exercise 3, provide a method of Employee that reports how many
thousands of dollars the employee earns, rounded to the nearest 1,000.
5. Change the Employee class so that you can initialize age, YearsOfService, and
Salary when you create the employee.
6. BUG BUSTERS: What is wrong with the following declaration?
class Square
{
public:
int Side;
}
7. BUG BUSTERS: Why isn't the following class declaration very useful?
class Cat
{
int GetAge()const;
private:
int itsAge;
};
8. BUG BUSTERS: What three bugs in this code will the compiler find?
class TV
{
public:
void SetStation(int Station);int GetStation() const;
private:
int itsStation;
};
main()
{
TV myTV;
myTV.itsStation = 9;
TV.SetStation(10);
TV myOtherTv(2);
}a
Day 7
".#
More Program Flow
Looping
The Roots of Looping goto
Listing 7.1. Looping with the keyword goto.
Why goto Is Shunned
The goto Statement
ile Loops
Listing 7.2. while loops.
The while Statement
More Complicated while Statements
Listing 7.3. Complex while loops.
continue and break
Listing 7.4. break and continue.
The continue Statement
The break Statement
while (1) Loops
Listing 7.5. while (1) loops.
do...while Loops
Listing 7.6. Skipping the body of the while Loop.
do...while
Listing 7.7. Demonstrates do...while loop.
The do...while Statement
for Loops
Listing 7.8. While reexamined.
Listing 7.9. Demonstrating the for loop.
The for Statement
Advanced for Loops
Listing 7.10. Demonstrating multiple statements in for loops.
Listing 7.11. Null statements in for loops.
Listing 7.12. Illustrating empty for loop statement.
Empty for Loops
Listing 7.13. Illustrates the null statement in a for loop.
Nested Loops
Listing 7.14. Illustrates nested for loops.
Scoping in for Loops
Summing Up Loops
Listing 7.15. Solving the nth Fibonacci number
using iteration.
switch Statements
Listing 7.16. Demonstrating the switch statement.
The switch Statement
Using a switch Statement with a Menu
Listing 7.17. Demonstrating a forever loop.
Summary
Q&A
Workshop
Quiz
Exercises
Day 7
More Program Flow
Programs accomplish most of their work by branching and looping. On Day 4, "Expressions and
Statements," you learned how to branch your program using the if statement. Today you learn
What loops are and how they are used.
How to build various loops.
An alternative to deeply-nested if/else statements.
Looping
Many programming problems are solved by repeatedly acting on the same data. There are two ways to
do this: recursion (discussed yesterday) and iteration. Iteration means doing the same thing again and
again. The principal method of iteration is the loop.
The Roots of Looping goto
In the primitive days of early computer science, programs were nasty, brutish, and short. Loops
consisted of a label, some statements, and a jump.
In C++, a label is just a name followed by a colon (:). The label is placed to the left of a legal C++
statement, and a jump is accomplished by writing goto followed by the label name. Listing 7.1
illustrates this.Listing 7.1. Looping with the keyword goto.
1:
// Listing 7.1
2:
// Looping with goto
3:
4:
#include <iostream.h>
5:
6:
int main()
7:
{
8:
int counter = 0;
// initialize counter
9:
loop: counter ++;
// top of the loop
10:
cout << "counter: " << counter << "\n";
11:
if (counter < 5)
// test the value
12:
goto loop;
// jump to the top
13:
14:
cout << "Complete. Counter: " << counter << ".\n";
15:
return 0;
16: }
Output: counter: 1
counter: 2
counter: 3
counter: 4
counter: 5
Complete. Counter: 5.
Analysis: On line 8, counter is initialized to 0. The label loop is on line 9, marking the top of the
loop. Counter is incremented and its new value is printed. The value of counter is tested on line
11. If it is less than 5, the if statement is true and the goto statement is executed. This causes
program execution to jump back to line 9. The program continues looping until counter is equal to
5, at which time it "falls through" the loop and the final output is printed.
Why goto Is Shunned
goto has received some rotten press lately, and it's well deserved. goto statements can cause a jump
to any location in your source code, backward or forward. The indiscriminate use of goto statements
has caused tangled, miserable, impossible-to-read programs known as "spaghetti code." Because of
this, computer science teachers have spent the past 20 years drumming one lesson into the heads of
their students: "Never, ever, ever use goto! It is evil!"
To avoid the use of goto, more sophisticated, tightly controlled looping commands have been
introduced: for, while, and do...while. Using these makes programs that are more easily
understood, and goto is generally avoided, but one might argue that the case has been a bit
overstated. Like any tool, carefully used and in the right hands, goto can be a useful construct, and
the ANSI committee decided to keep it in the language because it has its legitimate uses. But as theysay, kids, don't try this at home.
The goto Statement
To use the goto statement, you write goto followed by a label name. This causes an unconditioned
jump to the label. Example
if (value > 10)
goto end;if (value < 10)
"value is &*10!";end:cout << "done";
goto end;cout <<
WARNING: Use of goto is almost always a sign of bad design. The best advice is to
avoid using it. In 10 years of programming, I've needed it only once.
while Loops
A while loop causes your program to repeat a sequence of statements as long as the starting
condition remains true. In the example of goto, in Listing 7.1, the counter was incremented until it
was equal to 5. Listing 7.2 shows the same program rewritten to take advantage of a while loop.
Listing 7.2. while loops.
1:
// Listing 7.2
2:
// Looping with while
3:
4:
#include <iostream.h>
5:
6:
int main()
7:
{
8:
int counter = 0;
// initialize the condition
9:
10:
while(counter < 5)
// test condition still true
11:
{
12:
counter++;
// body of the loop
13:
cout << "counter: " << counter << "\n";
14:
}
15:
16:
cout << "Complete. Counter: " << counter << ".\n";
17:
return 0;
18: }
Output: counter: 1
counter: 2
counter: 3counter: 4
counter: 5
Complete. Counter: 5.
Analysis: This simple program demonstrates the fundamentals of the while loop. A condition is
tested, and if it is true, the body of the while loop is executed. In this case, the condition tested on
line 10 is whether counter is less than 5. If the condition is true, the body of the loop is executed;
on line 12 the counter is incremented, and on line 13 the value is printed. When the conditional
statement on line 10 fails (when counter is no longer less than 5), the entire body of the while
loop (lines 11-14) is skipped. Program execution falls through to line 15.
The while Statement
The syntax for the while statement is as follows:
while ( condition )
statement;
condition is any C++ expression, and statement is any valid C++ statement or block of statements.
When condition evaluates to TRUE (1), statement is executed, and then condition is tested again. This
continues until condition tests FALSE, at which time the while loop terminates and execution
continues on the first line below statement.
Example
// count to 10
int x = 0;
while (x < 10)
cout << "X: " << x++;
More Complicated while Statements
The condition tested by a while loop can be as complex as any legal C++ expression. This can
include expressions produced using the logical && (AND), || (OR), and ! (NOT) operators. Listing
7.3 is a somewhat more complicated while statement.
Listing 7.3. Complex while loops.
1:
2:
3:
4:
5:
6:
// Listing 7.3
// Complex while statements
#include <iostream.h>
int main()7:
{
8:
unsigned short small;
9:
unsigned long large;
10:
const unsigned short MAXSMALL=65535;
11:
12:
cout << "Enter a small number: ";
13:
cin >> small;
14:
cout << "Enter a large number: ";
15:
cin >> large;
16:
17:
cout << "small: " << small << "...";
18:
19:
// for each iteration, test three conditions
20:
while (small < large && large > 0 && small < MAXSMALL)
21:
22:
{
23:
if (small % 5000 == 0) // write a dot every 5k lines
24:
cout << ".";
25:
26:
small++;
27:
28:
large-=2;
29:
}
30:
31:
cout << "\nSmall: " << small << " Large: " << large <<
endl;
32:
return 0;
33: }
Output: Enter a small number: 2
Enter a large number: 100000
small: 2.........
Small: 33335 Large: 33334
Analysis: This program is a game. Enter two numbers, one small and one large. The smaller number
will count up by ones, and the larger number will count down by twos. The goal of the game is to
guess when they'll meet.
On lines 12-15, the numbers are entered. Line 20 sets up a while loop, which will continue only as
long as three conditions are met:
small is not bigger than large.
large isn't negative.
small doesn't overrun the size of a small integer (MAXSMALL).
On line 23, the value in small is calculated modulo 5,000. This does not change the value in
small; however, it only returns the value 0 when small is an exact multiple of 5,000. Each time itis, a dot (.) is printed to the screen to show progress. On line 26, small is incremented, and on line
28, large is decremented by 2.
When any of the three conditions in the while loop fails, the loop ends and execution of the program
continues after the while loop's closing brace on line 29.
NOTE: The modulus operator (%) and compound conditions are covered on Day 3,
"Variables and Constants."
continue and break
At times you'll want to return to the top of a while loop before the entire set of statements in the
while loop is executed. The continue statement jumps back to the top of the loop.
At other times, you may want to exit the loop before the exit conditions are met. The break
statement immediately exits the while loop, and program execution resumes after the closing brace.
Listing 7.4 demonstrates the use of these statements. This time the game has become more
complicated. The user is invited to enter a small number and a large number, a skip number,
and a target number. The small number will be incremented by one, and the large number will
be decremented by 2. The decrement will be skipped each time the small number is a multiple of the
skip. The game ends if small becomes larger than large. If the large number reaches the
target exactly, a statement is printed and the game stops.
The user's goal is to put in a target number for the large number that will stop the game.
Listing 7.4. break and continue.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
// Listing 7.4
// Demonstrates break and continue
#include <iostream.h>
int main()
{
unsigned short small;
unsigned long large;
unsigned long skip;
unsigned long target;
const unsigned short MAXSMALL=65535;
cout << "Enter a small number: ";
cin >> small;
cout << "Enter a large number: ";17:
cin >> large;
18:
cout << "Enter a skip number: ";
19:
cin >> skip;
20:
cout << "Enter a target number: ";
21:
cin >> target;
22:
23:
cout << "\n";
24:
25:
// set up 3 stop conditions for the loop
26:
while (small < large && large > 0 && small < 65535)
27:
28:
{
29:
30:
small++;
31:
32:
if (small % skip == 0) // skip the decrement?
33:
{
34:
cout << "skipping on " << small << endl;
35:
continue;
36:
}
37:
38:
if (large == target)
// exact match for the target?
39:
{
40:
cout << "Target reached!";
41:
break;
42:
}
43:
44:
large-=2;
45:
}
// end of while loop
46:
47:
cout << "\nSmall: " << small << " Large: " << large <<
endl;
48:
return 0;
49: }
Output: Enter a small number: 2
Enter a large number: 20
Enter a skip number: 4
Enter a target number: 6
skipping on 4
skipping on 8
Small: 10 Large: 8
Analysis: In this play, the user lost; small became larger than large before the target number
of 6 was reached.
On line 26, the while conditions are tested. If small continues to be smaller than large, largeis larger than 0, and small hasn't overrun the maximum value for a small int, the body of the
while loop is entered.
On line 32, the small value is taken modulo the skip value. If small is a multiple of skip, the
continue statement is reached and program execution jumps to the top of the loop at line 26. This
effectively skips over the test for the target and the decrement of large.
On line 38, target is tested against the value for large. If they are the same, the user has won. A
message is printed and the break statement is reached. This causes an immediate break out of the
while loop, and program execution resumes on line 46.
NOTE: Both continue and break should be used with caution. They are the next
most dangerous commands after goto, for much the same reason. Programs that
suddenly change direction are harder to understand, and liberal use of continue and
break can render even a small while loop unreadable.
The continue Statement
continue; causes a while or for loop to begin again at the top of the loop. Example
if (value > 10)
goto end;
if (value < 10)
goto end;
cout << "value is 10!";
end:
cout << "done";
The break Statement
break; causes the immediate end of a while or for loop. Execution jumps to the closing brace.
Example
while (condition)
{
if (condition2)
break;
// statements;
}while (1) Loops
The condition tested in a while loop can be any valid C++ expression. As long as that condition
remains true, the while loop will continue. You can create a loop that will never end by using the
number 1 for the condition to be tested. Since 1 is always true, the loop will never end, unless a
break statement is reached. Listing 7.5 demonstrates counting to 10 using this construct.
Listing 7.5. while (1) loops.
1:
// Listing 7.5
2:
// Demonstrates a while true loop
3:
4:
#include <iostream.h>
5:
6:
int main()
7:
{
8:
int counter = 0;
9:
10:
while (1)
11:
{
12:
counter ++;
13:
if (counter > 10)
14:
break;
15:
}
16:
cout << "Counter: " << counter << "\n";
17:
return 0;
18:
Output: Counter: 11
Analysis: On line 10, a while loop is set up with a condition that can never be false. The loop
increments the counter variable on line 12 and then on line 13 tests to see whether counter has
gone past 10. If it hasn't, the while loop iterates. If counter is greater than 10, the break on line
14 ends the while loop, and program execution falls through to line 16, where the results are printed.
This program works, but it isn't pretty. This is a good example of using the wrong tool for the job. The
same thing can be accomplished by putting the test of counter's value where it belongs--in the
while condition.
WARNING: Eternal loops such as while (1) can cause your computer to hang if
the exit condition is never reached. Use these with caution and test them thoroughly.
C++ gives you many different ways to accomplish the same task. The real trick is picking the right
tool for the particular job.DON'T use the goto statement. DO use while loops to iterate while a condition is
true. DO exercise caution when using continue and break statements. DO make
sure your loop will eventually end.
do...while Loops
It is possible that the body of a while loop will never execute. The while statement checks its
condition before executing any of its statements, and if the condition evaluates false, the entire
body of the while loop is skipped. Listing 7.6 illustrates this.
Listing 7.6. Skipping the body of the while Loop .
1:
// Listing 7.6
2:
// Demonstrates skipping the body of
3:
// the while loop when the condition is false.
4:
5:
#include <iostream.h>
6:
7:
int main()
8:
{
9:
int counter;
10:
cout << "How many hellos?: ";
11:
cin >> counter;
12:
while (counter > 0)
13:
{
14:
cout << "Hello!\n";
15:
counter--;
16:
}
17:
cout << "Counter is OutPut: " << counter;
18:
return 0;
19: }
Output: How many hellos?: 2
Hello!
Hello!
Counter is OutPut: 0
How many hellos?: 0
Counter is OutPut: 0
Analysis: The user is prompted for a starting value on line 10. This starting value is stored in the
integer variable counter. The value of counter is tested on line 12, and decremented in the body
of the while loop. The first time through counter was set to 2, and so the body of the while loop
ran twice. The second time through, however, the user typed in 0. The value of counter was testedon line 12 and the condition was false; counter was not greater than 0. The entire body of the
while loop was skipped, and Hello was never printed.
What if you want to ensure that Hello is always printed at least once? The while loop can't
accomplish this, because the if condition is tested before any printing is done. You can force the
issue with an if statement just before entering the while:
if (counter < 1)
counter = 1;
// force a minimum value
but that is what programmers call a "kludge," an ugly and inelegant solution.
do...while
The do...while loop executes the body of the loop before its condition is tested and ensures that
the body always executes at least one time. Listing 7.7 rewrites Listing 7.6, this time using a
do...while loop.
Listing 7.7. Demonstrates do...while loop.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18: }
// Listing 7.7
// Demonstrates do while
#include <iostream.h>
int main()
{
int counter;
cout << "How many hellos? ";
cin >> counter;
do
{
cout << "Hello\n";
counter--;
} while (counter >0 );
cout << "Counter is: " << counter << endl;
return 0;
Output: How many hellos? 2
Hello
Hello
Counter is: 0
Analysis: The user is prompted for a starting value on line 9, which is stored in the integer variable
counter. In the do...while loop, the body of the loop is entered before the condition is tested,and therefore the body of the loop is guaranteed to run at least once. On line 13 the message is printed,
on line 14 the counter is decremented, and on line 15 the condition is tested. If the condition evaluates
TRUE, execution jumps to the top of the loop on line 13; otherwise, it falls through to line 16.
The continue and break statements work in the do...while loop exactly as they do in the
while loop. The only difference between a while loop and a do...while loop is when the
condition is tested.
The do...while Statement
The syntax for the do...while statement is as follows:
do
statement
while (condition);
statement is executed, and then condition is evaluated. If condition is TRUE, the loop is repeated;
otherwise, the loop ends. The statements and conditions are otherwise identical to the while loop.
Example 1
// count to 10
int x = 0;
do
cout << "X: " << x++;
while (x < 10)
Example 2
// print lowercase alphabet.
char ch = `a';
do
{
cout << ch << ` `;
ch++;
} while ( ch <= `z' );
DO use do...while when you want to ensure the loop is executed at least once. DO
use while loops when you want to skip the loop if the condition is false. DO test all
loops to make sure they do what you expect.
for Loops
When programming while loops, you'll often find yourself setting up a starting condition, testing tosee if the condition is true, and incrementing or otherwise changing a variable each time through the
loop. Listing 7.8 demonstrates this.
Listing 7.8. While reexamined .
1:
// Listing 7.8
2:
// Looping with while
3:
4:
#include <iostream.h>
5:
6:
int main()
7:
{
8:
int counter = 0;
9:
10:
while(counter < 5)
11:
{
12:
counter++;
13:
cout << "Looping! ";
14:
}
15:
16:
cout << "\nCounter: " << counter << ".\n";
17:
return 0;
18: }
Output: Looping! Looping! Looping! Looping! Looping!
Counter: 5.
Analysis: The condition is set on line 8: counter is initialized to 0. On line 10, counter is tested
to see whether it is less than 5. counter is incremented on line 12. On line 16, a simple message is
printed, but you can imagine that more important work could be done for each increment of the
counter.
A for loop combines three steps into one statement. The three steps are initialization, test, and
increment. A for statement consists of the keyword for followed by a pair of parentheses. Within
the parentheses are three statements separated by semicolons.
The first statement is the initialization. Any legal C++ statement can be put here, but typically this is
used to create and initialize a counting variable. Statement 2 is the test, and any legal C++ expression
can be used here. This serves the same role as the condition in the while loop. Statement 3 is the
action. Typically a value is incremented or decremented, though any legal C++ statement can be put
here. Note that statements 1 and 3 can be any legal C++ statement, but statement 2 must be an
expression--a C++ statement that returns a value. Listing 7.9 demonstrates a for loop.
Listing 7.9. Demonstrating the for loop.
1:
2:
// Listing 7.9
// Looping with for3:
4:
#include <iostream.h>
5:
6:
int main()
7:
{
8:
int counter;
9:
for (counter = 0; counter < 5; counter++)
10:
cout << "Looping! ";
11:
12:
cout << "\nCounter: " << counter << ".\n";
13:
return 0;
14: }
Output: Looping! Looping! Looping! Looping! Looping!
Counter: 5.
Analysis: The for statement on line 8 combines the initialization of counter, the test that
counter is less than 5, and the increment of counter all into one line. The body of the for
statement is on line 9. Of course, a block could be used here as well.
The for Statement
The syntax for the for statement is as follows:
for (initialization; test; action )
statement;
The initialization statement is used to initialize the state of a counter, or to otherwise prepare for
the loop. test is any C++ expression and is evaluated each time through the loop. If test is TRUE, the
action in the header is executed (typically the counter is incremented) and then the body of the for
loop is executed. Example 1
// print Hello ten times
for (int i = 0; i<10; i++)
cout << "Hello! ";
Example 2
for (int i = 0; i < 10; i++)
{
cout << "Hello!" << endl;
cout << "the value of i is: " << i << endl;
}
Advanced for Loopsfor statements are powerful and flexible. The three independent statements (initialization, test, and
action) lend themselves to a number of variations.
A for loop works in the following sequence:
1. Performs the operations in the initialization.
2. Evaluates the condition.
3. If the condition is TRUE, executes the action statement and the loop.
After each time through, the loop repeats steps 2 and 3. Multiple Initialization and Increments It is not
uncommon to initialize more than one variable, to test a compound logical expression, and to execute
more than one statement. The initialization and the action may be replaced by multiple C++
statements, each separated by a comma. Listing 7.10 demonstrates the initialization and increment of
two variables.
Listing 7.10. Demonstrating multiple statements in for loops.
1: //listing 7.10
2: // demonstrates multiple statements in
3: // for loops
4:
5: #include <iostream.h>
6:
7: int main()
8: {
9:
for (int i=0, j=0; i<3; i++, j++)
10:
cout << "i: " << i << " j: " << j << endl;
11:
return 0;
12: }
Output: i: 0
i: 1 j: 1
i: 2 j: 2
j: 0
Analysis: On line 9, two variables, i and j, are each initialized with the value 0. The test (i<3) is
evaluated, and because it is true, the body of the for statement is executed, and the values are
printed. Finally, the third clause in the for statement is executed, and i and j are incremented.
Once line 10 completes, the condition is evaluated again, and if it remains true the actions are
repeated (i and j are again incremented), and the body of loop is executed again. This continues until
the test fails, in which case the action statement is not executed, and control falls out of the loop. Null
Statements in for Loops Any or all of the statements in a for loop can be null. To accomplish this,
use the semicolon to mark where the statement would have been. To create a for loop that acts
exactly like a while loop, leave out the first and third statements. Listing 7.11 illustrates this idea.Listing 7.11. Null statements in for loops .
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18: }
// Listing 7.11
// For loops with null statements
#include <iostream.h>
int main()
{
int counter = 0;
for( ; counter < 5; )
{
counter++;
cout << "Looping! ";
}
cout << "\nCounter: " << counter << ".\n";
return 0;
output: Looping!
Counter: 5.
Looping!
Looping!
Looping!
Looping!
Analysis: You may recognize this as exactly like the while loop illustrated in Listing 7.8! On line 8,
the counter variable is initialized. The for statement on line 10 does not initialize any values, but it
does include a test for counter < 5. There is no increment statement, so this loop behaves exactly
as if it had been written:
while (counter < 5)
Once again, C++ gives you a number of ways to accomplish the same thing. No experienced C++
programmer would use a for loop in this way, but it does illustrate the flexibility of the for
statement. In fact, it is possible, using break and continue, to create a for loop with none of the
three statements. Listing 7.12 illustrates how.
Listing 7.12. Illustrating empty for loop statement.
1:
2:
3:
4:
5:
6:
//Listing 7.12 illustrating
//empty for loop statement
#include <iostream.h>
int main()7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23: }
{
int counter=0;
// initialization
int max;
cout << "How many hellos?";
cin >> max;
for (;;)
// a for loop that doesn't end
{
if (counter < max)
// test
{
cout << "Hello!\n";
counter++;
// increment
}
else
break;
}
return 0;
Output: How many hellos?3
Hello!
Hello!
Hello!
Analysis: The for loop has now been pushed to its absolute limit. Initialization, test, and action have
all been taken out of the for statement. The initialization is done on line 8, before the for loop
begins. The test is done in a separate if statement on line 14, and if the test succeeds, the action, an
increment to counter, is performed on line 17. If the test fails, breaking out of the loop occurs on
line 20.
While this particular program is somewhat absurd, there are times when a for(;;) loop or a while
(1) loop is just what you'll want. You'll see an example of a more reasonable use of such loops when
switch statements are discussed later today.
Empty for Loops
So much can be done in the header of a for statement, there are times you won't need the body to do
anything at all. In that case, be sure to put a null statement (;) as the body of the loop. The semicolon
can be on the same line as the header, but this is easy to overlook. Listing 7.13 illustrates how to use a
null body in a for loop.
Listing 7.13. Illustrates the null statement in a for loop.
1:
2:
3:
4:
//Listing 7.13
//Demonstrates null statement
// as body of for loop5:
6:
7:
8:
9:
10:
11: }
#include <iostream.h>
int main()
{
for (int i = 0; i<5; cout << "i: " << i++ << endl)
;
return 0;
Output: i: 0
i: 1
i: 2
i: 3
i: 4
Analysis: The for loop on line 8 includes three statements: the initialization statement establishes
the counter i and initializes it to 0. The condition statement tests for i<5, and the action statement
prints the value in i and increments it.
There is nothing left to do in the body of the for loop, so the null statement (;) is used. Note that this
is not a well-designed for loop: the action statement is doing far too much. This would be better
rewritten as
8:
9:
for (int i = 0; i<5; i++)
cout << "i: " << i << endl;
While both do exactly the same thing, this example is easier to understand.
Nested Loops
Loops may be nested, with one loop sitting in the body of another. The inner loop will be executed in
full for every execution of the outer loop. Listing 7.14 illustrates writing marks into a matrix using
nested for loops.
Listing 7.14. Illustrates nested for loops.
1:
2:
3:
4:
5:
6:
7:
8:
9:
//Listing 7.14
//Illustrates nested for loops
#include <iostream.h>
int main()
{
int rows, columns;
char theChar;10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23: }
cout << "How many rows? ";
cin >> rows;
cout << "How many columns? ";
cin >> columns;
cout << "What character? ";
cin >> theChar;
for (int i = 0; i<rows; i++)
{
for (int j = 0; j<columns; j++)
cout << theChar;
cout << "\n";
}
return 0;
Output: How many rows? 4
How many columns? 12
What character? x
xxxxxxxxxxxx
xxxxxxxxxxxx
xxxxxxxxxxxx
xxxxxxxxxxxx
Analysis: The user is prompted for the number of rows and columns and for a character to print.
The first for loop, on line 16, initializes a counter (i) to 0, and then the body of the outer for loop is
run.
On line 18, the first line of the body of the outer for loop, another for loop is established. A second
counter (j) is also initialized to 0, and the body of the inner for loop is executed. On line 19, the
chosen character is printed, and control returns to the header of the inner for loop. Note that the inner
for loop is only one statement (the printing of the character). The condition is tested (j <
columns) and if it evaluates true, j is incremented and the next character is printed. This
continues until j equals the number of columns.
Once the inner for loop fails its test, in this case after 12 Xs are printed, execution falls through to
line 20, and a new line is printed. The outer for loop now returns to its header, where its condition (i
< rows) is tested. If this evaluates true, i is incremented and the body of the loop is executed.
In the second iteration of the outer for loop, the inner for loop is started over. Thus, j is
reinitialized to 0 and the entire inner loop is run again.
The important idea here is that by using a nested loop, the inner loop is executed for each iteration of
the outer loop. Thus the character is printed columns times for each row.
NOTE: As an aside, many C++ programmers use the letters i and j as counting
variables. This tradition goes all the way back to FORTRAN, in which the letters i, j,k, l, m, and n were the only legal counting variables. Other programmers prefer to use
more descriptive counter variable names, such as Ctrl and Ctr2. Using i and j in
for loop headers should not cause much confusion, however.
Scoping in for Loops
You will remember that variables are scoped to the block in which they are created. That is, a local
variable is visible only within the block in which it is created. It is important to note that counting
variables created in the header of a for loop are scoped to the outer block, not the inner block. The
implication of this is that if you have two for loops in the same function, you must give them
different counter variables, or they may interfere with one another.
Summing Up Loops
On Day 5, "Functions," you learned how to solve the Fibonacci series problem using recursion. To
review briefly, a Fibonacci series starts with 1, 1, 2, 3, and all subsequent numbers are the sum of the
previous two:
1,1,2,3,5,8,13,21,34...
The nth Fibonacci number is the sum of the n-1 and the n-2 Fibonacci numbers. The problem solved
on Day 5 was finding the value of the nth Fibonacci number. This was done with recursion. Listing
7.15 offers a solution using iteration.
Listing 7.15. Solving the nth Fibonacci numberusing iteration.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
// Listing 7.15
// Demonstrates solving the nth
// Fibonacci number using iteration
#include <iostream.h>
typedef unsigned long int ULONG;
ULONG fib(ULONG position);
int main()
{
ULONG answer, position;
cout << "Which position? ";
cin >> position;
cout << "\n";
answer = fib(position);18:
cout << answer << " is the ";
19:
cout << position << "th Fibonacci number.\n";
20:
return 0;
21: }
22:
23: ULONG fib(ULONG n)
24: {
25:
ULONG minusTwo=1, minusOne=1, answer=2;
26:
27:
if (n < 3)
28:
return 1;
29:
30:
for (n -= 3; n; n--)
31:
{
32:
minusTwo = minusOne;
33:
minusOne = answer;
34:
answer = minusOne + minusTwo;
35:
}
36:
37:
return answer;
38: }
Output: Which position? 4
3 is the 4th Fibonacci number.
Which position? 5
5 is the 5th Fibonacci number.
Which position? 20
6765 is the 20th Fibonacci number.
Which position? 100
3314859971 is the 100th Fibonacci number.
Analysis: Listing 7.15 solves the Fibonacci series using iteration rather than recursion. This approach
is faster and uses less memory than the recursive solution.
On line 13, the user is asked for the position to check. The function fib() is called, which evaluates
the position. If the position is less than 3, the function returns the value 1. Starting with position 3, the
function iterates using the following algorithm:
1. Establish the starting position: Fill variable answer with 2, minusTwo with 0 (answer-2), and
minusOne with 1 (answer-1). Decrement the position by 3, because the first two numbers are
handled by the starting position.2. For every number, count up the Fibonacci series. This is done by
a. Putting the value currently in minusOne into minusTwo.
b. Putting the value currently in answer into minusOne.
c. Adding minusOne and minusTwo and putting the sum in answer.
d. Decrementing n.
3. When n reaches 0, return the answer.
This is exactly how you would solve this problem with pencil and paper. If you were asked for the
fifth Fibonacci number, you would write:
1, 1, 2,
and think, "two more to do." You would then add 2+1 and write 3, and think, "one more to find."
Finally you would write 3+2 and the answer would be 5. In effect, you are shifting your attention
right one number each time through, and decrementing the number remaining to be found.
Note the condition tested on line 30 (n). This is a C++ idiom, and is exactly equivalent to n != 0.
This for loop relies on the fact that when n reaches 0 it will evaluate false, because 0 is false in
C++. The for loop header could have been written:
for (n-=3; n>0; n++)
which might have been clearer. However, this idiom is so common in C++ that there is little sense in
fighting it.
Compile, link, and run this program, along with the recursive solution offered on Day 5. Try finding
position 25 and compare the time it takes each program. Recursion is elegant, but because the function
call brings a performance overhead, and because it is called so many times, its performance is
noticeably slower than iteration. Microcomputers tend to be optimized for the arithmetic operations,
so the iterative solution should be blazingly fast.
Be careful how large a number you enter. fib grows quickly, and long integers will overflow after a
while.
switch Statements
On Day 4, you saw how to write if and if/else statements. These can become quite confusing
when nested too deeply, and C++ offers an alternative. Unlike if, which evaluates one value,
switch statements allow you to branch on any of a number of different values. The general form of
the switch statement is:switch (expression)
{
case valueOne: statement;
break;
case valueTwo: statement;
break;
....
case valueN:
statement;
break;
default:
statement;
}
expression is any legal C++ expression, and the statements are any legal C++ statements or block of
statements. switch evaluates expression and compares the result to each of the case values.
Note, however, that the evaluation is only for equality; relational operators may not be used here, nor
can Boolean operations.
If one of the case values matches the expression, execution jumps to those statements and continues
to the end of the switch block, unless a break statement is encountered. If nothing matches,
execution branches to the optional default statement. If there is no default and there is no matching
value, execution falls through the switch statement and the statement ends.
NOTE: It is almost always a good idea to have a default case in switch
statements. If you have no other need for the default, use it to test for the supposedly
impossible case, and print out an error message; this can be a tremendous aid in
debugging.
It is important to note that if there is no break statement at the end of a case statement, execution
will fall through to the next case statement. This is sometimes necessary, but usually is an error. If
you decide to let execution fall through, be sure to put a comment, indicating that you didn't just
forget the break.
Listing 7.16 illustrates use of the switch statement.
Listing 7.16. Demonstrating the switch statement .
1:
2:
3:
4:
5:
6:
7:
//Listing 7.16
// Demonstrates switch statement
#include <iostream.h>
int main()
{8:
unsigned short int number;
9:
cout << "Enter a number between 1 and 5: ";
10:
cin >> number;
11:
switch (number)
12:
{
13:
case 0:
cout << "Too small, sorry!";
14:
break;
15:
case 5: cout << "Good job!\n"; // fall
16:
case 4: cout << "Nice Pick!\n"; // fall
17:
case 3: cout << "Excellent!\n"; // fall
18:
case 2: cout << "Masterful!\n"; // fall
19:
case 1: cout << "Incredible!\n";
20:
break;
21:
default: cout << "Too large!\n";
22:
break;
23:
}
24:
cout << "\n\n";
25:
return 0;
26: }
through
through
through
through
Output: Enter a number between 1 and 5: 3
Excellent!
Masterful!
Incredible!
Enter a number between 1 and 5: 8
Too large!
Analysis: The user is prompted for a number. That number is given to the switch statement. If the
number is 0, the case statement on line 13 matches, the message Too small, sorry! is printed,
and the break statement ends the switch. If the value is 5, execution switches to line 15 where a
message is printed, and then falls through to line 16, another message is printed, and so forth until
hitting the break on line 20.
The net effect of these statements is that for a number between 1 and 5, that many messages are
printed. If the value of number is not 0-5, it is assumed to be too large, and the default statement is
invoked on line 21.
The switch Statement
The syntax for the switch statement is as follows:
switch (expression)
{
case valueOne: statement;
case valueTwo: statement;
....case valueN: statement
default: statement;
}
The switch statement allows for branching on multiple values of expression. The expression is
evaluated, and if it matches any of the case values, execution jumps to that line. Execution continues
until either the end of the switch statement or a break statement is encountered. If expression does
not match any of the case statements, and if there is a default statement, execution switches to
the default statement, otherwise the switch statement ends. Example 1
switch (choice)
{
case 0:
cout << "Zero!" << endl;
break
case 1:
cout << "One!" << endl;
break;
case 2:
cout << "Two!" << endl;
default:
cout << "Default!" << endl;
}
Example 2
switch
{
choice
choice
choice
(choice)
0:
1:
2:
cout << "Less than 3!";
break;
choice 3:
cout << "Equals 3!";
break;
default:
cout << "greater than 3!";
}
Using a switch Statement with a Menu
Listing 7.17 returns to the for(;;) loop discussed earlier. These loops are also called forever loops,
as they will loop forever if a break is not encountered. The forever loop is used to put up a menu,
solicit a choice from the user, act on the choice, and then return to the menu. This will continue untilthe user chooses to exit.
NOTE: Some programmers like to write
#define EVER ;;
for (EVER)
{
// statements...
}
Using #define is covered on Day 17, "The Preprocessor."
New Term: A forever loop is a loop that does not have an exit condition. In order to exit the
loop, a break statement must be used. Forever loops are also known as eternal loops.
Listing 7.17. Demonstrating a forever loop.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
//Listing 7.17
//Using a forever loop to manage
//user interaction
#include <iostream.h>
// types & defines
enum BOOL { FALSE, TRUE };
typedef unsigned short int USHORT;
// prototypes
USHORT menu();
void DoTaskOne();
void DoTaskMany(USHORT);
int main()
{
BOOL exit = FALSE;
for (;;)
{
USHORT choice = menu();
switch(choice)
{
case (1):25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
}
}
DoTaskOne();
break;
case (2):
DoTaskMany(2);
break;
case (3):
DoTaskMany(3);
break;
case (4):
continue; // redundant!
break;
case (5):
exit=TRUE;
break;
default:
cout << "Please select again!\n";
break;
// end switch
if (exit)
break;
}
// end forever
return 0;
// end main()
USHORT menu()
{
USHORT choice;
cout << " **** Menu ****\n\n";
cout << "(1) Choice one.\n";
cout << "(2) Choice two.\n";
cout << "(3) Choice three.\n";
cout << "(4) Redisplay menu.\n";
cout << "(5) Quit.\n\n";
cout << ": ";
cin >> choice;
return choice;
}
void DoTaskOne()
{
cout << "Task One!\n";
}
void DoTaskMany(USHORT which)71:
72:
73:
74:
75:
76: }
{
if (which == 2)
cout << "Task Two!\n";
else
cout << "Task Three!\n";
Output: **** Menu ****
(1)
(2)
(3)
(4)
(5)
Choice one.
Choice two.
Choice three.
Redisplay menu.
Quit.
: 1
Task One!
**** Menu ****
(1) Choice one.
(2) Choice two.
(3) Choice three.
(4) Redisplay menu.
(5) Quit.
: 3
Task Three!
**** Menu ****
(1) Choice one.
(2) Choice two.
(3) Choice three.
(4) Redisplay menu.
(5) Quit.
: 5
Analysis: This program brings together a number of concepts from today and previous days. It also
shows a common use of the switch statement. On line 7, an enumeration, BOOL, is created, with
two possible values: FALSE, which equals 0, as it should, and TRUE, which equals 1. On line 8,
typedef is used to create an alias, USHORT, for unsigned short int.
The forever loop begins on 19. The menu() function is called, which prints the menu to the screen
and returns the user's selection. The switch statement, which begins on line 22 and ends on line 42,
switches on the user's choice.
If the user enters 1, execution jumps to the case 1: statement on line 24. Line 25 switches
execution to the DoTaskOne() function, which prints a message and returns. On its return,
execution resumes on line 26, where the break ends the switch statement, and execution falls
through to line 43. On line 44, the variable exit is evaluated. If it evaluates true, the break on line45 will be executed and the for(;;) loop will end, but if it evaluates false, execution resumes at
the top of the loop on line 19.
Note that the continue statement on line 34 is redundant. If it were left out and the break
statement were encountered, the switch would end, exit would evaluate FALSE, the loop would
reiterate, and the menu would be reprinted. The continue does, however, bypass the test of exit.
DO use switch statements to avoid deeply nested if statements. DON'T forget
break at the end of each case unless you wish to fall through. DO carefully
document all intentional fall-through cases. DO put a default case in switch
statements, if only to detect seemingly impossible situations.
Summary
There are different ways to cause a C++ program to loop. While loops check a condition, and if it is
true, execute the statements in the body of the loop. do...while loops execute the body of the loop
and then test the condition. for loops initialize a value, then test an expression. If an expression is
true, the final statement in the for header is executed, as is the body of the loop. Each subsequent
time through the loop the expression is tested again.
The goto statement is generally avoided, as it causes an unconditional jump to a seemingly arbitrary
location in the code, and thus makes source code difficult to understand and maintain. continue
causes while, do...while, and for loops to start over, and break causes while,
do...while, for, and switch statements to end.
Q&A
Q. How do you choose between if/else and switch?
A. If there are more than just one or two else clauses, and all are testing the same value,
consider using a switch statement.
Q. How do you choose between while and do...while?
A. If the body of the loop should always execute at least once, consider a do...while loop;
otherwise, try to use the while loop.
Q. How do you choose between while and for?
A If you are initializing a counting variable, testing that variable, and incrementing it each time
through the loop, consider the for loop. If your variable is already initialized and is not
incremented on each loop, a while loop may be the better choice.
Q. How do you choose between recursion and iteration?A. Some problems cry out for recursion, but most problems will yield to iteration as well. Put
recursion in your back pocket; it may come in handy someday.
Q. Is it better to use while (1) or for (;;)?
A. There is no significant difference.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material
covered, as well as exercises to provide you with experience in using what you've learned. Try to
answer the quiz and exercise questions before checking the answers in Appendix D, and make sure
you understand the answers before continuing to the next chapter.
Quiz
1. How do I initialize more than one variable in a for loop?
2. Why is goto avoided?
3. Is it possible to write a for loop with a body that is never executed?
4. Is it possible to nest while loops within for loops?
5. Is it possible to create a loop that never ends? Give an example.
6. What happens if you create a loop that never ends?
Exercises
1. What is the value of x when the for loop completes?
for (int x = 0; x < 100; x++)
2. Write a nested for loop that prints a 10x10 pattern of 0s.
3. Write a for statement to count from 100 to 200 by 2s.
4. Write a while loop to count from 100 to 200 by 2s.
5. Write a do...while loop to count from 100 to 200 by 2s.
6. BUG BUSTERS: What is wrong with this code?
int counter = 0
while (counter < 10){
cout << "counter: " << counter;
}
7. BUG BUSTERS: What is wrong with this code?
for (int counter = 0; counter < 10; counter++);
cout << counter << " ";
8. BUG BUSTERS: What is wrong with this code?
int counter = 100;
while (counter < 10)
{
cout << "counter now: " << counter;
counter--;
}
9. BUG BUSTERS: What is wrong with this code?
cout << "Enter a number
cin >> theNumber;
switch (theNumber)
{
case 0:
doZero();
case 1:
case 2:
case 3:
case 4:
case 5:
doOneToFive();
break;
default:
doDefault();
break;
}
between 0 and 5: ";
//
//
//
//
fall
fall
fall
fall
through
through
through
throughIn Review
Listing R1.1. Week 1 in Review listing.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
}
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
#include <iostream.h>
typedef unsigned short int USHORT;
typedef unsigned long int ULONG;
enum BOOL { FALSE, TRUE};
enum CHOICE { DrawRect = 1, GetArea,
GetPerim, ChangeDimensions, Quit};
// Rectangle class declaration
class Rectangle
{
public:
// constructors
Rectangle(USHORT width, USHORT height);
~Rectangle();
// accessors
USHORT GetHeight() const { return itsHeight; }
USHORT GetWidth() const { return itsWidth; }
ULONG GetArea() const { return itsHeight * itsWidth; }
ULONG GetPerim() const { return 2*itsHeight + 2*itsWidth;
void SetSize(USHORT newWidth, USHORT newHeight);
// Misc. methods
void DrawShape() const;
private:
USHORT itsWidth;
USHORT itsHeight;
};
// Class method implementations
void Rectangle::SetSize(USHORT newWidth, USHORT newHeight)
{
itsWidth = newWidth;
itsHeight = newHeight;
}37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
Rectangle::Rectangle(USHORT width, USHORT height)
{
itsWidth = width;
itsHeight = height;
}
Rectangle::~Rectangle() {}
USHORT DoMenu();
void DoDrawRect(Rectangle);
void DoGetArea(Rectangle);
void DoGetPerim(Rectangle);
void main ()
{
// initialize a rectangle to 10,20
Rectangle theRect(30,5);
USHORT choice = DrawRect;
USHORT fQuit = FALSE;
while (!fQuit)
{
choice = DoMenu();
if (choice < DrawRect || choice > Quit)
{
cout << "\nInvalid Choice, please try again.\n\n";
continue;
}
switch (choice)
{
case DrawRect:
DoDrawRect(theRect);
break;
case GetArea:
DoGetArea(theRect);
break;
case GetPerim:
DoGetPerim(theRect);
break;
case ChangeDimensions:
USHORT newLength, newWidth;
cout << "\nNew width: ";
cin >> newWidth;83:
cout << "New height: ";
84:
cin >> newLength;
85:
theRect.SetSize(newWidth, newLength);
86:
DoDrawRect(theRect);
87:
break;
88:
case Quit:
89:
fQuit = TRUE;
90:
cout << "\nExiting...\n\n";
91:
break;
92:
default:
93:
cout << "Error in choice!\n";
94:
fQuit = TRUE;
95:
break;
96:
}
// end switch
97:
}
// end while
98: }
// end main
99:
100:
101: USHORT DoMenu()
102: {
103:
USHORT choice;
104:
cout << "\n\n
*** Menu *** \n";
105:
cout << "(1) Draw Rectangle\n";
106:
cout << "(2) Area\n";
107:
cout << "(3) Perimeter\n";
108:
cout << "(4) Resize\n";
109:
cout << "(5) Quit\n";
110:
111: cin >> choice;
112: return choice;
113: }
114:
115: void DoDrawRect(Rectangle theRect)
116: {
117:
USHORT height = theRect.GetHeight();
118:
USHORT width = theRect.GetWidth();
119:
120:
for (USHORT i = 0; i<height; i++)
121:
{
122:
for (USHORT j = 0; j< width; j++)
123:
cout << "*";
124:
cout << "\n";
125:
}
126: }
127:
128:129: void DoGetArea(Rectangle theRect)
130: {
131:
cout << "Area: " << theRect.GetArea() << endl;
132: }
133:
134: void DoGetPerim(Rectangle theRect)
135: {
136:
cout << "Perimeter: " << theRect.GetPerim() << endl;
137: }
Output: *** Menu ***
(1) Draw Rectangle
(2) Area
(3) Perimeter
(4) Resize
(5) Quit
1
******************************
******************************
******************************
******************************
******************************
*** Menu ***
Draw Rectangle
Area
Perimeter
Resize
Quit
(1)
(2)
(3)
(4)
(5)
2
Area: 150
*** Menu ***
Draw Rectangle
Area
Perimeter
Resize
Quit
(1)
(2)
(3)
(4)
(5)
3
Perimeter: 70
(1)
(2)
(3)
(4)
(5)
4
*** Menu ***
Draw Rectangle
Area
Perimeter
Resize
QuitNew Width: 10
New height: 8
**********
**********
**********
**********
**********
**********
**********
**********
*** Menu ***
Draw Rectangle
Area
Perimeter
Resize
Quit
(1)
(2)
(3)
(4)
(5)
2
Area: 80
*** Menu ***
Draw Rectangle
Area
Perimeter
Resize
Quit
(1)
(2)
(3)
(4)
(5)
3
Perimeter: 36
(1)
(2)
(3)
(4)
(5)
5
*** Menu ***
Draw Rectangle
Area
Perimeter
Resize
Quit
Exiting...
Analysis: This program utilizes most of the skills you learned this week. You should not only be able
to enter, compile, link, and run this program, but also understand what it does and how it works, based
on the work you've done this week.
The first six lines set up the new types and definitions that will be used throughout the program.
Lines 9-29 declare the Rectangle class. There are public accessor methods for obtaining and setting
the width and height of the rectangle, as well as for computing the area and perimeter. Lines 32-43contain the class function definitions that were not declared inline.
The function prototypes, for the non-class member functions, are on lines 47-50, and the program
begins on line 52. The essence of this program is to generate a rectangle, and then to print out a menu
offering five options: Draw the rectangle, determine its area, determine its perimeter, resize the
rectangle, or quit.
A flag is set on line 58, and when that flag is not set to TRUE the menu loop continues. The flag is only
set to TRUE if the user picks Quit from the menu.
Each of the other choices, with the exception of ChangeDimensions, calls out to a function. This
makes the switch statement cleaner. ChangeDimensions cannot call out to a function because it
must change the dimensions of the rectangle. If the rectangle were passed (by value) to a function such
as DoChangeDimensions(), the dimensions would be changed on the local copy of the rectangle
in DoChangeDimensions() and not on the rectangle in main(). On Day 8, "Pointers," and Day
10, "Advanced Functions," you'll learn how to overcome this restriction, but for now the change is
made in the main() function.
Note how the use of an enumeration makes the switch statement much cleaner and easier to
understand. Had the switch depended on the numeric choices (1-5) of the user, you would have to
constantly refer to the description of the menu to see which pick was which.
On line 63, the user's choice is checked to make sure it is in range. If not, an error message is printed
and the menu is reprinted. Note that the switch statement includes an "impossible" default condition.
This is an aid in debugging. If the program is working, that statement can never be reached.
Week in Review
Congratulations! You've completed the first week! Now you can create and understand sophisticated
C++ programs. Of course, there's much more to do, and next week starts with one of the most difficult
concepts in C++: pointers. Don't give up now, you're about to delve deeply into the meaning and use of
object-oriented programming, virtual functions, and many of the advanced features of this powerful
language.
Take a break, bask in the glory of your accomplishment, and then turn the page to start Week
Pointers present two special challenges when learning C++: They can be somewhat confusing, and it isn't
immediately obvious why they are needed. This chapter explains how pointers work, step by step. You will
fully understand the need for pointers, however, only as the book progresses.
What Is a Pointer?
New Term: A pointer is a variable that holds a memory address.
To understand pointers, you must know a little about computer memory. Computer memory is divided into
sequentially numbered memory locations. Each variable is located at a unique location in memory, known as
its address. (This is discussed in the "Extra Credit" section following Day 5, "Functions.") Figure 8.1 shows a
schematic representation of the storage of an unsigned long integer variable theAge.
Figure 8.1. A schematic representation of theAge.
Different computers number this memory using different, complex schemes. Usually programmers don't need
to know the particular address of any given variable, because the compiler handles the details. If you want this
information, though, you can use the address of operator (&), which is illustrated in Listing 8.1.
Listing 8.1. Demonstrating address of variables.
1:
2:
3:
4:
5:
6:
7:
8:
// Listing 8.1 Demonstrates address of operator
// and addresses of local variables
#include <iostream.h>
int main()
{
unsigned short shortVar=5;9:
unsigned long longVar=65535;
10:
long sVar = -65535;
11:
12:
cout << "shortVar:\t" << shortVar;
13:
cout << " Address of shortVar:\t";
14:
cout << &shortVar _<< "\n";
15:
16:
cout << "longVar:\t" << longVar;
17:
cout << " Address of longVar:\t" ;
18:
cout << &longVar _<< "\n";
19:
20:
cout << "sVar:\t"
<< sVar;
21:
cout
<< " Address of sVar:\t" ;
22:
cout
<< &sVar
_<< "\n";
23:
24: return 0;
25: }
Output: shortVar: 5
Address of shortVar: 0x8fc9:fff4
longVar: 65535
Address of longVar: 0x8fc9:fff2
sVar:
-65535
Address of sVar:
0x8fc9:ffee
(Your printout may look different.)
Analysis: Three variables are declared and initialized: a short in line 8, an unsigned long in line 9, and
a long in line 10. Their values and addresses are printed in lines 12-16, by using the address of operator
(&).
The value of shortVar is 5, as expected, and its address is 0x8fc9:fff4 when run on my 80386-based
computer. This complicated address is computer-specific and may change slightly each time the program is
run. Your results will be different. What doesn't change, however, is that the difference in the first two
addresses is two bytes if your computer uses two-byte short integers. The difference between the second and
third is four bytes if your computer uses four-byte long integers. Figure 8.2 illustrates how the variables in
this program would be stored in memory.
Figure 8.2. Illustration of variable storage.
There is no reason why you need to know the actual numeric value of the address of each variable. What you
care about is that each one has an address and that the right amount of memory is set aside. You tell the
compiler how much memory to allow for your variables by declaring the variable type; the compiler
automatically assigns an address for it. For example, a long integer is typically four bytes, meaning that the
variable has an address to four bytes of memory.
Storing the Address in a Pointer
Every variable has an address. Even without knowing the specific address of a given variable, you can store
that address in a pointer.
For example, suppose that howOld is an integer. To declare a pointer called pAge to hold its address, you
would writeint *pAge = 0;
This declares pAge to be a pointer to int. That is, pAge is declared to hold the address of an int.
Note that pAge is a variable like any of the variables. When you declare an integer variable (type int), it is
set up to hold an integer. When you declare a pointer variable like pAge, it is set up to hold an address. pAge
is just a different type of variable.
In this example, pAge is initialized to zero. A pointer whose value is zero is called a null pointer. All pointers,
when they are created, should be initialized to something. If you don't know what you want to assign to the
pointer, assign 0. A pointer that is not initialized is called a wild pointer. Wild pointers are very dangerous.
NOTE: Practice safe computing: Initialize your pointers!
If you do initialize the pointer to 0, you must specifically assign the address of howOld to pAge. Here's an
example that shows how to do that:
unsigned short int howOld = 50;
unsigned short int * pAge = 0;
pAge = &howOld;
// make a variable
// make a pointer
// put howOld's address in pAge
The first line creates a variable--howOld, whose type is unsigned short int--and initializes it with the
value 50. The second line declares pAge to be a pointer to type unsigned short int and initializes it to
zero. You know that pAge is a pointer because of the asterisk (*) after the variable type and before the
variable name.
The third and final line assigns the address of howOld to the pointer pAge. You can tell that the address of
howOld is being assigned because of the address of operator (&). If the address of operator had not
been used, the value of howOld would have been assigned. That might, or might not, have been a valid
address.
At this point, pAge has as its value the address of howOld. howOld, in turn, has the value 50. You could
have accomplished this with one less step, as in
unsigned short int howOld = 50;
unsigned short int * pAge = &howOld;
// make a variable
// make pointer to howOld
pAge is a pointer that now contains the address of the howOld variable. Using pAge, you can actually
determine the value of howOld, which in this case is 50. Accessing howOld by using the pointer pAge is
called indirection because you are indirectly accessing howOld by means of pAge. Later today you will see
how to use indirection to access a variable's value.
New Term: Indirection means accessing the value at the address held by a pointer. The pointer provides
an indirect way to get the value held at that address.Pointer Names
Pointers can have any name that is legal for other variables. This book follows the convention of naming all
pointers with an initial p, as in pAge or pNumber.
The Indirection Operator
The indirection operator (*) is also called the dereference operator. When a pointer is dereferenced, the value
at the address stored by the pointer is retrieved.
Normal variables provide direct access to their own values. If you create a new variable of type unsigned
short int called yourAge, and you want to assign the value in howOld to that new variable, you would
write
unsigned short int yourAge;
yourAge = howOld;
A pointer provides indirect access to the value of the variable whose address it stores. To assign the value in
howOld to the new variable yourAge by way of the pointer pAge, you would write
unsigned short int yourAge;
yourAge = *pAge;
The indirection operator (*) in front of the variable pAge means "the value stored at." This assignment says,
"Take the value stored at the address in pAge and assign it to yourAge."
NOTE: The indirection operator (*) is used in two distinct ways with pointers: declaration and
dereference. When a pointer is declared, the star indicates that it is a pointer, not a normal
variable. For example,
unsigned short * pAge = 0; // make a pointer to an unsigned short
When the pointer is dereferenced, the indirection operator indicates that the value at the memory
location stored in the pointer is to be accessed, rather than the address itself.
*pAge = 5; // assign 5 to the value at pAge
Also note that this same character (*) is used as the multiplication operator. The compiler knows
which operator to call, based on context.
Pointers, Addresses, and Variables
It is important to distinguish between a pointer, the address that the pointer holds, and the value at the address
held by the pointer. This is the source of much of the confusion about pointers.Consider the following code fragment:
int theVariable = 5;
int * pPointer = &theVariable ;
theVariable is declared to be an integer variable initialized with the value 5. pPointer is declared to be
a pointer to an integer; it is initialized with the address of theVariable. pPointer is the pointer. The
address that pPointer holds is the address of theVariable. The value at the address that pPointer
holds is 5. Figure 8.3 shows a schematic representation of theVariable and pPointer.
Figure 8.3. A schematic representation of memory.
Manipulating Data by Using Pointers
Once a pointer is assigned the address of a variable, you can use that pointer to access the data in that variable.
Listing 8.2 demonstrates how the address of a local variable is assigned to a pointer and how the pointer
manipulates the values in that variable.
Listing 8.2. Manipulating data by using pointers.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
// Listing 8.2 Using pointers
#include <iostream.h>
typedef unsigned short int USHORT;
int main()
{
USHORT myAge;
// a variable
USHORT * pAge = 0;
// a pointer
myAge = 5;
cout << "myAge: " << myAge << "\n";
pAge = &myAge;
// assign address of myAge to pAge
cout << "*pAge: " << *pAge << "\n\n";
cout << "*pAge = 7\n";
*pAge = 7;
// sets myAge to 7
cout << "*pAge: " << *pAge << "\n";
cout << "myAge: " << myAge << "\n\n";
cout << "myAge = 9\n";
myAge = 9;
cout << "myAge: " << myAge << "\n";30:
31:
32:
33: }
cout << "*pAge: " << *pAge << "\n";
return 0;
Output: myAge: 5
*pAge: 5
*pAge = 7
*pAge: 7
myAge: 7
myAge = 9
myAge: 9
*pAge: 9
Analysis: This program declares two variables: an unsigned short, myAge, and a pointer to an
unsigned short, pAge. myAge is assigned the value 5 on line 10; this is verified by the printout in line
11.
On line 13, pAge is assigned the address of myAge. On line 15, pAge is dereferenced and printed, showing
that the value at the address that pAge stores is the 5 stored in myAge. In line 17, the value 7 is assigned to the
variable at the address stored in pAge. This sets myAge to 7, and the printouts in lines 21-22 confirm this.
In line 27, the value 9 is assigned to the variable myAge. This value is obtained directly in line 29 and
indirectly (by dereferencing pAge) in line 30.
Examining the Address
Pointers enable you to manipulate addresses without ever knowing their real value. After today, you'll take it
on faith that when you assign the address of a variable to a pointer, it really has the address of that variable as
its value. But just this once, why not check to make sure? Listing 8.3 illustrates this idea.
Listing 8.3. Finding out what is stored in pointers.
1:
// Listing 8.3 What is stored in a pointer.
2:
3:
#include <iostream.h>
4:
5:
typedef unsigned short int USHORT;
6:
int main()
7:
{
8:
unsigned short int myAge = 5, yourAge = 10;
9:
unsigned short int * pAge = &myAge; // a pointer
10:
11:
cout << "myAge:\t" << myAge << "\tyourAge:\t" << yourAge
<< "\n";
12:
cout << "&myAge:\t" << &myAge << "\t&yourAge:\t" <<
&yourAge <<"\n";
13:
14:
cout << "pAge:\t" << pAge << "\n";15:
cout << "*pAge:\t" << *pAge << "\n";
16:
17:
pAge = &yourAge;
// reassign the pointer
18:
19:
cout << "myAge:\t" << myAge << "\tyourAge:\t" << yourAge
<< "\n";
20:
cout << "&myAge:\t" << &myAge << "\t&yourAge:\t" <<
&yourAge <<"\n";
21:
22:
cout << "pAge:\t" << pAge << "\n";
23:
cout << "*pAge:\t" << *pAge << "\n";
24:
25:
cout << "&pAge:\t" << &pAge << "\n";
26:
return 0;
27: }
Output: myAge:
5
yourAge: 10
&myAge:
0x355C
&yourAge: 0x355E
pAge:
0x355C
*pAge:
5
myAge:
5
yourAge: 10
&myAge:
0x355C
&yourAge: 0x355E
pAge:
0x355E
*pAge:
10
&pAge:
0x355A
(Your output may look different.)
Analysis: In line 8, myAge and yourAge are declared to be variables of type unsigned short integer. In
line 9, pAge is declared to be a pointer to an unsigned short integer, and it is initialized with the address
of the variable myAge.
Lines 11 and 12 print the values and the addresses of myAge and yourAge. Line 14 prints the contents of
pAge, which is the address of myAge. Line 15 prints the result of dereferencing pAge, which prints the value
at pAge--the value in myAge, or 5.
This is the essence of pointers. Line 14 shows that pAge stores the address of myAge, and line 15 shows how
to get the value stored in myAge by dereferencing the pointer pAge. Make sure that you understand this fully
before you go on. Study the code and look at the output.
In line 17, pAge is reassigned to point to the address of yourAge. The values and addresses are printed again.
The output shows that pAge now has the address of the variable yourAge and that dereferencing obtains the
value in yourAge.
Line 25 prints the address of pAge itself. Like any variable, it has an address, and that address can be stored in
a pointer. (Assigning the address of a pointer to another pointer will be discussed shortly.)
DO use the indirection operator (*) to access the data stored at the address in a pointer. DO
initialize all pointers either to a valid address or to null (0). DO remember the difference
between the address in a pointer and the value at that address.Pointers
To declare a pointer, write the type of the variable or object whose address will be stored in the pointer,
followed by the pointer operator (*) and the name of the pointer. For example,
unsigned short int * pPointer = 0;
To assign or initialize a pointer, prepend the name of the variable whose address is being assigned with the
address of operator (&). For example,
unsigned short int theVariable = 5;
unsigned short int * pPointer = & theVariable;
To dereference a pointer, prepend the pointer name with the dereference operator (*). For example,
unsigned short int theValue = *pPointer
Why Would You Use Pointers?
So far you've seen step-by-step details of assigning a variable's address to a pointer. In practice, though, you
would never do this. After all, why bother with a pointer when you already have a variable with access to that
value? The only reason for this kind of pointer manipulation of an automatic variable is to demonstrate how
pointers work. Now that you are comfortable with the syntax of pointers, you can put them to good use.
Pointers are used, most often, for three tasks:
This rest of this chapter focuses on managing data on the free store and accessing class member data and
functions. Tomorrow you will learn about passing variables by reference.
The Stack and the Free Store
In the "Extra Credit" section following the discussion of functions in Day 5, five areas of memory are
mentioned:
Local variables are on the stack, along with function parameters. Code is in code space, of course, and global
variables are in global name space. The registers are used for internal housekeeping functions, such as keeping
track of the top of the stack and the instruction pointer. Just about all remaining memory is given over to the
free store, which is sometimes referred to as the heap.
The problem with local variables is that they don't persist: When the function returns, the local variables are
thrown away. Global variables solve that problem at the cost of unrestricted access throughout the program,
which leads to the creation of code that is difficult to understand and maintain. Putting data in the free store
solves both of these problems.
You can think of the free store as a massive section of memory in which thousands of sequentially numbered
cubbyholes lie waiting for your data. You can't label these cubbyholes, though, as you can with the stack. You
must ask for the address of the cubbyhole that you reserve and then stash that address away in a pointer.
One way to think about this is with an analogy: A friend gives you the 800 number for Acme Mail Order. You
go home and program your telephone with that number, and then you throw away the piece of paper with the
number on it. If you push the button, a telephone rings somewhere, and Acme Mail Order answers. You don't
remember the number, and you don't know where the other telephone is located, but the button gives you
access to Acme Mail Order. Acme Mail Order is your data on the free store. You don't know where it is, but
you know how to get to it. You access it by using its address--in this case, the telephone number. You don't
have to know that number; you just have to put it into a pointer (the button). The pointer gives you access to
your data without bothering you with the details.
The stack is cleaned automatically when a function returns. All the local variables go out of scope, and they are
removed from the stack. The free store is not cleaned until your program ends, and it is your responsibility to
free any memory that you've reserved when you are done with it.
The advantage to the free store is that the memory you reserve remains available until you explicitly free it. If
you reserve memory on the free store while in a function, the memory is still available when the function
returns.
The advantage of accessing memory in this way, rather than using global variables, is that only functions with
access to the pointer have access to the data. This provides a tightly controlled interface to that data, and it
eliminates the problem of one function changing that data in unexpected and unanticipated ways.
For this to work, you must be able to create a pointer to an area on the free store and to pass that pointer among
functions. The following sections describe how to do this.
new
You allocate memory on the free store in C++ by using the new keyword. new is followed by the type of the
object that you want to allocate so that the compiler knows how much memory is required. Therefore, new
unsigned short int allocates two bytes in the free store, and new long allocates four.
The return value from new is a memory address. It must be assigned to a pointer. To create an unsignedshort on the free store, you might write
unsigned short int * pPointer;
pPointer = new unsigned short int;
You can, of course, initialize the pointer at its creation with
unsigned short int * pPointer = new unsigned short int;
In either case, pPointer now points to an unsigned short int on the free store. You can use this like
any other pointer to a variable and assign a value into that area of memory by writing
*pPointer = 72;
This means, "Put 72 at the value in pPointer," or "Assign the value 72 to the area on the free store to which
pPointer points."
If new cannot create memory on the free store (memory is, after all, a limited resource) it returns the null
pointer. You must check your pointer for null each time you request new memory.
WARNING: Each time you allocate memory using the new keyword, you must check to make
sure the pointer is not null.
delete
When you are finished with your area of memory, you must call delete on the pointer. delete returns the
memory to the free store. Remember that the pointer itself--as opposed to the memory to which it points--is a
local variable. When the function in which it is declared returns, that pointer goes out of scope and is lost. The
memory allocated with new is not freed automatically, however. That memory becomes unavailable--a
situation called a memory leak. It's called a memory leak because that memory can't be recovered until the
program ends. It is as though the memory has leaked out of your computer.
To restore the memory to the free store, you use the keyword delete. For example,
delete pPointer;
When you delete the pointer, what you are really doing is freeing up the memory whose address is stored in the
pointer. You are saying, "Return to the free store the memory that this pointer points to." The pointer is still a
pointer, and it can be reassigned. Listing 8.4 demonstrates allocating a variable on the heap, using that variable,
and deleting it.
WARNING: When you call delete on a pointer, the memory it points to is freed. Calling
delete on that pointer again will crash your program! When you delete a pointer, set it to zero
(null). Calling delete on a null pointer is guaranteed to be safe. For example:
Animal *pDog = new Animal; delete pDog; //frees the memorypDog = 0; //sets pointer to null
//... delete pDog; //harmless
Listing 8.4. Allocating, using, and deleting pointers.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30: }
// Listing 8.4
// Allocating and deleting a pointer
#include <iostream.h>
int main()
{
int localVariable = 5;
int * pLocal= &localVariable;
int * pHeap = new int;
if (pHeap == NULL)
{
cout << "Error! No memory for pHeap!!";
return 0;
}
*pHeap = 7;
cout << "localVariable: " << localVariable << "\n";
cout << "*pLocal: " << *pLocal << "\n";
cout << "*pHeap: " << *pHeap << "\n";
delete pHeap;
pHeap = new int;
if (pHeap == NULL)
{
cout << "Error! No memory for pHeap!!";
return 0;
}
*pHeap = 9;
cout << "*pHeap: " << *pHeap << "\n";
delete pHeap;
return 0;
Output: localVariable: 5
*pLocal: 5
*pHeap: 7
*pHeap: 9
Analysis: Line 7 declares and initializes a local variable. Line 8 declares and initializes a pointer with the
address of the local variable. Line 9 declares another pointer but initializes it with the result obtained from
calling new int. This allocates space on the free store for an int. Line 10 verifies that memory was
allocated and the pointer is valid (not null). If no memory can be allocated, the pointer is null and an error
message is printed.
To keep things simple, this error checking often won't be reproduced in future programs, but you must include
some sort of error checking in your own programs.Line 15 assigns the value 7 to the newly allocated memory. Line 16 prints the value of the local variable, and
line 17 prints the value pointed to by pLocal. As expected, these are the same. Line 19 prints the value
pointed to by pHeap. It shows that the value assigned in line 15 is, in fact, accessible.
In line 19, the memory allocated in line 9 is returned to the free store by a call to delete. This frees the
memory and disassociates the pointer from that memory. pHeap is now free to point to other memory. It is
reassigned in lines 20 and 26, and line 27 prints the result. Line 28 restores that memory to the free store.
Although line 28 is redundant (the end of the program would have returned that memory) it is a good idea to
free this memory explicitly. If the program changes or is extended, it will be beneficial that this step was
already taken care of.
Memory Leaks
Another way you might inadvertently create a memory leak is by reassigning your pointer before deleting the
memory to which it points. Consider this code fragment:
1:
2:
3:
4:
unsigned short int * pPointer = new unsigned short int;
*pPointer = 72;
pPointer = new unsigned short int;
*pPointer = 84;
Line 1 creates pPointer and assigns it the address of an area on the free store. Line 2 stores the value 72 in
that area of memory. Line 3 reassigns pPointer to another area of memory. Line 4 places the value 84 in
that area. The original area--in which the value 72 is now held--is unavailable because the pointer to that area
of memory has been reassigned. There is no way to access that original area of memory, nor is there any way to
free it before the program ends.
The code should have been written like this:
1:
2:
3:
4:
5:
unsigned short int * pPointer = new unsigned short int;
*pPointer = 72;
delete pPointer;
pPointer = new unsigned short int;
*pPointer = 84;
Now the memory originally pointed to by pPointer is deleted, and thus freed, in line 3.
NOTE: For every time in your program that you call new, there should be a call to delete. It
is important to keep track of which pointer owns an area of memory and to ensure that the
memory is returned to the free store when you are done with it.
Creating Objects on the Free Store
Just as you can create a pointer to an integer, you can create a pointer to any object. If you have declared anobject of type Cat, you can declare a pointer to that class and instantiate a Cat object on the free store, just as
you can make one on the stack. The syntax is the same as for integers:
Cat *pCat = new Cat;
This calls the default constructor--the constructor that takes no parameters. The constructor is called whenever
an object is created (on the stack or on the free store).
Deleting Objects
When you call delete on a pointer to an object on the free store, that object's destructor is called before the
memory is released. This gives your class a chance to clean up, just as it does for objects destroyed on the
stack. Listing 8.5 illustrates creating and deleting objects on the free store.
Listing 8.5. Creating and deleting objects on the free store.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Listing 8.5
// Creating objects on the free store
#include <iostream.h>
class SimpleCat
{
public:
SimpleCat();
~SimpleCat();
private:
int itsAge;
};
SimpleCat::SimpleCat()
{
cout << "Constructor called.\n";
itsAge = 1;
}
SimpleCat::~SimpleCat()
{
cout << "Destructor called.\n";
}
int main()
{
cout << "SimpleCat Frisky...\n";
SimpleCat Frisky;
cout << "SimpleCat *pRags = new SimpleCat...\n";
SimpleCat * pRags = new SimpleCat;
cout << "delete pRags...\n";
delete pRags;34
35
36 }
cout << "Exiting, watch Frisky go...\n";
return 0;
Output: SimpleCat Frisky...
Constructor called.
SimpleCat *pRags = new SimpleCat..
Constructor called.
delete pRags...
Destructor called.
Exiting, watch Frisky go...
Destructor called.
Analysis: Lines 6-13 declare the stripped-down class SimpleCat. Line 9 declares SimpleCat's
constructor, and lines 15-19 contain its definition. Line 10 declares SimpleCat's destructor, and lines 21-24
contain its definition.
In line 29, Frisky is created on the stack, which causes the constructor to be called. In line 31, the
SimpleCat pointed to by pRags is created on the heap; the constructor is called again. In line 33, delete is
called on pRags, and the destructor is called. When the function ends, Frisky goes out of scope, and the
destructor is called.
Accessing Data Members
You accessed data members and functions by using the dot (.) operator for Cat objects created locally. To
access the Cat object on the free store, you must dereference the pointer and call the dot operator on the object
pointed to by the pointer. Therefore, to access the GetAge member function, you would write
(*pRags).GetAge();
Parentheses are used to assure that pRags is dereferenced before GetAge() is accessed.
Because this is cumbersome, C++ provides a shorthand operator for indirect access: the points-to operator
(->), which is created by typing the dash (-) immediately followed by the greater-than symbol (>). C++ treats
this as a single symbol. Listing 8.6 demonstrates accessing member variables and functions of objects created
on the free store.
Listing 8.6. Accessing member data of objects on the free store.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
// Listing 8.6
// Accessing data members of objects on the heap
#include <iostream.h>
class SimpleCat
{
public:
SimpleCat() {itsAge = 2; }
~SimpleCat() {}
int GetAge() const { return itsAge; }12:
void SetAge(int age)
13:
private:
14:
int itsAge;
15:
};
16:
17:
int main()
18:
{
19:
SimpleCat * Frisky
20:
cout << "Frisky is
years old\n";
21:
Frisky->SetAge(5);
22:
cout << "Frisky is
years old\n";
23:
delete Frisky;
24:
return 0;
25: }
{ itsAge = age; }
= new SimpleCat;
" << Frisky->GetAge() << "
" << Frisky->GetAge() << "
Output: Frisky is 2 years old
Frisky is 5 years old
Analysis: In line 19, a SimpleCat object is instantiated on the free store. The default constructor sets its age
to 2, and the GetAge() method is called in line 20. Because this is a pointer, the indirection operator (->) is
used to access the member data and functions. In line 21, the SetAge() method is called, and GetAge() is
accessed again in line 22.
Member Data on the Free Store
One or more of the data members of a class can be a pointer to an object on the free store. The memory can be
allocated in the class constructor or in one of its methods, and it can be deleted in its destructor, as Listing 8.7
illustrates.
Listing 8.7. Pointers as member data.
1: // Listing 8.7
2: // Pointers as data members
3:
4:
#include <iostream.h>
5:
6:
class SimpleCat
7:
{
8:
public:
9:
SimpleCat();
10:
~SimpleCat();
11:
int GetAge() const { return *itsAge; }
12:
void SetAge(int age) { *itsAge = age; }
13:
14:
int GetWeight() const { return *itsWeight; }
15:
void setWeight (int weight) { *itsWeight = weight; }
16:17:
private:
18:
int * itsAge;
19:
int * itsWeight;
20:
};
21:
22:
SimpleCat::SimpleCat()
23:
{
24:
itsAge = new int(2);
25:
itsWeight = new int(5);
26:
}
27:
28:
SimpleCat::~SimpleCat()
29:
{
30:
delete itsAge;
31:
delete itsWeight;
32:
}
33:
34:
int main()
35:
{
36:
SimpleCat *Frisky = new SimpleCat;
37:
cout << "Frisky is " << Frisky->GetAge() << "
years old\n";
38:
Frisky->SetAge(5);
39:
cout << "Frisky is " << Frisky->GetAge() << "
years old\n";
40:
delete Frisky;
41:
return 0;
42: }
Output: Frisky is 2 years old
Frisky is 5 years old
Analysis: The class SimpleCat is declared to have two member variables--both of which are pointers to
integers--on lines 14 and 15. The constructor (lines 22-26) initializes the pointers to memory on the free store
and to the default values.
The destructor (lines 28-32) cleans up the allocated memory. Because this is the destructor, there is no point in
assigning these pointers to null, as they will no longer be accessible. This is one of the safe places to break
the rule that deleted pointers should be assigned to null, although following the rule doesn't hurt.
The calling function (in this case, main()) is unaware that itsAge and itsWeight are point-ers to
memory on the free store. main() continues to call GetAge() and SetAge(), and the details of the
memory management are hidden in the implementation of the class--as they should be.
When Frisky is deleted in line 40, its destructor is called. The destructor deletes each of its member pointers.
If these, in turn, point to objects of other user-defined classes, their destructors are called as well.
The this Pointer
Every class member function has a hidden parameter: the this pointer. this points to the individual object.
Therefore, in each call to GetAge() or SetAge(), the this pointer for the object is included as a hiddenparameter.
It is possible to use the this pointer explicitly, as Listing 8.8 illustrates.
Listing 8.8. Using the this pointer.
1:
// Listing 8.8
2:
// Using the this pointer
3:
4:
#include <iostream.h>
5:
6:
class Rectangle
7:
{
8:
public:
9:
Rectangle();
10:
~Rectangle();
11:
void SetLength(int length) { this->itsLength =
length; }
12:
int GetLength() const { return this->itsLength; }
13:
14:
void SetWidth(int width) { itsWidth = width; }
15:
int GetWidth() const { return itsWidth; }
16:
17:
private:
18:
int itsLength;
19:
int itsWidth;
20:
};
21:
22:
Rectangle::Rectangle()
23:
{
24:
itsWidth = 5;
25:
itsLength = 10;
26:
}
27:
Rectangle::~Rectangle()
28:
{}
29:
30:
int main()
31:
{
32:
Rectangle theRect;
33:
cout << "theRect is " << theRect.GetLength() << "
feet long.\n";
34:
cout << "theRect is " << theRect.GetWidth() << " feet
wide.\n";
35:
theRect.SetLength(20);
36:
theRect.SetWidth(10);
37:
cout << "theRect is " << theRect.GetLength()<< " feet
long.\n";
38:
cout << "theRect is " << theRect.GetWidth()<< " feet
wide.\n";
39:
return 0;40: }
Output:
theRect
theRect
theRect
theRect is 10 feet long.
is 5 feet long.
is 20 feet long.
is 10 feet long.
Analysis: The SetLength() and GetLength() accessor functions explicitly use the this pointer to
access the member variables of the Rectangle object. The SetWidth and GetWidth accessors do not.
There is no difference in their behavior, although the syntax is easier to understand.
If that were all there was to the this pointer, there would be little point in bothering you with it. The this
pointer, however, is a pointer; it stores the memory address of an object. As such, it can be a powerful tool.
You'll see a practical use for the this pointer on Day 10, "Advanced Functions," when operator overloading
is discussed. For now, your goal is to know about the this pointer and to understand what it is: a pointer to
the object itself.
You don't have to worry about creating or deleting the this pointer. The compiler takes care of that.
Stray or Dangling Pointers
One source of bugs that are nasty and difficult to find is stray pointers. A stray pointer is created when you call
delete on a pointer--thereby freeing the memory that it points to--and later try to use that pointer again
without reassigning it.
It is as though the Acme Mail Order company moved away, and you still pressed the programmed button on
your phone. It is possible that nothing terrible happens--a telephone rings in a deserted warehouse. Perhaps the
telephone number has been reassigned to a munitions factory, and your call detonates an explosive and blows
up your whole city!
In short, be careful not to use a pointer after you have called delete on it. The pointer still points to the old
area of memory, but the compiler is free to put other data there; using the pointer can cause your program to
crash. Worse, your program might proceed merrily on its way and crash several minutes later. This is called a
time bomb, and it is no fun. To be safe, after you delete a pointer, set it to null (0). This disarms the pointer.
NOTE: Stray pointers are often called wild pointers or dangling pointers.
Listing 8.9 illustrates creating a stray pointer.
WARNING: This program intentionally creates a stray pointer. Do NOT run this program--it
will crash, if you are lucky.
Listing 8.9. Creating a stray pointer.
1:
// Listing 8.92:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23: }
// Demonstrates a stray pointer
typedef unsigned short int USHORT;
#include <iostream.h>
int main()
{
USHORT * pInt = new USHORT;
*pInt = 10;
cout << "*pInt: " << *pInt << endl;
delete pInt;
pInt = 0;
long * pLong = new long;
*pLong = 90000;
cout << "*pLong: " << *pLong << endl;
*pInt = 20;
// uh oh, this was deleted!
cout << "*pInt: " << *pInt << endl;
cout << "*pLong: " << *pLong << endl;
delete pLong;
return 0;
Output: *pInt:
10
*pLong: 90000
*pInt:
20
*pLong: 65556
Null pointer assignment
(Your output may look different.)
Analysis: Line 8 declares pInt to be a pointer to USHORT, and pInt is pointed to newly allocated memory.
Line 9 puts the value 10 in that memory, and line 10 prints its value. After the value is printed, delete is
called on the pointer. pInt is now a stray, or dangling, pointer.
Line 13 declares a new pointer, pLong, which is pointed at the memory allocated by new.
Line 14 assigns the value 90000 to pLong, and line 15 prints its value.
Line 17 assigns the value 20 to the memory that pInt points to, but pInt no longer points anywhere that is
valid. The memory that pInt points to was freed by the call to delete, so assigning a value to that memory
is certain disaster.
Line 19 prints the value at pInt. Sure enough, it is 20. Line 20 prints 20, the value at pLong; it has suddenly
been changed to 65556. Two questions arise:
1. How could pLong's value change, given that pLong wasn't touched?
2. Where did the 20 go when pInt was used in line 17?
As you might guess, these are related questions. When a value was placed at pInt in line 17, the compiler
happily placed the value 20 at the memory location that pInt previously pointed to. However, because thatmemory was freed in line 11, the compiler was free to reassign it. When pLong was created in line 13, it was
given pInt's old memory location. (On some computers this may not happen, depending on where in memory
these values are stored.) When the value 20 was assigned to the location that pInt previously pointed to, it
wrote over the value pointed to by pLong. This is called "stomping on a pointer." It is often the unfortunate
outcome of using a stray pointer.
This is a particularly nasty bug, because the value that changed wasn't associated with the stray pointer. The
change to the value at pLong was a side effect of the misuse of pInt. In a large program, this would be very
difficult to track down.
Just for fun, here are the details of how 65,556 got into that memory address:
1. pInt was pointed at a particular memory location, and the value 10 was assigned.
2. delete was called on pInt, which told the compiler that it could put something else at that
location. Then pLong was assigned the same memory location.
3. The value 90000 was assigned to *pLong. The particular computer used in this example stored the
four-byte value of 90,000 (00 01 5F 90) in byte-swapped order. Therefore, it was stored as 5F 90 00 01.
4. pInt was assigned the value 20--or 00 14 in hexadecimal notation. Because pInt still pointed to
the same address, the first two bytes of pLong were overwritten, leaving 00 14 00 01.
5. The value at pLong was printed, reversing the bytes back to their correct order of 00 01 00 14, which
was translated into the DOS value of 65556.
DO use new to create objects on the free store. DO use delete to destroy objects on the free store and
to return their memory. DON'T forget to balance all new statements with a delete statement. DON'T
forget to assign null (0) to all pointers that you call delete on. DO check the value returned by
new.
const Pointers
You can use the keyword const for pointers before the type, after the type, or in both places. For example, all
of the following are legal declarations:
const int * pOne;
int * const pTwo;
const int * const pThree;
pOne is a pointer to a constant integer. The value that is pointed to can't be changed.
pTwo is a constant pointer to an integer. The integer can be changed, but pTwo can't point to anything else.
pThree is a constant pointer to a constant integer. The value that is pointed to can't be changed, and pThree
can't be changed to point to anything else.
The trick to keeping this straight is to look to the right of the keyword const to find out what is being
declared constant. If the type is to the right of the keyword, it is the value that is constant. If the variable is tothe right of the keyword const, it is the pointer variable itself that is constant.
const int * p1;
int * const p2;
// the int pointed to is constant
// p2 is constant, it can't point to anything else
const Pointers and const Member Functions
On Day 6, "Basic Classes," you learned that you can apply the keyword const to a member function. When a
function is declared const, the compiler flags as an error any attempt to change data in the object from within
that function.
If you declare a pointer to a const object, the only methods that you can call with that pointer are const
methods. Listing 8.10 illustrates this.
Listing 8.10. Using pointers to const objects.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
// Listing 8.10
// Using pointers with const methods
#include <iostream.h>
class Rectangle
{
public:
Rectangle();
~Rectangle();
void SetLength(int length) { itsLength = length; }
int GetLength() const { return itsLength; }
void SetWidth(int width) { itsWidth = width; }
int GetWidth() const { return itsWidth; }
private:
int itsLength;
int itsWidth;
};
Rectangle::Rectangle():
itsWidth(5),
itsLength(10)
{}
Rectangle::~Rectangle()
{}
int main()
{
Rectangle* pRect = new Rectangle;
const Rectangle * pConstRect = new Rectangle;34:
Rectangle * const pConstPtr = new Rectangle;
35:
36:
cout << "pRect width: " << pRect->GetWidth() << "
feet\n";
37:
cout << "pConstRect width: " << pConstRect-
>GetWidth() << " feet\n";
38:
cout << "pConstPtr width: " << pConstPtr->GetWidth()
<< " feet\n";
39:
40:
pRect->SetWidth(10);
41:
// pConstRect->SetWidth(10);
42:
pConstPtr->SetWidth(10);
43:
44:
cout << "pRect width: " << pRect->GetWidth() << "
feet\n";
45:
cout << "pConstRect width: " << pConstRect-
>GetWidth() << " feet\n";
46:
cout << "pConstPtr width: " << pConstPtr->GetWidth()
<< " feet\n";
47:
return 0;
48: }
Output: pRect width: 5 feet
pConstRect width: 5 feet
pConstPtr width: 5 feet
pRect width: 10 feet
pConstRect width: 5 feet
pConstPtr width: 10 feet
Analysis: Lines 6-20 declare Rectangle. Line 15 declares the GetWidth() member method const. Line
32 declares a pointer to Rectangle. Line 33 declares pConstRect, which is a pointer to a constant
Rectangle. Line 34 declares pConstPtr, which is a constant pointer to Rectangle.
Lines 36-38 print their values.
In line 40, pRect is used to set the width of the rectangle to 10. In line 41, pConstRect would be used, but
it was declared to point to a constant Rectangle. Therefore, it cannot legally call a non-const member
function; it is commented out. In line 38, pConstPtr calls SetAge(). pConstPtr is declared to be a
constant pointer to a rectangle. In other words, the pointer is constant and cannot point to anything else, but the
rectangle is not constant.
const this Pointers
When you declare an object to be const, you are in effect declaring that the this pointer is a pointer to a
const object. A const this pointer can be used only with const mem- ber functions.
Constant objects and constant pointers will be discussed again tomorrow, when references to constant objects
are discussed.
DO protect objects passed by reference with const if they should not be changed. DO pass byreference when the object can be changed. DO pass by value when small objects should not be
changed.
Summary
Pointers provide a powerful way to access data by indirection. Every variable has an address, which can be
obtained using the address of operator (&). The address can be stored in a pointer.
Pointers are declared by writing the type of object that they point to, followed by the indirection operator (*)
and the name of the pointer. Pointers should be initialized to point to an object or to null (0).
You access the value at the address stored in a pointer by using the indirection operator (*). You can declare
const pointers, which can't be reassigned to point to other objects, and pointers to const objects, which
can't be used to change the objects to which they point.
To create new objects on the free store, you use the new keyword and assign the address that is returned to a
pointer. You free that memory by calling the delete keyword on the pointer. delete frees the memory, but
it doesn't destroy the pointer. Therefore, you must reassign the pointer after its memory has been freed.
Q&A
Q. Why are pointers so important?
A. Today you saw how pointers are used to hold the address of objects on the free store and how they
are used to pass arguments by reference. In addition, on Day 13, "Polymorphism," you'll see how
pointers are used in class polymorphism.
Q. Why should I bother to declare anything on the free store?
A. Objects on the free store persist after the return of a function. Additionally, the ability to store objects
on the free store enables you to decide at runtime how many objects you need, instead of having to
declare this in advance. This is explored in greater depth tomorrow.
Q. Why should I declare an object const if it limits what I can do with it?
A. As a programmer, you want to enlist the compiler in helping you find bugs. One serious bug that is
difficult to find is a function that changes an object in ways that aren't obvious to the calling function.
Declaring an object const prevents such changes.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material covered and
exercises to provide you with experience in using what you've learned. Try to answer the quiz and exercise
questions before checking the answers in Appendix D, and make sure you understand the answers before
continuing to the next chapter.
Quiz1. What operator is used to determine the address of a variable?
2. What operator is used to find the value stored at an address held in a pointer?
3. What is a pointer?
4. What is the difference between the address stored in a pointer and the value at that address?
5. What is the difference between the indirection operator and the address of operator?
6. What is the difference between const int * ptrOne and int * const ptrTwo?
Exercises
1. What do these declarations do?
a. int * pOne;
b. int vTwo;
c. int * pThree = &vTwo;
2. If you have an unsigned short variable named yourAge, how would you declare a pointer to
manipulate yourAge?
3. Assign the value 50 to the variable yourAge by using the pointer that you declared in Exercise 2.
4. Write a small program that declares an integer and a pointer to integer. Assign the address of the
integer to the pointer. Use the pointer to set a value in the integer variable.
5. BUG BUSTERS: What is wrong with this code?
#include <iostream.h>
int main()
{
int *pInt;
*pInt = 9;
cout << "The value at pInt: " << *pInt;
return 0;
}
6. BUG BUSTERS: What is wrong with this code?
int main()
{
int SomeVariable = 5;
cout << "SomeVariable: " << SomeVariable << "\n";
int *pVar = & SomeVariable;
pVar = 9;
cout << "SomeVariable: " << *pVar << "\n";
return 0;
}
What Is a Reference?
A reference is an alias; when you create a reference, you initialize it with the name of another object,
the target. From that moment on, the reference acts as an alternative name for the target, and anything
you do to the reference is really done to the target.
You create a reference by writing the type of the target object, followed by the reference operator (&),
followed by the name of the reference. References can use any legal variable name, but for this book
we'll prefix all reference names with "r." Thus, if you have an integer variable named someInt, you
can make a reference to that variable by writing the following:
int &rSomeRef = someInt;
This is read as "rSomeRef is a reference to an integer that is initialized to refer to someInt."
Listing 9.1 shows how references are created and used.NOTE: Note that the reference operator (&) is the same symbol as the one used for the
address of the operator. These are not the same operators, however, though clearly they
are related.
Listing 9.1. Creating and using references.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19: }
//Listing 9.1
// Demonstrating the use of References
#include <iostream.h>
int main()
{
int intOne;
int &rSomeRef = intOne;
intOne = 5;
cout << "intOne: " << intOne << endl;
cout << "rSomeRef: " << rSomeRef << endl;
rSomeRef = 7;
cout << "intOne: " << intOne << endl;
cout << "rSomeRef: " << rSomeRef << endl;
return 0;
Output: intOne: 5
rSomeRef: 5
intOne: 7
rSomeRef: 7
Anaylsis: On line 8, a local int variable, intOne, is declared. On line 9, a reference to an int,
rSomeRef, is declared and initialized to refer to intOne. If you declare a reference, but don't
initialize it, you will get a compile-time error. References must be initialized.
On line 11, intOne is assigned the value 5. On lines 12 and 13, the values in intOne and
rSomeRef are printed, and are, of course, the same.
On line 15, 7 is assigned to rSomeRef. Since this is a reference, it is an alias for intOne, and thus
the 7 is really assigned to intOne, as is shown by the printouts on lines 16 and 17.
Using the Address of Operator & on References
If you ask a reference for its address, it returns the address of its target. That is the nature of
references. They are aliases for the target. Listing 9.2 demonstrates this.Listing 9.2. Taking the address of a reference .
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19: }
//Listing 9.2
// Demonstrating the use of References
#include <iostream.h>
int main()
{
int intOne;
int &rSomeRef = intOne;
intOne = 5;
cout << "intOne: " << intOne << endl;
cout << "rSomeRef: " << rSomeRef << endl;
cout << "&intOne: " << &intOne << endl;
cout << "&rSomeRef: " << &rSomeRef << endl;
return 0;
Output: intOne: 5
rSomeRef: 5
&intOne: 0x3500
&rSomeRef: 0x3500
NOTE: Your output may differ on the last two lines.
Anaylsis: Once again rSomeRef is initialized as a reference to intOne. This time the
addresses of the two variables are printed, and they are identical. C++ gives you no way to access the
address of the reference itself because it is not meaningful, as it would be if you were using a pointer
or other variable. References are initialized when created, and always act as a synonym for their
target, even when the address of operator is applied.
For example, if you have a class called President, you might declare an instance of that class as
follows:
President
William_Jefferson_Clinton;
You might then declare a reference to President and initialize it with this object:President &Bill_Clinton = William_Jefferson_Clinton;
There is only one President; both identifiers refer to the same object of the same class. Any action
you take on Bill_Clinton will be taken on William_Jefferson_Clinton as well.
Be careful to distinguish between the & symbol on line 9 of Listing 9.2, which declares a reference to
int named rSomeRef, and the & symbols on lines 15 and 16, which return the addresses of the
integer variable intOne and the reference rSomeRef.
Normally, when you use a reference, you do not use the address of operator. You simply use the
reference as you would use the target variable. This is shown on line 13.
Even experienced C++ programmers, who know the rule that references cannot be reassigned and are
always aliases for their target, can be confused by what happens when you try to reassign a reference.
What appears to be a reassignment turns out to be the assignment of a new value to the target. Listing
9.3 illustrates this fact.
Listing 9.3. Assigning to a reference.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26: }
//Listing 9.3
//Reassigning a reference
#include <iostream.h>
int main()
{
int intOne;
int &rSomeRef = intOne;
intOne = 5;
cout << "intOne:\t" << intOne << endl;
cout << "rSomeRef:\t" << rSomeRef << endl;
cout << "&intOne:\t" << &intOne << endl;
cout << "&rSomeRef:\t" << &rSomeRef << endl;
int intTwo = 8;
rSomeRef = intTwo; // not what you think!
cout << "\nintOne:\t" << intOne << endl;
cout << "intTwo:\t" << intTwo << endl;
cout << "rSomeRef:\t" << rSomeRef << endl;
cout << "&intOne:\t" << &intOne << endl;
cout << "&intTwo:\t" << &intTwo << endl;
cout << "&rSomeRef:\t" << &rSomeRef << endl;
return 0;Output: intOne:
rSomeRef:
5
&intOne:
0x213e
&rSomeRef:
0x213e
intOne:
intTwo:
rSomeRef:
&intOne:
&intTwo:
&rSomeRef:
5
8
8
8
0x213e
0x2130
0x213e
Anaylsis: Once again, an integer variable and a reference to an integer are declared, on lines 8
and 9. The integer is assigned the value 5 on line 11, and the values and their addresses are printed on
lines 12-15.
On line 17, a new variable, intTwo, is created and initialized with the value 8. On line 18, the
programmer tries to reassign rSomeRef to now be an alias to the variable intTwo, but that is not
what happens. What actually happens is that rSomeRef continues to act as an alias for intOne, so
this assignment is exactly equivalent to the following:
intOne = intTwo;
Sure enough, when the values of intOne and rSomeRef are printed (lines 19-21) they are the same
as intTwo. In fact, when the addresses are printed on lines 22-24, you see that rSomeRef continues
to refer to intOne and not intTwo.
DO use references to create an alias to an object. DO initialize all references. DON'T
try to reassign a reference. DON'T confuse the address of operator with the reference
operator.
What Can Be Referenced?
Any object can be referenced, including user-defined objects. Note that you create a reference to an
object, but not to a class. You do not write this:
int & rIntRef = int;
// wrong
You must initialize rIntRef to a particular integer, such as this:
int howBig = 200;
int & rIntRef = howBig;In the same way, you don't initialize a reference to a CAT:
CAT & rCatRef = CAT;
// wrong
You must initialize rCatRef to a particular CAT object:
CAT frisky;
CAT & rCatRef = frisky;
References to objects are used just like the object itself. Member data and methods are accessed using
the normal class member access operator (.), and just as with the built-in types, the reference acts as
an alias to the object. Listing 9.4 illustrates this.
Listing 9.4. References to objects.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
// Listing 9.4
// References to class objects
#include <iostream.h>
class SimpleCat
{
public:
SimpleCat (int age, int weight);
~SimpleCat() {}
int GetAge() { return itsAge; }
int GetWeight() { return itsWeight; }
private:
int itsAge;
int itsWeight;
};
SimpleCat::SimpleCat(int age, int weight)
{
itsAge = age;
itsWeight = weight;
}
int main()
{
SimpleCat Frisky(5,8);
SimpleCat & rCat = Frisky;
cout << "Frisky is: ";
cout << Frisky.GetAge() << " years old. \n";31:
cout << "And Frisky weighs: ";
32:
cout << rCat.GetWeight() << " pounds. \n";
33:
return 0;
34: }
Output: Frisky is: 5 years old.
And Frisky weighs 8 pounds.
Anaylsis: On line 26, Frisky is declared to be a SimpleCat object. On line 27, a
SimpleCat reference, rCat, is declared and initialized to refer to Frisky. On lines 30 and 32, the
SimpleCat accessor methods are accessed by using first the SimpleCat object and then the
SimpleCat reference. Note that the access is identical. Again, the reference is an alias for the actual
object.
References
Declare a reference by writing the type, followed by the reference operator (&), followed by the
reference name. References must be initialized at the time of creation. Example 1
int hisAge;
int &rAge = hisAge;
Example 2
CAT boots;
CAT &rCatRef = boots;
Null Pointers and Null References
When pointers are not initialized, or when they are deleted, they ought to be assigned to null (0).
This is not true for references. In fact, a reference cannot be null, and a program with a reference to a
null object is considered an invalid program. When a program is invalid, just about anything can
happen. It can appear to work, or it can erase all the files on your disk. Both are possible outcomes of
an invalid program.
Most compilers will support a null object without much complaint, crashing only if you try to use the
object in some way. Taking advantage of this, however, is still not a good idea. When you move your
program to another machine or compiler, mysterious bugs may develop if you have null objects.
Passing Function Arguments by Reference
On Day 5, "Functions," you learned that functions have two limitations: Arguments are passed by
value, and the return statement can return only one value.Passing values to a function by reference can overcome both of these limitations. In C++, passing by
reference is accomplished in two ways: using pointers and using references. The syntax is different,
but the net effect is the same. Rather than a copy being created within the scope of the function, the
actual original object is passed into the function.
NOTE: If you read the extra credit section after Day 5, you learned that functions are
passed their parameters on the stack. When a function is passed a value by reference
(either using pointers or references), the address of the object is put on the stack, not the
entire object. In fact, on some computers the address is actually held in a register and
nothing is put on the stack. In either case, the compiler now knows how to get to the
original object, and changes are made there and not in a copy.
Passing an object by reference allows the function to change the object being referred to.
Recall that Listing 5.5 in Day 5 demonstrated that a call to the swap() function did not affect the
values in the calling function. Listing 5.5 is reproduced here as Listing 9.5, for your convenience.
Listing 9.5. Demonstrating passing by value.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
"\n";
12:
13:
"\n";
14:
15:
16:
17:
18:
19:
20:
21:
"\n";
//Listing 9.5 Demonstrates passing by value
#include <iostream.h>
void swap(int x, int y);
int main()
{
int x = 5, y = 10;
cout << "Main. Before swap, x: " << x << " y: " << y <<
swap(x,y);
cout << "Main. After swap, x: " << x << " y: " << y <<
return 0;
}
void swap (int x, int y)
{
int temp;
cout << "Swap. Before swap, x: " << x << " y: " << y <<22:
23:
24:
25:
26:
27:
"\n";
28:
29: }
temp = x;
x = y;
y = temp;
cout << "Swap. After swap, x: " << x << " y: " << y <<
Output: Main. Before swap, x: 5 y: 10
Swap. Before swap, x: 5 y: 10
Swap. After swap, x: 10 y: 5
Main. After swap, x: 5 y: 10
Anaylsis: This program initializes two variables in main() and then passes them to the
swap() function, which appears to swap them. When they are examined again in main(), they are
unchanged!
The problem here is that x and y are being passed to swap() by value. That is, local copies were
made in the function. What you want is to pass x and y by reference.
There are two ways to solve this problem in C++: You can make the parameters of swap() pointers
to the original values, or you can pass in references to the original values.
Making swap() Work with Pointers
When you pass in a pointer, you pass in the address of the object, and thus the function can
manipulate the value at that address. To make swap() change the actual values using pointers, the
function, swap(), should be declared to accept two int pointers. Then, by dereferencing the
pointers, the values of x and y will, in fact, be swapped. Listing 9.6 demonstrates this idea.
Listing 9.6. Passing by reference using pointers.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
"\n";
//Listing 9.6 Demonstrates passing by reference
#include <iostream.h>
void swap(int *x, int *y);
int main()
{
int x = 5, y = 10;
cout << "Main. Before swap, x: " << x << " y: " << y <<12:
swap(&x,&y);
13:
cout << "Main. After swap, x: " << x << " y: " << y <<
"\n";
14:
return 0;
15:
}
16
17:
void swap (int *px, int *py)
18:
{
19:
int temp;
20:
21:
cout << "Swap. Before swap, *px: " << *px << " *py: " <<
*py << "\n";
22:
23:
temp = *px;
24:
*px = *py;
25:
*py = temp;
26:
27:
cout << "Swap. After swap, *px: " << *px << " *py: " <<
*py << "\n";
28:
29: }
Output: Main. Before swap, x: 5 y: 10
Swap. Before swap, *px: 5 *py: 10
Swap. After swap, *px: 10 *py: 5
Main. After swap, x: 10 y: 5
Anaylsis: Success! On line 5, the prototype of swap() is changed to indicate that its two
parameters will be pointers to int rather than int variables. When swap() is called on line 12, the
addresses of x and y are passed as the arguments.
On line 19, a local variable, temp, is declared in the swap() function. Temp need not be a pointer;
it will just hold the value of *px (that is, the value of x in the calling function) for the life of the
function. After the function returns, temp will no longer be needed.
On line 23, temp is assigned the value at px. On line 24, the value at px is assigned to the value at
py. On line 25, the value stashed in temp (that is, the original value at px) is put into py.
The net effect of this is that the values in the calling function, whose address was passed to swap(),
are, in fact, swapped.
Implementing swap() with References
The preceding program works, but the syntax of the swap() function is cumbersome in two ways.
First, the repeated need to dereference the pointers within the swap() function makes it error-prone
and hard to read. Second, the need to pass the address of the variables in the calling function makes
the inner workings of swap() overly apparent to its users.It is a goal of C++ to prevent the user of a function from worrying about how it works. Passing by
pointers takes the burden off of the called function, and puts it where it belongs--on the calling
function. Listing 9.7 rewrites the swap() function, using references.
Listing 9.7. swap() rewritten with references.
1:
//Listing 9.7 Demonstrates passing by reference
2:
// using references!
3:
4:
#include <iostream.h>
5:
6:
void swap(int &x, int &y);
7:
8:
int main()
9:
{
10:
int x = 5, y = 10;
11:
12:
cout << "Main. Before swap, x: " << x << " y: " << y
<< "\n";
13:
swap(x,y);
14:
cout << "Main. After swap, x: " << x << " y: " << y
<< "\n";
15:
return 0;
16:
}
17:
18:
void swap (int &rx, int &ry)
19:
{
20:
int temp;
21:
22:
cout << "Swap. Before swap, rx: " << rx << " ry:
" << ry << "\n";
23:
24:
temp = rx;
25:
rx = ry;
26:
ry = temp;
27:
28:
cout << "Swap. After swap, rx: " << rx << " ry:
" << ry << "\n";
29:
30: }
Output: Main. Before swap, x:5 y: 10
Swap. Before swap, rx:5 ry:10
Swap. After swap, rx:10 ry:5
Main. After swap, x:10, y:5Anaylsis:Just as in the example with pointers, two variables are declared on line 10 and their
values are printed on line 12. On line 13, the function swap() is called, but note that x and y, not
their addresses, are passed. The calling function simply passes the variables.
When swap() is called, program execution jumps to line 18, where the variables are identified as
references. Their values are printed on line 22, but note that no special operators are required. These
are aliases for the original values, and can be used as such.
On lines 24-26, the values are swapped, and then they're printed on line 28. Program execution jumps
back to the calling function, and on line 14, the values are printed in main(). Because the parameters
to swap() are declared to be references, the values from main() are passed by reference, and thus
are changed in main() as well.
References provide the convenience and ease of use of normal variables, with the power and pass-by-
reference capability of pointers!
Understanding Function Headers and Prototypes
Listing 9.6 shows swap() using pointers, and Listing 9.7 shows it using references. Using the
function that takes references is easier, and the code is easier to read, but how does the calling
function know if the values are passed by reference or by value? As a client (or user) of swap(), the
programmer must ensure that swap() will, in fact, change the parameters.
This is another use for the function prototype. By examining the parameters declared in the prototype,
which is typically in a header file along with all the other prototypes, the programmer knows that the
values passed into swap() are passed by reference, and thus will be swapped properly.
If swap() had been a member function of a class, the class declaration, also available in a header
file, would have supplied this information.
In C++, clients of classes and functions rely on the header file to tell all that is needed; it acts as the
interface to the class or function. The actual implementation is hidden from the client. This allows the
programmer to focus on the problem at hand and to use the class or function without concern for how
it works.
When Colonel John Roebling designed the Brooklyn Bridge, he worried in detail about how the
concrete was poured and how the wire for the bridge was manufactured. He was intimately involved
in the mechanical and chemical processes required to create his materials. Today, however, engineers
make more efficient use of their time by using well-understood building materials, without regard to
how their manufacturer produced them.
It is the goal of C++ to allow programmers to rely on well-understood classes and functions without
regard to their internal workings. These "component parts" can be assembled to produce a program,
much the same way wires, pipes, clamps, and other parts are assembled to produce buildings and
bridges.In much the same way that an engineer examines the spec sheet for a pipe to determine its load-
bearing capacity, volume, fitting size, and so forth, a C++ programmer reads the interface of a
function or class to determine what services it provides, what parameters it takes, and what values it
returns.
Returning Multiple Values
As discussed, functions can only return one value. What if you need to get two values back from a
function? One way to solve this problem is to pass two objects into the function, by reference. The
function can then fill the objects with the correct values. Since passing by reference allows a function
to change the original objects, this effectively lets the function return two pieces of information. This
approach bypasses the return value of the function, which can then be reserved for reporting errors.
Once again, this can be done with references or pointers. Listing 9.8 demonstrates a function that
returns three values: two as pointer parameters and one as the return value of the function.
Listing 9.8. Returning values with pointers.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
//Listing 9.8
// Returning multiple values from a function
#include <iostream.h>
typedef unsigned short USHORT;
short Factor(USHORT, USHORT*, USHORT*);
int main()
{
USHORT number, squared, cubed;
short error;
cout << "Enter a number (0 - 20): ";
cin >> number;
error = Factor(number, &squared, &cubed);
if (!error)
{
cout << "number: " << number << "\n";
cout << "square: " << squared << "\n";
cout << "cubed: " << cubed
<< "\n";
}
else27:
cout << "Error encountered!!\n";
28:
return 0;
29:
}
30:
31:
short Factor(USHORT n, USHORT *pSquared, USHORT *pCubed)
32:
{
33:
short Value = 0;
34:
if (n > 20)
35:
Value = 1;
36:
else
37:
{
38:
*pSquared = n*n;
39:
*pCubed = n*n*n;
40:
Value = 0;
41:
}
42:
return Value;
43: }
Output: Enter a number (0-20): 3
number: 3
square: 9
cubed: 27
Anaylsis: On line 12, number, squared, and cubed are defined as USHORTs. number is
assigned a value based on user input. This number and the addresses of squared and cubed are
passed to the function Factor().
Factor()examines the first parameter, which is passed by value. If it is greater than 20 (the
maximum value this function can handle), it sets return Value to a simple error value. Note that
the return value from Function() is reserved for either this error value or the value 0, indicating
all went well, and note that the function returns this value on line 42.
The actual values needed, the square and cube of number, are returned not by using the return
mechanism, but rather by changing the pointers that were passed into the function.
On lines 38 and 39, the pointers are assigned their return values. On line 40, return Value is
assigned a success value. On line 41, return Value is returned.
One improvement to this program might be to declare the following:
enum ERROR_VALUE { SUCCESS, FAILURE};
Then, rather than returning 0 or 1, the program could return SUCCESS or FAILURE.
Returning Values by Reference
Although Listing 9.8 works, it can be made easier to read and maintain by using references rather thanpointers. Listing 9.9 shows the same program rewritten to use references and to incorporate the
ERROR enumeration.
Listing 9.9.Listing 9.8 rewritten using references.
1:
//Listing 9.9
2:
// Returning multiple values from a function
3:
// using references
4:
5:
#include <iostream.h>
6:
7:
typedef unsigned short USHORT;
8:
enum ERR_CODE { SUCCESS, ERROR };
9:
10:
ERR_CODE Factor(USHORT, USHORT&, USHORT&);
11:
12:
int main()
13:
{
14:
USHORT number, squared, cubed;
15:
ERR_CODE result;
16:
17:
cout << "Enter a number (0 - 20): ";
18:
cin >> number;
19:
20:
result = Factor(number, squared, cubed);
21:
22:
if (result == SUCCESS)
23:
{
24:
cout << "number: " << number << "\n";
25:
cout << "square: " << squared << "\n";
26:
cout << "cubed: " << cubed
<< "\n";
27:
}
28:
else
29:
cout << "Error encountered!!\n";
30:
return 0;
31:
}
32:
33:
ERR_CODE Factor(USHORT n, USHORT &rSquared, USHORT
&rCubed)
34:
{
35:
if (n > 20)
36:
return ERROR;
// simple error code
37:
else
38:
{
39:
rSquared = n*n;
40:
rCubed = n*n*n;41:
42:
43: }
return SUCCESS;
}
Output: Enter a number (0 - 20): 3
number: 3
square: 9
cubed: 27
Anaylsis: Listing 9.9 is identical to 9.8, with two exceptions. The ERR_CODE enumeration
makes the error reporting a bit more explicit on lines 36 and 41, as well as the error handling on line
22.
The larger change, however, is that Factor() is now declared to take references to squared and
cubed rather than to pointers. This makes the manipulation of these parameters far simpler and easier
to understand.
Passing by Reference for Efficiency
Each time you pass an object into a function by value, a copy of the object is made. Each time you
return an object from a function by value, another copy is made.
In the "Extra Credit" section at the end of Day 5, you learned that these objects are copied onto the
stack. Doing so takes time and memory. For small objects, such as the built-in integer values, this is a
trivial cost.
However, with larger, user-created objects, the cost is greater. The size of a user-created object on the
stack is the sum of each of its member variables. These, in turn, can each be user-created objects, and
passing such a massive structure by copying it onto the stack can be very expensive in performance
and memory consumption.
There is another cost as well. With the classes you create, each of these temporary copies is created
when the compiler calls a special constructor: the copy constructor. Tomorrow you will learn how
copy constructors work and how you can make your own, but for now it is enough to know that the
copy constructor is called each time a temporary copy of the object is put on the stack.
When the temporary object is destroyed, which happens when the function returns, the object's
destructor is called. If an object is returned by the function by value, a copy of that object must be
made and destroyed as well.
With large objects, these constructor and destructor calls can be expensive in speed and use of
memory. To illustrate this idea, Listing 9.9 creates a stripped-down user-created object: SimpleCat.
A real object would be larger and more expensive, but this is sufficient to show how often the copy
constructor and destructor are called.Listing 9.10 creates the SimpleCat object and then calls two functions. The first function receives
the Cat by value and then returns it by value. The second one receives a pointer to the object, rather
than the object itself, and returns a pointer to the object.
Listing 9.10. Passing objects by reference.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
//Listing 9.10
// Passing pointers to objects
#include <iostream.h>
class SimpleCat
{
public:
SimpleCat ();
SimpleCat(SimpleCat&);
~SimpleCat();
};
// constructor
// copy constructor
// destructor
SimpleCat::SimpleCat()
{
cout << "Simple Cat Constructor...\n";
}
SimpleCat::SimpleCat(SimpleCat&)
{
cout << "Simple Cat Copy Constructor...\n";
}
SimpleCat::~SimpleCat()
{
cout << "Simple Cat Destructor...\n";
}
SimpleCat FunctionOne (SimpleCat theCat);
SimpleCat* FunctionTwo (SimpleCat *theCat);
int main()
{
cout << "Making a cat...\n";
SimpleCat Frisky;
cout << "Calling FunctionOne...\n";
FunctionOne(Frisky);
cout << "Calling FunctionTwo...\n";
FunctionTwo(&Frisky);
return 0;41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55: }
}
// FunctionOne, passes by value
SimpleCat FunctionOne(SimpleCat theCat)
{
cout << "Function One. Returning...\n";
return theCat;
}
// functionTwo, passes by reference
SimpleCat* FunctionTwo (SimpleCat *theCat)
{
cout << "Function Two. Returning...\n";
return theCat;
Output: 1: Making a cat...
2: Simple Cat Constructor...
3: Calling FunctionOne...
4: Simple Cat Copy Constructor...
5: Function One. Returning...
6: Simple Cat Copy Constructor...
7: Simple Cat Destructor...
8: Simple Cat Destructor...
9: Calling FunctionTwo...
10: Function Two. Returning...
11: Simple Cat Destructor...
NOTE: Line numbers will not print. They were added to aid in the analysis.
Anaylsis: A very simplified SimpleCat class is declared on lines 6-12. The constructor, copy
constructor, and destructor all print an informative message so that you can tell when they've been
called.
On line 34, main() prints out a message, and that is seen on output line 1. On line 35, a
SimpleCat object is instantiated. This causes the constructor to be called, and the output from the
constructor is seen on output line 2.
On line 36, main() reports that it is calling FunctionOne, which creates output line 3. Because
FunctionOne() is called passing the SimpleCat object by value, a copy of the SimpleCat
object is made on the stack as an object local to the called function. This causes the copy constructor
to be called, which creates output line 4.
Program execution jumps to line 46 in the called function, which prints an informative message,
output line 5. The function then returns, and returns the SimpleCat object by value. This creates yetanother copy of the object, calling the copy constructor and producing line 6.
The return value from FunctionOne() is not assigned to any object, and so the temporary created
for the return is thrown away, calling the destructor, which produces output line 7. Since
FunctionOne() has ended, its local copy goes out of scope and is destroyed, calling the destructor
and producing line 8.
Program execution returns to main(), and FunctionTwo() is called, but the parameter is passed
by reference. No copy is produced, so there's no output. FunctionTwo() prints the message that
appears as output line 10 and then returns the SimpleCat object, again by reference, and so again
produces no calls to the constructor or destructor.
Finally, the program ends and Frisky goes out of scope, causing one final call to the destructor and
printing output line 11.
The net effect of this is that the call to FunctionOne(), because it passed the cat by value,
produced two calls to the copy constructor and two to the destructor, while the call to
FunctionTwo() produced none.
Passing a const Pointer
Although passing a pointer to FunctionTwo() is more efficient, it is dangerous.
FunctionTwo() is not allowed to change the SimpleCat object it is passed, yet it is given the
address of the SimpleCat. This seriously exposes the object to change and defeats the protection
offered in passing by value.
Passing by value is like giving a museum a photograph of your masterpiece instead of the real thing.
If vandals mark it up, there is no harm done to the original. Passing by reference is like sending your
home address to the museum and inviting guests to come over and look at the real thing.
The solution is to pass a const pointer to SimpleCat. Doing so prevents calling any non-const
method on SimpleCat, and thus protects the object from change. Listing 9.11 demonstrates this
idea.
Listing 9.11. Passing const pointers.
1:
2:
3:
4:
5:
6:
7:
8:
//Listing 9.11
// Passing pointers to objects
#include <iostream.h>
class SimpleCat
{
public:9:
SimpleCat();
10:
SimpleCat(SimpleCat&);
11:
~SimpleCat();
12:
13:
int GetAge() const { return itsAge; }
14:
void SetAge(int age) { itsAge = age; }
15:
16:
private:
17:
int itsAge;
18:
};
19:
20:
SimpleCat::SimpleCat()
21:
{
22:
cout << "Simple Cat Constructor...\n";
23:
itsAge = 1;
24:
}
25:
26:
SimpleCat::SimpleCat(SimpleCat&)
27:
{
28:
cout << "Simple Cat Copy Constructor...\n";
29:
}
30:
31:
SimpleCat::~SimpleCat()
32:
{
33:
cout << "Simple Cat Destructor...\n";
34:
}
35:
36:const SimpleCat * const FunctionTwo (const SimpleCat * const
theCat);
37:
38:
int main()
39:
{
40:
cout << "Making a cat...\n";
41:
SimpleCat Frisky;
42:
cout << "Frisky is " ;
43
cout << Frisky.GetAge();
44:
cout << " years _old\n";
45:
int age = 5;
46:
Frisky.SetAge(age);
47:
cout << "Frisky is " ;
48
cout << Frisky.GetAge();
49:
cout << " years _old\n";
50:
cout << "Calling FunctionTwo...\n";
51:
FunctionTwo(&Frisky);
52:
cout << "Frisky is " ;
53
cout << Frisky.GetAge();54:
cout << " years _old\n";
55:
return 0;
56:
}
57:
58:
// functionTwo, passes a const pointer
59:
const SimpleCat * const FunctionTwo (const SimpleCat * const
theCat)
60:
{
61:
cout << "Function Two. Returning...\n";
62:
cout << "Frisky is now " << theCat->GetAge();
63:
cout << " years old \n";
64:
// theCat->SetAge(8);
const!
65:
return theCat;
66: }
Output: Making a cat...
Simple Cat constructor...
Frisky is 1 years old
Frisky is 5 years old
Calling FunctionTwo...
FunctionTwo. Returning...
Frisky is now 5 years old
Frisky is 5 years old
Simple Cat Destructor...
Anaylsis: SimpleCat has added two accessor functions, GetAge() on line 13, which is a
const function, and SetAge() on line 14, which is not a const function. It has also added the
member variable itsAge on line 17.
The constructor, copy constructor, and destructor are still defined to print their messages. The copy
constructor is never called, however, because the object is passed by reference and so no copies are
made. On line 41, an object is created, and its default age is printed, starting on line 42.
On line 46, itsAge is set using the accessor SetAge, and the result is printed on line 47.
FunctionOne is not used in this program, but FunctionTwo() is called. FunctionTwo() has
changed slightly; the parameter and return value are now declared, on line 36, to take a constant
pointer to a constant object and to return a constant pointer to a constant object.
Because the parameter and return value are still passed by reference, no copies are made and the copy
constructor is not called. The pointer in FunctionTwo(), however, is now constant, and thus
cannot call the non-const method, SetAge(). If the call to SetAge() on line 64 was not
commented out, the program would not compile.
Note that the object created in main() is not constant, and Frisky can call SetAge(). The
address of this non-constant object is passed to FunctionTwo(), but because FunctionTwo()'s
declaration declares the pointer to be a constant pointer, the object is treated as if it were constant!References as an Alternative
Listing 9.11 solves the problem of making extra copies, and thus saves the calls to the copy
constructor and destructor. It uses constant pointers to constant objects, and thereby solves the
problem of the function changing the object. It is still somewhat cumbersome, however, because the
objects passed to the function are pointers.
Since you know the object will never be null, it would be easier to work with in the function if a
reference were passed in, rather than a pointer. Listing 9.12 illustrates this.
Listing 9.12. Passing references to objects.
1: //Listing 9.12
2: // Passing references to objects
3:
4:
#include <iostream.h>
5:
6:
class SimpleCat
7:
{
8:
public:
9:
SimpleCat();
10:
SimpleCat(SimpleCat&);
11:
~SimpleCat();
12:
13:
int GetAge() const { return itsAge; }
14:
void SetAge(int age) { itsAge = age; }
15:
16:
private:
17:
int itsAge;
18:
};
19:
20:
SimpleCat::SimpleCat()
21:
{
22:
cout << "Simple Cat Constructor...\n";
23:
itsAge = 1;
24:
}
25:
26:
SimpleCat::SimpleCat(SimpleCat&)
27:
{
28:
cout << "Simple Cat Copy Constructor...\n";
29:
}
30:
31:
SimpleCat::~SimpleCat()
32:
{
33:
cout << "Simple Cat Destructor...\n";34:
}
35:
36:
const
SimpleCat & FunctionTwo (const SimpleCat &
theCat);
37:
38:
int main()
39:
{
40:
cout << "Making a cat...\n";
41:
SimpleCat Frisky;
42:
cout << "Frisky is " << Frisky.GetAge() << " years
old\n";
43:
int age = 5;
44:
Frisky.SetAge(age);
45:
cout << "Frisky is " << Frisky.GetAge() << " years
old\n";
46:
cout << "Calling FunctionTwo...\n";
47:
FunctionTwo(Frisky);
48:
cout << "Frisky is " << Frisky.GetAge() << " years
old\n";
49:
return 0;
50:
}
51:
52:
// functionTwo, passes a ref to a const object
53:
const SimpleCat & FunctionTwo (const SimpleCat & theCat)
54:
{
55:
cout << "Function Two. Returning...\n";
56:
cout << "Frisky is now " <<
theCat.GetAge();
57:
cout << " years old \n";
58:
// theCat.SetAge(8);
const!
59:
return theCat;
60: }
Output: Making a cat...
Simple Cat constructor...
Frisky is 1 years old
Frisky is 5 years old
Calling FunctionTwo...
FunctionTwo. Returning...
Frisky is now 5 years old
Frisky is 5 years old
Simple Cat Destructor...
Analysis: The output is identical to that produced by Listing 9.11. The only significant change is
that FunctionTwo() now takes and returns a reference to a constant object. Once again, working
with references is somewhat simpler than working with pointers, and the same savings and efficiencyare achieved, as well as the safety provided by using const.
const References
C++ programmers do not usually differentiate between "constant reference to a SimpleCat object"
and "reference to a constant SimpleCat object." References themselves can never be reassigned to
refer to another object, and so are always constant. If the keyword const is applied to a reference, it
is to make the object referred to constant.
When to Use References and When to Use Pointers
C++ programmers strongly prefer references to pointers. References are cleaner and easier to use, and
they do a better job of hiding information, as we saw in the previous example.
References cannot be reassigned, however. If you need to point first to one object and then another,
you must use a pointer. References cannot be null, so if there is any chance that the object in question
may be null, you must not use a reference. You must use a pointer.
An example of the latter concern is the operator new. If new cannot allocate memory on the free
store, it returns a null pointer. Since a reference can't be null, you must not initialize a reference to this
memory until you've checked that it is not null. The following example shows how to handle this:
int *pInt = new int;
if (pInt != NULL)
int &rInt = *pInt;
In this example a pointer to int, pInt, is declared and initialized with the memory returned by the
operator new. The address in pInt is tested, and if it is not null, pInt is dereferenced. The result of
dereferencing an int variable is an int object, and rInt is initialized to refer to that object. Thus,
rInt becomes an alias to the int returned by the operator new.
DO pass parameters by reference whenever possible. DO return by reference whenever
possible. DON'T use pointers if references will work. DO use const to protect
references and pointers whenever possible. DON'T return a reference to a local object.
Mixing References and Pointers
It is perfectly legal to declare both pointers and references in the same function parameter list, along
with objects passed by value. Here's an example:
CAT * SomeFunction (Person &theOwner, House *theHouse, int age);This declaration says that SomeFunction takes three parameters. The first is a reference to a
Person object, the second is a pointer to a house object, and the third is an integer. It returns a
pointer to a CAT object.
NOTE: The question of where to put the reference (&) or indirection (*) operator when
declaring these variables is a great controversy. You may legally write any of the
following:
1:
2:
3:
CAT& rFrisky;
CAT & rFrisky;
CAT &rFrisky;
White space is completely ignored, so anywhere you see a space here you may put as many spaces,
tabs, and new lines as you like. Setting aside freedom of expression issues, which is best? Here are the
arguments for all three: The argument for case 1 is that rFrisky is a variable whose name is
rFrisky and whose type can be thought of as "reference to CAT object." Thus, this argument goes,
the & should be with the type. The counterargument is that the type is CAT. The & is part of the
"declarator," which includes the variable name and the ampersand. More important, having the & near
the CAT can lead to the following bug:
CAT&
rFrisky, rBoots;
Casual examination of this line would lead you to think that both rFrisky and rBoots are
references to CAT objects, but you'd be wrong. This really says that rFrisky is a reference to a CAT,
and rBoots (despite its name) is not a reference but a plain old CAT variable. This should be
rewritten as follows:
CAT
&rFrisky, rBoots;
The answer to this objection is that declarations of references and variables should never be combined
like this. Here's the right answer:
CAT& rFrisky;
CAT boots;
Finally, many programmers opt out of the argument and go with the middle position, that of putting
the & in the middle of the two, as illustrated in case 2. Of course, everything said so far about the
reference operator (&) applies equally well to the indirection operator (*). The important thing is to
recognize that reasonable people differ in their perceptions of the one true way. Choose a style that
works for you, and be consistent within any one program; clarity is, and remains, the goal. This book
will adopt two conventions when declaring references and pointers:
1. Put the ampersand and asterisk in the middle, with a space on either side.2. Never declare references, pointers, and variables all on the same line.
Dont Return a Reference to an Object that Isnt in Scope!
Once C++ programmers learn to pass by reference, they have a tendency to go hog-wild. It is possible,
however, to overdo it. Remember that a reference is always an alias to some other object. If you pass a
reference into or out of a function, be sure to ask yourself, "What is the object I'm aliasing, and will it
still exist every time it's used?"
Listing 9.13 illustrates the danger of returning a reference to an object that no longer exists.
Listing 9.13. Returning a reference to a non-existent object.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
// Listing 9.13
// Returning a reference to an object
// which no longer exists
#include <iostream.h>
class SimpleCat
{
public:
SimpleCat (int age, int weight);
~SimpleCat() {}
int GetAge() { return itsAge; }
int GetWeight() { return itsWeight; }
private:
int itsAge;
int itsWeight;
};
SimpleCat::SimpleCat(int age, int weight):
itsAge(age), itsWeight(weight) {}
SimpleCat &TheFunction();
int main()
{
SimpleCat &rCat = TheFunction();
int age = rCat.GetAge();
cout << "rCat is " << age << " years old!\n";
return 0;
}32:
SimpleCat &TheFunction()
33:
{
34:
SimpleCat Frisky(5,9);
35:
return Frisky;
36: }
Output: Compile error: Attempting to return a reference to a local
object!
WARNING: This program won't compile on the Borland compiler. It will compile on
Microsoft compilers; however, it should be noted that it is a bad coding practice.
Anaylsis: On lines 7-17, SimpleCat is declared. On line 26, a reference to a SimpleCat is
initialized with the results of calling TheFunction(), which is declared on line 22 to return a
reference to a SimpleCat.
The body of TheFunction() declares a local object of type SimpleCat and initializes its age
and weight. It then returns that local object by reference. Some compilers are smart enough to catch
this error and won't let you run the program. Others will let you run the program, with unpredictable
results.
When TheFunction() returns, the local object, Frisky, will be destroyed (painlessly, I assure
you). The reference returned by this function will be an alias to a non-existent object, and this is a bad
thing.
Returning a Reference to an Object on the Heap
You might be tempted to solve the problem in Listing 9.13 by having TheFunction() create
Frisky on the heap. That way, when you return from TheFunction(), Frisky will still exist.
The problem with this approach is: What do you do with the memory allocated for Frisky when you
are done with it? Listing 9.14 illustrates this problem.
Listing 9.14. Memory leaks.
1:
2:
3:
4:
5:
6:
7:
8:
9:
// Listing 9.14
// Resolving memory leaks
#include <iostream.h>
class SimpleCat
{
public:
SimpleCat (int age, int weight);
~SimpleCat() {}10:
11:
12:
13
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41: }
int GetAge() { return itsAge; }
int GetWeight() { return itsWeight; }
private:
int itsAge;
int itsWeight;
};
SimpleCat::SimpleCat(int age, int weight):
itsAge(age), itsWeight(weight) {}
SimpleCat & TheFunction();
int main()
{
SimpleCat & rCat = TheFunction();
int age = rCat.GetAge();
cout << "rCat is " << age << " years old!\n";
cout << "&rCat: " << &rCat << endl;
// How do you get rid of that memory?
SimpleCat * pCat = &rCat;
delete pCat;
// Uh oh, rCat now refers to ??
return 0;
}
SimpleCat &TheFunction()
{
SimpleCat * pFrisky = new SimpleCat(5,9);
cout << "pFrisky: " << pFrisky << endl;
return *pFrisky;
Output: pFrisky: 0x2bf4
rCat is 5 years old!
&rCat: 0x2bf4
WARNING: This compiles, links, and appears to work. But it is a time bomb waiting
to go off.
Anaylss: TheFunction() has been changed so that it no longer returns a reference to a local
variable. Memory is allocated on the free store and assigned to a pointer on line 38. The address that
pointer holds is printed, and then the pointer is dereferenced and the SimpleCat object is returned
by reference.On line 25, the return of TheFunction() is assigned to a reference to SimpleCat, and that
object is used to obtain the cat's age, which is printed on line 27.
To prove that the reference declared in main() is referring to the object put on the free store in
TheFunction(), the address of operator is applied to rCat. Sure enough, it displays the address
of the object it refers to and this matches the address of the object on the free store.
So far, so good. But how will that memory be freed? You can't call delete on the reference. One
clever solution is to create another pointer and initialize it with the address obtained from rCat. This
does delete the memory, and plugs the memory leak. One small problem, though: What is rCat
referring to after line 31? As stated earlier, a reference must always alias an actual object; if it
references a null object (as this does now), the program is invalid.
NOTE: It cannot be overemphasized that a program with a reference to a null object
may compile, but it is invalid and its performance is unpredictable.
There are actually three solutions to this problem. The first is to declare a SimpleCat object on line
25, and to return that cat from TheFunction by value. The second is to go ahead and declare the
SimpleCat on the free store in TheFunction(), but have TheFunction() return a pointer to
that memory. Then the calling function can delete the pointer when it is done.
The third workable solution, and the right one, is to declare the object in the calling function and then
to pass it to TheFunction() by reference.
Pointer, Pointer, Who Has the Pointer?
When your program allocates memory on the free store, a pointer is returned. It is imperative that you
keep a pointer to that memory, because once the pointer is lost, the memory cannot be deleted and
becomes a memory leak.
As you pass this block of memory between functions, someone will "own" the pointer. Typically the
value in the block will be passed using references, and the function that created the memory is the one
that deletes it. But this is a general rule, not an ironclad one.
It is dangerous for one function to create memory and another to free it, however. Ambiguity about
who owns the pointer can lead to one of two problems: forgetting to delete a pointer or deleting it
twice. Either one can cause serious problems in your program. It is safer to build your functions so
that they delete the memory they create.
If you are writing a function that needs to create memory and then pass it back to the calling function,
consider changing your interface. Have the calling function allocate the memory and then pass it into
your function by reference. This moves all memory management out of your program and back to the
function that is prepared to delete it.DO pass parameters by value when you must. DO return by value when you must.
DON'T pass by reference if the item referred to may go out of scope. DON'T use
references to null objects.
Summary
Today you learned what references are and how they compare to pointers. You saw that references
must be initialized to refer to an existing object, and cannot be reassigned to refer to anything else.
Any action taken on a reference is in fact taken on the reference's target object. Proof of this is that
taking the address of a reference returns the address of the target.
You saw that passing objects by reference can be more efficient than passing by value. Passing by
reference also allows the called function to change the value in the arguments back in the calling
function.
You saw that arguments to functions and values returned from functions can be passed by reference,
and that this can be implemented with pointers or with references.
You saw how to use const pointers and const references to safely pass values between functions
while achieving the efficiency of passing by reference.
Q&A
Q. Why have references if pointers can do everything references can?
A. References are easier to use and understand. The indirection is hidden, and there is no need
to repeatedly dereference the variable.
Q. Why have pointers if references are easier?
A. References cannot be null, and they cannot be reassigned. Pointers offer greater flexibility,
but are slightly more difficult to use.
Q. Why would you ever return by value from a function?
A. If the object being returned is local, you must return by value or you will be returning a
reference to a non-existent object.
Q. Given the danger in returning by reference, why not always return by value?
A. There is far greater efficiency in returning by reference. Memory is saved and the program
runs faster.Workshop
The Workshop contains quiz questions to help solidify your understanding of the material covered and
exercises to provide you with experience in using what you've learned. Try to answer the quiz and
exercise questions before checking the answers in Appendix D, and make sure you understand the
answers before going to the next chapter.
Quiz
1. What is the difference between a reference and a pointer?
2. When must you use a pointer rather than a reference?
3. What does new return if there is insufficient memory to make your new object?
4. What is a constant reference?
5. What is the difference between passing by reference and passing a reference?
Exercises
1. Write a program that declares an int, a reference to an int, and a pointer to an int. Use
the pointer and the reference to manipulate the value in the int.
2. Write a program that declares a constant pointer to a constant integer. Initialize the pointer
to an integer variable, varOne. Assign 6 to varOne. Use the pointer to assign 7 to varOne.
Create a second integer variable, varTwo. Reassign the pointer to varTwo.
3. Compile the program in Exercise 2. What produces errors? What produces warnings?
4. Write a program that produces a stray pointer.
5. Fix the program from Exercise 4.
6. Write a program that produces a memory leak.
7. Fix the program from Exercise 6.
8. BUG BUSTERS: What is wrong with this program?
1:
2:
3:
4:
5:
6:
7:
#include <iostream.h>
class CAT
{
public:
CAT(int age) { itsAge = age; }
~CAT(){}8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
int GetAge() const { return itsAge;}
private:
int itsAge;
};
CAT & MakeCat(int age);
int main()
{
int age = 7;
CAT Boots = MakeCat(age);
cout << "Boots is " << Boots.GetAge() << " years old\n";
}
CAT & MakeCat(int age)
{
CAT * pCat = new CAT(age);
return *pCat;
}
Overloaded Member Functions
On Day 5, you learned how to implement function polymorphism, or function overloading, by writing
two or more functions with the same name but with different parameters. Class member functions can
be overloaded as well, in much the same way.
The Rectangle class, demonstrated in Listing 10.1, has two DrawShape() functions. One, which
takes no parameters, draws the Rectangle based on the class's current values. The other takes two
values, width and length, and draws the rectangle based on those values, ignoring the current
class values.Listing 10.1. Overloading member functions.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
//Listing 10.1 Overloading class member functions
#include <iostream.h>
typedef unsigned short int USHORT;
enum BOOL { FALSE, TRUE};
// Rectangle class declaration
class Rectangle
{
public:
// constructors
Rectangle(USHORT width, USHORT height);
~Rectangle(){}
// overloaded class function DrawShape
void DrawShape() const;
void DrawShape(USHORT aWidth, USHORT aHeight) const;
private:
USHORT itsWidth;
USHORT itsHeight;
};
//Constructor implementation
Rectangle::Rectangle(USHORT width, USHORT height)
{
itsWidth = width;
itsHeight = height;
}
// Overloaded DrawShape - takes no values
// Draws based on current class member values
void Rectangle::DrawShape() const
{
DrawShape( itsWidth, itsHeight);
}
// overloaded DrawShape - takes two values
// draws shape based on the parameters
void Rectangle::DrawShape(USHORT width, USHORT height) const
{
for (USHORT i = 0; i<height; i++)45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64: }
{
for (USHORT j = 0; j< width; j++)
{
cout << "*";
}
cout << "\n";
}
}
// Driver program to demonstrate overloaded functions
int main()
{
// initialize a rectangle to 30,5
Rectangle theRect(30,5);
cout << "DrawShape(): \n";
theRect.DrawShape();
cout << "\nDrawShape(40,2): \n";
theRect.DrawShape(40,2);
return 0;
NOTE: This listing passes width and height values to several functions. You
should note that sometimes width is passed first and at other times height is passed
first.
Output: DrawShape():
Analysis: Listing 10.1 represents a stripped-down version of the Week in Review project from Week
1. The test for illegal values has been taken out to save room, as have some of the accessor functions.
The main program has been stripped down to a simple driver program, rather than a menu.
The important code, however, is on lines 16 and 17, where DrawShape() is overloaded. The
implementation for these overloaded class methods is on lines 32-52. Note that the version of
DrawShape() that takes no parameters simply calls the version that takes two parameters, passing
in the current member variables. Try very hard to avoid duplicating code in two functions. Otherwise,keeping them in sync when changes are made to one or the other will be difficult and error-prone.
The driver program, on lines 54-64, creates a rectangle object and then calls DrawShape(), first
passing in no parameters, and then passing in two unsigned short integers.
The compiler decides which method to call based on the number and type of parameters entered. One
can imagine a third overloaded function named DrawShape() that takes one dimension and an
enumeration for whether it is the width or height, at the user's choice.
Using Default Values
Just as non-class functions can have one or more default values, so can each member function of a
class. The same rules apply for declaring the default values, as illustrated in Listing 10.2.
Listing 10.2. Using default values.
1:
//Listing 10.2 Default values in member functions
2:
#include <iostream.h>
3:
4:
typedef unsigned short int USHORT;
5:
enum BOOL { FALSE, TRUE};
6:
7:
// Rectangle class declaration
8:
class Rectangle
9:
{
10:
public:
11:
// constructors
12:
Rectangle(USHORT width, USHORT height);
13:
~Rectangle(){}
14:
void DrawShape(USHORT aWidth, USHORT aHeight, BOOL
UseCurrentVals = %!
FALSE) const;
15:
16:
private:
17:
USHORT itsWidth;
18:
USHORT itsHeight;
19:
};
20:
21:
//Constructor implementation
22:
Rectangle::Rectangle(USHORT width, USHORT height):
23:
itsWidth(width),
// initializations
24:
itsHeight(height)
25:
{}
// empty body
26:
27:
28:
// default values used for third parameter29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
values
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70: }
void Rectangle::DrawShape(
USHORT width,
USHORT height,
BOOL UseCurrentValue
) const
{
int printWidth;
int printHeight;
if (UseCurrentValue == TRUE)
{
printWidth = itsWidth;
// use current class
printHeight = itsHeight;
}
else
{
printWidth = width;
printHeight = height;
}
// use parameter values
for (int i = 0; i<printHeight; i++)
{
for (int j = 0; j< printWidth; j++)
{
cout << "*";
}
cout << "\n";
}
}
// Driver program to demonstrate overloaded functions
int main()
{
// initialize a rectangle to 10,20
Rectangle theRect(30,5);
cout << "DrawShape(0,0,TRUE)...\n";
theRect.DrawShape(0,0,TRUE);
cout <<"DrawShape(40,2)...\n";
theRect.DrawShape(40,2);
return 0;
Output: DrawShape(0,0,TRUE)...
Analysis: Listing 10.2 replaces the overloaded DrawShape() function with a single function with
default parameters. The function is declared on line 14 to take three parameters. The first two,
aWidth and aHeight, are USHORTs, and the third, UseCurrentVals, is a BOOL (true or false)
that defaults to FALSE.
NOTE: Boolean values are those that evaluate to TRUE or FALSE. C++ considers 0 to
be false and all other values to be true.
The implementation for this somewhat awkward function begins on line 29. The third parameter,
UseCurrentValue, is evaluated. If it is TRUE, the member variables itsWidth and
itsHeight are used to set the local variables printWidth and printHeight, respectively.
If UseCurrentValue is FALSE, either because it has defaulted FALSE or was set by the user, the
first two parameters are used for setting printWidth and printHeight.
Note that if UseCurrentValue is TRUE, the values of the other two parameters are completely
ignored.
Choosing Between Default Values and Overloaded Functions
Listings 10.1 and 10.2 accomplish the same thing, but the overloaded functions in Listing 10.1 are
easier to understand and more natural to use. Also, if a third variation is needed--perhaps the user
wants to supply either the width or the height, but not both--it is easy to extend the overloaded
functions. The default value, however, will quickly become unusably complex as new variations are
added.
How do you decide whether to use function overloading or default values? Here's a rule of thumb:
Use function overloading when
There is no reasonable default value.
You need different algorithms.
You need to support variant types in your parameter list.
The Default Constructor
As discussed on Day 6, "Basic Classes," if you do not explicitly declare a constructor for your class, a
default constructor is created that takes no parameters and does nothing. You are free to make your
own default constructor, however, that takes no arguments but that "sets up" your object as required.
The constructor provided for you is called the "default" constructor, but by convention so is any
constructor that takes no parameters. This can be a bit confusing, but it is usually clear from context
which is meant.
Take note that if you make any constructors at all, the default constructor is not made by the compiler.
So if you want a constructor that takes no parameters and you've created any other constructors, you
must make the default constructor yourself!
Overloading Constructors
The point of a constructor is to establish the object; for example, the point of a Rectangle
constructor is to make a rectangle. Before the constructor runs, there is no rectangle, just an area of
memory. After the constructor finishes, there is a complete, ready-to-use rectangle object.
Constructors, like all member functions, can be overloaded. The ability to overload constructors is
very powerful and very flexible.
For example, you might have a rectangle object that has two constructors: The first takes a length
and a width and makes a rectangle of that size. The second takes no values and makes a default-sized
rectangle. Listing 10.3 implements this idea.
Listing 10.3. Overloading the constructor.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
// Listing 10.3
// Overloading constructors
#include <iostream.h>
class Rectangle
{
public:
Rectangle();
Rectangle(int width, int length);
~Rectangle() {}
int GetWidth() const { return itsWidth; }
int GetLength() const { return itsLength; }14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
endl;
36:
37:
38:
39:
40:
41:
42:
43:
44:
endl;
45:
endl;
46:
47: }
private:
int itsWidth;
int itsLength;
};
Rectangle::Rectangle()
{
itsWidth = 5;
itsLength = 10;
}
Rectangle::Rectangle (int width, int length)
{
itsWidth = width;
itsLength = length;
}
int main()
{
Rectangle Rect1;
cout << "Rect1 width: " << Rect1.GetWidth() << endl;
cout << "Rect1 length: " << Rect1.GetLength() <<
int aWidth, aLength;
cout << "Enter a width: ";
cin >> aWidth;
cout << "\nEnter a length: ";
cin >> aLength;
Rectangle Rect2(aWidth, aLength);
cout << "\nRect2 width: " << Rect2.GetWidth() <<
cout << "Rect2 length: " << Rect2.GetLength() <<
return 0;
Output: Rect1 width: 5
Rect1 length: 10
Enter a width: 20
Enter a length: 50
Rect2 width: 20
Rect2 length: 50Analysis: The Rectangle class is declared on lines 6-17. Two constructors are declared: the
"default constructor" on line 9 and a constructor taking two integer variables.
On line 33, a rectangle is created using the default constructor, and its values are printed on lines 34-
35. On lines 37-41, the user is prompted for a width and length, and the constructor taking two
parameters is called on line 43. Finally, the width and height for this rectangle are printed on lines 44-
45.
Just as it does any overloaded function, the compiler chooses the right constructor, based on the
number and type of the parameters.
Initializing Objects
Up to now, you've been setting the member variables of objects in the body of the constructor.
Constructors, however, are invoked in two stages: the initialization stage and the body.
Most variables can be set in either stage, either by initializing in the initialization stage or by assigning
in the body of the constructor. It is cleaner, and often more efficient, to initialize member variables at
the initialization stage. The following example shows how to initialize member variables:
CAT():
itsAge(5),
itsWeight(8)
{ }
// constructor name and parameters
// initialization list
// body of constructor
After the closing parentheses on the constructor's parameter list, write a colon. Then write the name of
the member variable and a pair of parentheses. Inside the parentheses, write the expression to be used
to initialize that member variable. If there is more than one initialization, separate each one with a
comma. Listing 10.4 shows the definition of the constructors from Listing 10.3, with initialization of
the member variables rather than assignment.
Listing 10.4. A code snippet showing initialization of member variables.
1:
Rectangle::Rectangle():
2:
itsWidth(5),
3:
itsLength(10)
4:
{
5:
};
6:
7:
Rectangle::Rectangle (int width, int length)
8:
itsWidth(width),
9:
itsLength(length)
10:
11: };Output: No output.
There are some variables that must be initialized and cannot be assigned to: references and constants.
It is common to have other assignments or action statements in the body of the constructor; however,
it is best to use initialization as much as possible.
The Copy Constructor
In addition to providing a default constructor and destructor, the compiler provides a default copy
constructor. The copy constructor is called every time a copy of an object is made.
When you pass an object by value, either into a function or as a function's return value, a temporary
copy of that object is made. If the object is a user-defined object, the class's copy constructor is called,
as you saw yesterday in Listing 9.6.
All copy constructors take one parameter, a reference to an object of the same class. It is a good idea
to make it a constant reference, because the constructor will not have to alter the object passed in. For
example:
CAT(const CAT & theCat);
Here the CAT constructor takes a constant reference to an existing CAT object. The goal of the copy
constructor is to make a copy of theCAT.
The default copy constructor simply copies each member variable from the object passed as a
parameter to the member variables of the new object. This is called a member-wise (or shallow) copy,
and although this is fine for most member variables, it breaks pretty quickly for member variables that
are pointers to objects on the free store.
New Term: A shallow or member-wise copy copies the exact values of one object's member
variables into another object. Pointers in both objects end up pointing to the same memory. A
deep copy copies the values allocated on the heap to newly allocated memory.
If the CAT class includes a member variable, itsAge, that points to an integer on the free
store, the default copy constructor will copy the passed-in CAT's itsAge member variable to
the new CAT's itsAge member variable. The two objects will now point to the same
memory, as illustrated in Figure 10.1.
Figure 10.1.Using the default copy constructor.
This will lead to a disaster when either CAT goes out of scope. As mentioned on Day 8, "Pointers," thejob of the destructor is to clean up this memory. If the original CAT's destructor frees this memory and
the new CAT is still pointing to the memory, a stray pointer has been created, and the program is in
mortal danger. Figure 10.2 illustrates this problem.
Figure 10.2. Creating a stray pointer.
The solution to this is to create your own copy constructor and to allocate the memory as required.
Once the memory is allocated, the old values can be copied into the new memory. This is called a
deep copy. Listing 10.5 illustrates how to do this.
Listing 10.5. Copy constructors.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
// Listing 10.5
// Copy constructors
#include <iostream.h>
class CAT
{
public:
CAT();
// default constructor
CAT (const CAT &);
// copy constructor
~CAT();
// destructor
int GetAge() const { return *itsAge; }
int GetWeight() const { return *itsWeight; }
void SetAge(int age) { *itsAge = age; }
private:
int *itsAge;
int *itsWeight;
};
CAT::CAT()
{
itsAge = new int;
itsWeight = new int;
*itsAge = 5;
*itsWeight = 9;
}
CAT::CAT(const CAT & rhs)
{
itsAge = new int;
itsWeight = new int;
*itsAge = rhs.GetAge();
*itsWeight = rhs.GetWeight();35: }
36:
37: CAT::~CAT()
38: {
39:
delete itsAge;
40:
itsAge = 0;
41:
delete itsWeight;
42:
itsWeight = 0;
43: }
44:
45: int main()
46: {
47:
CAT frisky;
48:
cout << "frisky's age: " << frisky.GetAge() << endl;
49:
cout << "Setting frisky to 6...\n";
50:
frisky.SetAge(6);
51:
cout << "Creating boots from frisky\n";
52:
CAT boots(frisky);
53:
cout << "frisky's age: " <<
frisky.GetAge() << endl;
54:
cout << "boots' age: " << boots.GetAge() << endl;
55:
cout << "setting frisky to 7...\n";
56:
frisky.SetAge(7);
57:
cout << "frisky's age: " <<
frisky.GetAge() << endl;
58:
cout << "boot's age: " << boots.GetAge() << endl;
59:
return 0;
60: }
Output: frisky's age: 5
Setting frisky to 6...
Creating boots from frisky
frisky's age: 6
boots' age: 6
setting frisky to 7...
frisky's age: 7
boots' age: 6
Analysis: On lines 6-19, the CAT class is declared. Note that on line 9 a default constructor is
declared, and on line 10 a copy constructor is declared.
On lines 17 and 18, two member variables are declared, each as a pointer to an integer. Typically
there'd be little reason for a class to store int member variables as pointers, but this was done to
illustrate how to manage member variables on the free store.
The default constructor, on lines 21-27, allocates room on the free store for two int variables and
then assigns values to them.
The copy constructor begins on line 29. Note that the parameter is rhs. It is common to refer to theparameter to a copy constructor as rhs, which stands for right-hand side. When you look at the
assignments in lines 33 and 34, you'll see that the object passed in as a parameter is on the right-hand
side of the equals sign. Here's how it works.
On lines 31 and 32, memory is allocated on the free store. Then, on lines 33 and 34, the value at the
new memory location is assigned the values from the existing CAT.
The parameter rhs is a CAT that is passed into the copy constructor as a constant reference. The
member function rhs.GetAge() returns the value stored in the memory pointed to by rhs's
member variable itsAge. As a CAT object, rhs has all the member variables of any other CAT.
When the copy constructor is called to create a new CAT, an existing CAT is passed in as a parameter.
The new CAT can refer to its own member variables directly; however, it must access rhs's member
variables using the public accessor methods.
Figure 10.3 diagrams what is happening here. The values pointed to by the existing CAT are copied to
the memory allocated for the new CAT
Figure 10.3. Deep copy illustrated.
On line 47, a CAT called frisky is created. frisky's age is printed, and then his age is set to 6 on
line 50. On line 52, a new CAT boots is created, using the copy constructor and passing in frisky.
Had frisky been passed as a parameter to a function, this same call to the copy constructor would
have been made by the compiler.
On lines 53 and 54, the ages of both CATs are printed. Sure enough, boots has frisky's age, 6, not
the default age of 5. On line 56, frisky's age is set to 7, and then the ages are printed again. This
time frisky's age is 7, but boots' age is still 6, demonstrating that they are stored in separate areas
of memory.
When the CATs fall out of scope, their destructors are automatically invoked. The implementation of
the CAT destructor is shown on lines 37-43. delete is called on both pointers, itsAge and
itsWeight, returning the allocated memory to the free store. Also, for safety, the pointers are
reassigned to NULL.
Operator Overloading
C++ has a number of built-in types, including int, real, char, and so forth. Each of these has a
number of built-in operators, such as addition (+) and multiplication (*). C++ enables you to add
these operators to your own classes as well.
In order to explore operator overloading fully, Listing 10.6 creates a new class, Counter. A
Counter object will be used in counting (surprise!) in loops and other applications where a number
must be incremented, decremented, or otherwise tracked.Listing 10.6. The Counter class.
1:
// Listing 10.6
2:
// The Counter class
3:
4:
typedef unsigned short USHORT;
5:
#include <iostream.h>
6:
7:
class Counter
8:
{
9:
public:
10:
Counter();
11:
~Counter(){}
12:
USHORT GetItsVal()const { return itsVal; }
13:
void SetItsVal(USHORT x) {itsVal = x; }
14:
15:
private:
16:
USHORT itsVal;
17:
18:
};
19:
20:
Counter::Counter():
21:
itsVal(0)
22:
{};
23:
24:
int main()
25:
{
26:
Counter i;
27:
cout << "The value of i is " << i.GetItsVal() << endl;
28:
return 0;
29: }
Output: The value of i is 0
Analysis: As it stands, this is a pretty useless class. It is defined on lines 7-18. Its only member
variable is a USHORT. The default constructor, which is declared on line 10 and whose
implementation is on line 20, initializes the one member variable, itsVal, to zero.
Unlike an honest, red-blooded USHORT, the Counter object cannot be incremented, decremented,
added, assigned, or otherwise manipulated. In exchange for this, it makes printing its value far more
difficult!
Writing an Increment Function
Operator overloading restores much of the functionality that has been stripped out of this class. For
example, there are two ways to add the ability to increment a Counter object. The first is to write anincrement method, as shown in Listing 10.7.
Listing 10.7. Adding an increment operator.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32: }
// Listing 10.7
// The Counter class
typedef unsigned short
#include <iostream.h>
USHORT;
class Counter
{
public:
Counter();
~Counter(){}
USHORT GetItsVal()const { return itsVal; }
void SetItsVal(USHORT x) {itsVal = x; }
void Increment() { ++itsVal; }
private:
USHORT itsVal;
};
Counter::Counter():
itsVal(0)
{};
int main()
{
Counter i;
cout << "The value of i is " << i.GetItsVal() << endl;
i.Increment();
cout << "The value of i is " << i.GetItsVal() << endl;
return 0;
Output: The value of i is 0
The value of i is 1
Analysis: Listing 10.7 adds an Increment function, defined on line 14. Although this works, it is
cumbersome to use. The program cries out for the ability to add a ++ operator, and of course this can
be done.
Overloading the Prefix OperatorPrefix operators can be overloaded by declaring functions with the form:
returnType Operator op (parameters)
Here, op is the operator to overload. Thus, the ++ operator can be overloaded with the following
syntax:
void operator++ ()
Listing 10.8 demonstrates this alternative.
Listing 10.8. Overloading operator++.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
// Listing 10.8
// The Counter class
typedef unsigned short
#include <iostream.h>
USHORT;
class Counter
{
public:
Counter();
~Counter(){}
USHORT GetItsVal()const { return itsVal; }
void SetItsVal(USHORT x) {itsVal = x; }
void Increment() { ++itsVal; }
void operator++ () { ++itsVal; }
private:
USHORT itsVal;
};
Counter::Counter():
itsVal(0)
{};
int main()
{
Counter i;
cout << "The value of i is " << i.GetItsVal() << endl;
i.Increment();
cout << "The value of i is " << i.GetItsVal() << endl;32:
++i;
33:
cout <<
34:
return 0;
35: }
Output: The value
The value of i is
The value of i is
"The value of i is " << i.GetItsVal() << endl;
of i is 0
1
2
Analysis: On line 15, operator++ is overloaded, and it's used on line 32. This is far closer to the
syntax one would expect with the Counter object. At this point, you might consider putting in the
extra abilities for which Counter was created in the first place, such as detecting when the
Counter overruns its maximum size.
There is a significant defect in the way the increment operator was written, however. If you want to
put the Counter on the right side of an assignment, it will fail. For example:
Counter a = ++i;
This code intends to create a new Counter, a, and then assign to it the value in i after i is
incremented. The built-in copy constructor will handle the assignment, but the current increment
operator does not return a Counter object. It returns void. You can't assign a void object to a
Counter object. (You can't make something from nothing!)
Returning Types in Overloaded Operator Functions
Clearly, what you want is to return a Counter object so that it can be assigned to another Counter
object. Which object should be returned? One approach would be to create a temporary object and
return that. Listing 10.9 illustrates this approach.
Listing 10.9. Returning a temporary object.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
// Listing 10.9
// operator++ returns a temporary object
typedef unsigned short
#include <iostream.h>
USHORT;
class Counter
{
public:
Counter();
~Counter(){}
USHORT GetItsVal()const { return itsVal; }
void SetItsVal(USHORT x) {itsVal = x; }
void Increment() { ++itsVal; }
Counter operator++ ();16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46: }
private:
USHORT itsVal;
};
Counter::Counter():
itsVal(0)
{};
Counter Counter::operator++()
{
++itsVal;
Counter temp;
temp.SetItsVal(itsVal);
return temp;
}
int main()
{
Counter i;
cout << "The value
i.Increment();
cout << "The value
++i;
cout << "The value
Counter a = ++i;
cout << "The value
cout << " and i: "
return 0;
Output: The value
The value of i is
The value of i is
The value of a: 3
of i is " << i.GetItsVal() << endl;
of i is " << i.GetItsVal() << endl;
of i is " << i.GetItsVal() << endl;
of a: " << a.GetItsVal();
<< i.GetItsVal() << endl;
of i is 0
1
2
and i: 3
Analysis: In this version, operator++ has been declared on line 15 to return a Counter object.
On line 29, a temporary variable, temp, is created and its value is set to match that in the current
object. That temporary variable is returned and immediately assigned to a on line 42.
Returning Nameless Temporaries
There is really no need to name the temporary object created on line 29. If Counter had a
constructor that took a value, you could simply return the result of that constructor as the return value
of the increment operator. Listing 10.10 illustrates this idea.Listing 10.10. Returning a nameless temporary object.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
// Listing 10.10
// operator++ returns a nameless temporary object
typedef unsigned short
#include <iostream.h>
USHORT;
class Counter
{
public:
Counter();
Counter(USHORT val);
~Counter(){}
USHORT GetItsVal()const { return itsVal; }
void SetItsVal(USHORT x) {itsVal = x; }
void Increment() { ++itsVal; }
Counter operator++ ();
private:
USHORT itsVal;
};
Counter::Counter():
itsVal(0)
{}
Counter::Counter(USHORT val):
itsVal(val)
{}
Counter Counter::operator++()
{
++itsVal;
return Counter (itsVal);
}
int main()
{
Counter i;
cout << "The value of i is " << i.GetItsVal() << endl;
i.Increment();
cout << "The value of i is " << i.GetItsVal() << endl;
++i;44:
45:
46:
47:
48:
49: }
cout <<
Counter
cout <<
cout <<
return 0;
Output: The value
The value of i is
The value of i is
The value of a: 3
"The value of i is " << i.GetItsVal() << endl;
a = ++i;
"The value of a: " << a.GetItsVal();
" and i: " << i.GetItsVal() << endl;
of i is 0
1
2
and i: 3
Analysis: On line 11, a new constructor is declared that takes a USHORT. The implementation is on
lines 27-29. It initializes itsVal with the passed-in value.
The implementation of operator++ is now simplified. On line 33, itsVal is incremented. Then
on line 34, a temporary Counter object is created, initialized to the value in itsVal, and then
returned as the result of the operator++.
This is more elegant, but begs the question, "Why create a temporary object at all?" Remember that
each temporary object must be constructed and later destroyed--each one potentially an expensive
operation. Also, the object i already exists and already has the right value, so why not return it? We'll
solve this problem by using the this pointer.
Using the this Pointer
The this pointer, as discussed yesterday, was passed to the operator++ member function as to all
member functions. The this pointer points to i, and if it's dereferenced it will return the object i,
which already has the right value in its member variable itsVal. Listing 10.11 illustrates returning
the dereferenced this pointer and avoiding the creation of an unneeded temporary object.
Listing 10.11. Returning the this pointer.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
// Listing 10.11
// Returning the dereferenced this pointer
typedef unsigned short
#include <iostream.h>
USHORT;
class Counter
{
public:
Counter();
~Counter(){}
USHORT GetItsVal()const { return itsVal; }
void SetItsVal(USHORT x) {itsVal = x; }14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
48:
49: }
void Increment() { ++itsVal; }
const Counter& operator++ ();
private:
USHORT itsVal;
};
Counter::Counter():
itsVal(0)
{};
const Counter& Counter::operator++()
{
++itsVal;
return *this;
}
int main()
{
Counter i;
cout << "The value
i.Increment();
cout << "The value
++i;
cout << "The value
Counter a = ++i;
cout << "The value
cout << " and i: "
return 0;
Output: The value
The value of i is
The value of i is
The value of a: 3
of i is " << i.GetItsVal() << endl;
of i is " << i.GetItsVal() << endl;
of i is " << i.GetItsVal() << endl;
of a: " << a.GetItsVal();
<< i.GetItsVal() << endl;
of i is 0
1
2
and i: 3
Analysis: The implementation of operator++, on lines 26-30, has been changed to dereference the
this pointer and to return the current object. This provides a Counter object to be assigned to a.
As discussed above, if the Counter object allocated memory, it would be important to override the
copy constructor. In this case, the default copy constructor works fine.
Note that the value returned is a Counter reference, thereby avoiding the creation of an extra
temporary object. It is a const reference because the value should not be changed by the function
using this Counter.Overloading the Postfix Operator
So far you've overloaded the prefix operator. What if you want to overload the postfix increment
operator? Here the compiler has a problem: How is it to differentiate between prefix and postfix? By
convention, an integer variable is supplied as a parameter to the operator declaration. The parameter's
value is ignored; it is just a signal that this is the postfix operator.
Difference Between Prefix and Postfix
Before we can write the postfix operator, we must understand how it is different from the prefix
operator. We reviewed this in detail on Day 4, "Expressions and Statements" (see Listing 4.3).
To review, prefix says "increment, and then fetch," while postfix says "fetch, and then increment."
Thus, while the prefix operator can simply increment the value and then return the object itself, the
postfix must return the value that existed before it was incremented. To do this, we must create a
temporary object that will hold the original value, then increment the value of the original object, and
then return the temporary.
Let's go over that again. Consider the following line of code:
a = x++;
If x was 5, after this statement a is 5, but x is 6. Thus, we returned the value in x and assigned it to
a, and then we increased the value of x. If x is an object, its postfix increment operator must stash
away the original value (5) in a temporary object, increment x's value to 6, and then return that
temporary to assign its value to a.
Note that since we are returning the temporary, we must return it by value and not by reference, as the
temporary will go out of scope as soon as the function returns.
Listing 10.12 demonstrates the use of both the prefix and the postfix operators.
Listing 10.12. Prefix and postfix operators.
1:
2:
3:
4:
5:
6:
7:
8:
9:
// Listing 10.12
// Returning the dereferenced this pointer
typedef unsigned short
#include <iostream.h>
class Counter
{
public:
USHORT;10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53: }
Counter();
~Counter(){}
USHORT GetItsVal()const { return itsVal; }
void SetItsVal(USHORT x) {itsVal = x; }
const Counter& operator++ ();
// prefix
const Counter operator++ (int); // postfix
private:
USHORT itsVal;
};
Counter::Counter():
itsVal(0)
{}
const Counter& Counter::operator++()
{
++itsVal;
return *this;
}
const Counter Counter::operator++(int)
{
Counter temp(*this);
++itsVal;
return temp;
}
int main()
{
Counter i;
cout << "The value
i++;
cout << "The value
++i;
cout << "The value
Counter a = ++i;
cout << "The value
cout << " and i: "
a = i++;
cout << "The value
cout << " and i: "
return 0;
Output: The value of i is 0
of i is " << i.GetItsVal() << endl;
of i is " << i.GetItsVal() << endl;
of i is " << i.GetItsVal() << endl;
of a: " << a.GetItsVal();
<< i.GetItsVal() << endl;
of a: " << a.GetItsVal();
<< i.GetItsVal() << endl;The
The
The
The
value
value
value
value
of
of
of
of
i is
i is
a: 3
a: 3
1
2
and i: 3
and i: 4
Analysis: The postfix operator is declared on line 15 and implemented on lines 31-36. Note that the
call to the prefix operator on line 14 does not include the flag integer (x), but is used with its normal
syntax. The postfix operator uses a flag value (x) to signal that it is the postfix and not the prefix. The
flag value (x) is never used, however.
Operator Overloading Unary Operators
Declare an overloaded operator as you would a function. Use the keyword operator, followed by
the operator to overload. Unary operator functions do not take parameters, with the exception of the
postfix increment and decrement, which take an integer as a flag. Example 1
const Counter& Counter::operator++ ();
Example 2
Counter Counter::operator-(int);
DO use a parameter to operator++ if you want the postfix operator. DO return a
const reference to the object from operator++. DON'T create temporary objects
as return values from operator++.
The Addition Operator
The increment operator is a unary operator. It operates on only one object. The addition operator (+) is
a binary operator, where two objects are involved. How do you implement overloading the + operator
for Count?
The goal is to be able to declare two Counter variables and then add them, as in this example:
Counter varOne, varTwo, varThree;
VarThree = VarOne + VarTwo;
Once again, you could start by writing a function, Add(), which would take a Counter as its
argument, add the values, and then return a Counter with the result. Listing 10.13 illustrates this
approach.
Listing 10.13. The Add() function.1:
// Listing 10.13
2:
// Add function
3:
4:
typedef unsigned short USHORT;
5:
#include <iostream.h>
6:
7:
class Counter
8:
{
9:
public:
10:
Counter();
11:
Counter(USHORT initialValue);
12:
~Counter(){}
13:
USHORT GetItsVal()const { return itsVal; }
14:
void SetItsVal(USHORT x) {itsVal = x; }
15:
Counter Add(const Counter &);
16:
17:
private:
18:
USHORT itsVal;
19:
20:
};
21:
22:
Counter::Counter(USHORT initialValue):
23:
itsVal(initialValue)
24:
{}
25:
26:
Counter::Counter():
27:
itsVal(0)
28:
{}
29:
30:
Counter Counter::Add(const Counter & rhs)
31:
{
32:
return Counter(itsVal+ rhs.GetItsVal());
33:
}
34:
35:
int main()
36:
{
37:
Counter varOne(2), varTwo(4), varThree;
38:
varThree = varOne.Add(varTwo);
39:
cout << "varOne: " << varOne.GetItsVal()<< endl;
40:
cout << "varTwo: " << varTwo.GetItsVal() << endl;
41:
cout << "varThree: " << varThree.GetItsVal() << endl;
42:
43:
return 0;
44: }
Output: varOne: 2varTwo: 4
varThree: 6
Analysis: The Add()function is declared on line 15. It takes a constant Counter reference, which
is the number to add to the current object. It returns a Counter object, which is the result to be
assigned to the left side of the assignment statement, as shown on line 38. That is, VarOne is the
object, varTwo is the parameter to the Add() function, and the result is assigned to VarThree.
In order to create varThree without having to initialize a value for it, a default constructor is
required. The default constructor initializes itsVal to 0, as shown on lines 26-28. Since varOne
and varTwo need to be initialized to a non-zero value, another constructor was created, as shown on
lines 22-24. Another solution to this problem is to provide the default value 0 to the constructor
declared on line 11.
Overloading operator+
The Add() function itself is shown on lines 30-33. It works, but its use is unnatural. Overloading the
+ operator would make for a more natural use of the Counter class. Listing 10.14 illustrates this.
Listing 10.14. operator+.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
// Listing 10.14
//Overload operator plus (+)
typedef unsigned short
#include <iostream.h>
USHORT;
class Counter
{
public:
Counter();
Counter(USHORT initialValue);
~Counter(){}
USHORT GetItsVal()const { return itsVal; }
void SetItsVal(USHORT x) {itsVal = x; }
Counter operator+ (const Counter &);
private:
USHORT itsVal;
};
Counter::Counter(USHORT initialValue):
itsVal(initialValue)
{}24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42: }
Counter::Counter():
itsVal(0)
{}
Counter Counter::operator+ (const Counter & rhs)
{
return Counter(itsVal + rhs.GetItsVal());
}
int main()
{
Counter varOne(2), varTwo(4), varThree;
varThree = varOne + varTwo;
cout << "varOne: " << varOne.GetItsVal()<< endl;
cout << "varTwo: " << varTwo.GetItsVal() << endl;
cout << "varThree: " << varThree.GetItsVal() << endl;
return 0;
Output: varOne: 2
varTwo: 4
varThree: 6
Analysis: operator+ is declared on line 15 and defined on lines 28-31. Compare these with the
declaration and definition of the Add() function in the previous listing; they are nearly identical. The
syntax of their use, however, is quite different. It is more natural to say this:
varThree = varOne + varTwo;
than to say:
varThree = varOne.Add(varTwo);
Not a big change, but enough to make the program easier to use and understand.
NOTE: The techniques used for overloading operator++ can be applied to the other
unary operators, such as operator-.
Operator Overloading: Binary Operators
Binary operators are created like unary operators, except that they do take a parameter. The parameter
is a constant reference to an object of the same type. Example 1Counter Counter::operator+ (const Counter & rhs);
Example 2
Counter Counter::operator-(const Counter & rhs);
Issues in Operator Overloading
Overloaded operators can be member functions, as described in this chapter, or non-member
functions. The latter will be described on Day 14, "Special Classes and Functions," when we discuss
friend functions.
The only operators that must be class members are the assignment (=), subscript([]), function call
(()), and indirection (->) operators.
operator[] will be discussed tomorrow, when arrays are covered. Overloading operator->
will be discussed on Day 14, when smart pointers are discussed.
Limitations on Operator Overloading
Operators on built-in types (such as int) cannot be overloaded. The precedence order cannot be
changed, and the arity of the operator, that is, whether it is unary or binary, cannot be changed. You
cannot make up new operators, so you cannot declare ** to be the "power of" operator.
New Term: Arity refers to how many terms are used in the operator. Some C++ operators are
unary and use only one term (myValue++). Some operators are binary and use two terms
(a+b). Only one operator is ternary and uses three terms. The ? operator is often called the
ternary operator, as it is the only ternary operator in C++ (a > b ? x : y).
What to Overload
Operator overloading is one of the aspects of C++ most overused and abused by new programmers. It
is tempting to create new and interesting uses for some of the more obscure operators, but these
invariably lead to code that is confusing and difficult to read.
Of course, making the + operator subtract and the * operator add can be fun, but no professional
programmer would do that. The greater danger lies in the well-intentioned but idiosyncratic use of an
operator--using + to mean concatenate a series of letters, or / to mean split a string. There is good
reason to consider these uses, but there is even better reason to proceed with caution. Remember, the
goal of overloading operators is to increase usability and understanding.DO use operator overloading when it will clarify the program. DON'T create counter-
intuitive operators. DO return an object of the class from overloaded operators.
The Assignment Operator
The fourth and final function that is supplied by the compiler, if you don't specify one, is the
assignment operator (operator=()). This operator is called whenever you assign to an object. For
example:
CAT catOne(5,7);
CAT catTwo(3,4);
// ... other code here
catTwo = catOne;
Here, catOne is created and initialized with itsAge equal to 5 and itsWeight equal to 7.
catTwo is then created and assigned the values 3 and 4.
After a while, catTwo is assigned the values in catOne. Two issues are raised here: What happens
if itsAge is a pointer, and what happens to the original values in catTwo?
Handling member variables that store their values on the free store was discussed earlier during the
examination of the copy constructor. The same issues arise here, as you saw illustrated in Figures 10.1
and 10.2.
C++ programmers differentiate between a shallow or member-wise copy on the one hand, and a deep
copy on the other. A shallow copy just copies the members, and both objects end up pointing to the
same area on the free store. A deep copy allocates the necessary memory. This is illustrated in Figure
10.3.
There is an added wrinkle with the assignment operator, however. The object catTwo already exists
and has memory already allocated. That memory must be deleted if there is to be no memory leak. But
what happens if you assign catTwo to itself?
catTwo = catTwo;
No one is likely to do this on purpose, but the program must be able to handle it. More important, it is
possible for this to happen by accident when references and dereferenced pointers hide the fact that
the assignment is to itself.
If you did not handle this problem carefully, catTwo would delete its memory allocation. Then,
when it was ready to copy in the memory from the right-hand side of the assignment, it would have a
very big problem: The memory would be gone.
To protect against this, your assignment operator must check to see if the right-hand side of theassignment operator is the object itself. It does this by examining the this pointer. Listing 10.15
shows a class with an assignment operator.
Listing 10.15. An assignment operator.
1:
// Listing 10.15
2:
// Copy constructors
3:
4:
#include <iostream.h>
5:
6:
class CAT
7:
{
8:
public:
9:
CAT();
// default
constructor
10:
// copy constructor and destructor elided!
11:
int GetAge() const { return *itsAge; }
12:
int GetWeight() const { return *itsWeight; }
13:
void SetAge(int age) { *itsAge = age; }
14:
CAT operator=(const CAT &);
15:
16:
private:
17:
int *itsAge;
18:
int *itsWeight;
19:
};
20:
21:
CAT::CAT()
22:
{
23:
itsAge = new int;
24:
itsWeight = new int;
25:
*itsAge = 5;
26:
*itsWeight = 9;
27: }
28:
29:
30: CAT CAT::operator=(const CAT & rhs)
31: {
32:
if (this == &rhs)
33:
return *this;
34:
delete itsAge;
35:
delete itsWeight;
36:
itsAge = new int;
37:
itsWeight = new int;
38:
*itsAge = rhs.GetAge();
39:
*itsWeight = rhs.GetWeight();40:
41: }
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
endl;
52:
53:
54:
endl;
55:
56: }
return *this;
int main()
{
CAT frisky;
cout << "frisky's age: " << frisky.GetAge() << endl;
cout << "Setting frisky to 6...\n";
frisky.SetAge(6);
CAT whiskers;
cout << "whiskers' age: " << whiskers.GetAge() <<
cout << "copying frisky to whiskers...\n";
whiskers = frisky;
cout << "whiskers' age: " << whiskers.GetAge() <<
return 0;
frisky's age: 5
Setting frisky to 6...
whiskers' age: 5
copying frisky to whiskers...
whiskers' age: 6
Output: Listing 10.15 brings back the CAT class, and leaves out the copy constructor and destructor
to save room. On line 14, the assignment operator is declared, and on lines 30-41 it is defined.
Analysis: On line 32, the current object (the CAT being assigned to) is tested to see whether it is the
same as the CAT being assigned. This is done by checking whether or not the address of rhs is the
same as the address stored in the this pointer.
This works fine for single inheritance, but if you are using multiple inheritance, as discussed on Day
13, "Polymorphism," this test will fail. An alternative test is to dereference the this pointer and see
if the two objects are the same:
if (*this == rhs)
Of course, the equality operator (==) can be overloaded as well, allowing you to determine for
yourself what it means for your objects to be equal.
Conversion Operators
What happens when you try to assign a variable of a built-in type, such as int or unsignedshort, to an object of a user-defined class? Listing 10.16 brings back the Counter class, and
attempts to assign a variable of type USHORT to a Counter object.
WARNING: Listing 10.16 will not compile!
Listing 10.16. Attempting to assign a Counter to a USHORT
1:
// Listing 10.16
2:
// This code won't compile!
3:
4:
typedef unsigned short USHORT;
5:
#include <iostream.h>
6:
7:
class Counter
8:
{
9:
public:
10:
Counter();
11:
~Counter(){}
12:
USHORT GetItsVal()const { return itsVal; }
13:
void SetItsVal(USHORT x) {itsVal = x; }
14:
private:
15:
USHORT itsVal;
16:
17:
};
18:
19:
Counter::Counter():
20:
itsVal(0)
21:
{}
22:
23:
int main()
24:
{
25:
USHORT theShort = 5;
26:
Counter theCtr = theShort;
27:
cout << "theCtr: " << theCtr.GetItsVal() << endl;
28:
return ;0
29: }
Output: Compiler error! Unable to convert USHORT to Counter
Analysis: The Counter class declared on lines 7-17 has only a default constructor. It declares no
particular method for turning a USHORT into a Counter object, and so line 26 causes a compile
error. The compiler cannot figure out, unless you tell it, that, given a USHORT, it should assign that
value to the member variable itsVal.
Listing 10.17 corrects this by creating a conversion operator: a constructor that takes a USHORT andproduces a Counter object.
Listing 10.17. Converting USHORT to Counter.
1:
// Listing 10.17
2:
// Constructor as conversion operator
3:
4:
typedef unsigned short USHORT;
5:
#include <iostream.h>
6:
7:
class Counter
8:
{
9:
public:
10:
Counter();
11:
Counter(USHORT val);
12:
~Counter(){}
13:
USHORT GetItsVal()const { return itsVal; }
14:
void SetItsVal(USHORT x) {itsVal = x; }
15:
private:
16:
USHORT itsVal;
17:
18:
};
19:
20:
Counter::Counter():
21:
itsVal(0)
22:
{}
23:
24:
Counter::Counter(USHORT val):
25:
itsVal(val)
26:
{}
27:
28:
29:
int main()
30:
{
31:
USHORT theShort = 5;
32:
Counter theCtr = theShort;
33:
cout << "theCtr: " << theCtr.GetItsVal() << endl;
34:
return 0;
35:
Output: theCtr: 5
Analysis: The important change is on line 11, where the constructor is overloaded to take a USHORT,
and on lines 24-26, where the constructor is implemented. The effect of this constructor is to create a
Counter out of a USHORT.
Given this, the compiler is able to call the constructor that takes a USHORT as its argument. Whathappens, however, if you try to reverse the assignment with the following?
1:
2:
3:
Counter theCtr(5);
USHORT theShort = theCtr;
cout << "theShort : " << theShort
<< endl;
Once again, this will generate a compile error. Although the compiler now knows how to create a
Counter out of a USHORT, it does not know how to reverse the process.
Conversion Operators
To solve this and similar problems, C++ provides conversion operators that can be added to your
class. This allows your class to specify how to do implicit conversions to built-in types. Listing 10.18
illustrates this. One note, however: Conversion operators do not specify a return value, even though
they do, in effect, return a converted value.
Listing 10.18. Converting from Counter to unsigned short().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
// Listing 10.18
// conversion operator
typedef unsigned short
#include <iostream.h>
USHORT;
class Counter
{
public:
Counter();
Counter(USHORT val);
~Counter(){}
USHORT GetItsVal()const { return itsVal; }
void SetItsVal(USHORT x) {itsVal = x; }
operator unsigned short();
private:
USHORT itsVal;
};
Counter::Counter():
itsVal(0)
{}
Counter::Counter(USHORT val):
itsVal(val)
{}28:
29: Counter::operator unsigned short ()
30: {
31:
return ( USHORT (itsVal) );
32: }
33:
34: int main()
35: {
36:
Counter ctr(5);
37:
USHORT theShort = ctr;
38:
cout << "theShort: " << theShort << endl;
39:
return 0;
40:
Output: theShort: 5
Analysis: On line 15, the conversion operator is declared. Note that it has no return value. The
implementation of this function is on lines 29-32. Line 31 returns the value of itsVal, converted to
a USHORT.
Now the compiler knows how to turn USHORTs into Counter objects and vice versa, and they can
be assigned to one another freely.
Summary
Today you learned how to overload member functions of your classes. You also learned how to
supply default values to functions, and how to decide when to use default values and when to
overload.
Overloading class constructors allows you to create flexible classes that can be created from other
objects. Initialization of objects happens at the initialization stage of construction, and is more
efficient than assigning values in the body of the constructor.
The copy constructor and the assignment operator are supplied by the compiler if you don't create
your own, but they do a member-wise copy of the class. In classes in which member data includes
pointers to the free store, these methods must be overridden so that you allocate memory for the target
object.
Almost all C++ operators can be overloaded, though you want to be cautious not to create operators
whose use is counter-intuitive. You cannot change the arity of operators, nor can you invent new
operators.
The this pointer refers to the current object and is an invisible parameter to all member functions.
The dereferenced this pointer is often returned by overloaded operators.
Conversion operators allow you to create classes that can be used in expressions that expect adifferent type of object. They are exceptions to the rule that all functions return an explicit value; like
constructors and destructors, they have no return type.
Q&A
Q. Why would you ever use default values when you can overload a function?
A. It is easier to maintain one function than two, and often easier to understand a function with
default parameters than to study the bodies of two functions. Furthermore, updating one of the
functions and neglecting to update the second is a common source of bugs.
Q. Given the problems with overloaded functions, why not always use default values
instead?
A. Overloaded functions supply capabilities not available with default variables, such as
varying the list of parameters by type rather than just by number.
Q. When writing a class constructor, how do you decide what to put in the initialization
and what to put in the body of the constructor?
A. A simple rule of thumb is to do as much as possible in the initialization phase--that is,
initialize all member variables there. Some things, like computations and print statements,
must be in the body of the constructor.
Q. Can an overloaded function have a default parameter?
A. Yes. There is no reason not to combine these powerful features. One or more of the
overloaded functions can have their own default values, following the normal rules for default
variables in any function.
Q. Why are some member functions defined within the class declaration and others are
not?
A. Defining the implementation of a member function within the declaration makes it inline.
Generally, this is done only if the function is extremely simple. Note that you can also make a
member function inline by using the keyword inline, even if the function is declared outside
the class declaration.
Workshop
The Workshop provides quiz questions to help solidify your understanding of the material covered
and exercises to provide you with experience in using what you've learned. Try to answer the quiz and
exercise questions before checking the answers in Appendix D, and make sure you understand the
answers before going to the next chapter.
Quiz1. When you overload member functions, in what ways must they differ?
2. What is the difference between a declaration and a definition?
3. When is the copy constructor called?
4. When is the destructor called?
5. How does the copy constructor differ from the assignment operator (=)?
6. What is the this pointer?
7. How do you differentiate between overloading the prefix and postfix increment operators?
8. Can you overload the operator+ for short integers?
9. Is it legal in C++ to overload the operator++ so that it decrements a value in your class?
10. What return value must conversion operators have in their declarations?
Exercises
1. Write a SimpleCircle class declaration (only) with one member variable: itsRadius.
Include a default constructor, a destructor, and accessor methods for radius.
2. Using the class you created in Exercise 1, write the implementation of the default
constructor, initializing itsRadius with the value 5.
3. Using the same class, add a second constructor that takes a value as its parameter and
assigns that value to itsRadius.
4. Create a prefix and postfix increment operator for your SimpleCircle class that
increments itsRadius.
5. Change SimpleCircle to store itsRadius on the free store, and fix the existing
methods.
6. Provide a copy constructor for SimpleCircle.
7. Provide an assignment operator for SimpleCircle.
8. Write a program that creates two SimpleCircle objects. Use the default constructor on
one and instantiate the other with the value 9. Call the increment operator on each and then
print their values. Finally, assign the second to the first and print its values.
9. BUG BUSTERS: What is wrong with this implementation of the assignment operator?
SQUARE SQUARE ::operator=(const SQUARE & rhs){
itsSide = new int;
*itsSide = rhs.GetSide();
return *this;
}
10. BUG BUSTERS: What is wrong with this implementation of the addition operator?
VeryShort VeryShort::operator+ (const VeryShort& rhs)
{
itsVal += rhs.GetItsVal();
return *this;
}
What Is an Array?
An array is a collection of data storage locations, each of which holds the same type of data. Each
storage location is called an element of the array.
You declare an array by writing the type, followed by the array name and the subscript. The subscript
is the number of elements in the array, surrounded by square brackets. For example,
long LongArray[25];
declares an array of 25 long integers, named LongArray. When the compiler sees this declaration,
it sets aside enough memory to hold all 25 elements. Because each long integer requires 4 bytes, this
declaration sets aside 100 contiguous bytes of memory, as illustrated in Figure 11.1.
Figure 11.1. Declaring an array.Array Elements
You access each of the array elements by referring to an offset from the array name. Array elements
are counted from zero. Therefore, the first array element is arrayName[0]. In the LongArray
example, LongArray[0] is the first array element, LongArray[1] the second, and so forth.
This can be somewhat confusing. The array SomeArray[3] has three elements. They are
SomeArray[0], SomeArray[1], and SomeArray[2]. More generally, SomeArray[n] has n
elements that are numbered SomeArray[0] through SomeArray[n-1].
Therefore, LongArray[25] is numbered from LongArray[0] through LongArray[24].
Listing 11.1 shows how to declare an array of five integers and fill each with a value.
Listing 11.1. Using an integer array.
1:
//Listing 11.1 - Arrays
2:
#include <iostream.h>
3:
4:
int main()
5:
{
6:
int myArray[5];
7:
int i;
8:
for ( i=0; i<5; i++) // 0-4
9:
{
10:
cout << "Value for myArray[" << i << "]: ";
11:
cin >> myArray[i];
12:
}
13:
for (i = 0; i<5; i++)
14:
cout << i << ": " << myArray[i] << "\n";
15:
return 0;
16: }
Output: Value for myArray[0]: 3
Value for myArray[1]: 6
Value for myArray[2]: 9
Value for myArray[3]: 12
Value for myArray[4]: 15
0: 3
1: 6
2: 9
3: 12
4: 15
Analysis: Line 6 declares an array called myArray, which holds five integer variables. Line 8
establishes a loop that counts from 0 through 4, which is the proper set of offsets for a five-element
array. The user is prompted for a value, and that value is saved at the correct offset into the array.The first value is saved at myArray[0], the second at myArray[1], and so forth. The second for
loop prints each value to the screen.
NOTE: Arrays count from 0, not from 1. This is the cause of many bugs in programs
written by C++ novices. Whenever you use an array, remember that an array with 10
elements counts from ArrayName[0] to ArrayName[9]. There is no
ArrayName[10].
Writing Past the End of an Array
When you write a value to an element in an array, the compiler computes where to store the value
based on the size of each element and the subscript. Suppose that you ask to write over the value at
LongArray[5], which is the sixth element. The compiler multiplies the offset (5) by the size of
each element--in this case, 4. It then moves that many bytes (20) from the beginning of the array and
writes the new value at that location.
If you ask to write at LongArray[50], the compiler ignores the fact that there is no such element. It
computes how far past the first element it should look (200 bytes) and then writes over whatever is at
that location. This can be virtually any data, and writing your new value there might have
unpredictable results. If you're lucky, your program will crash immediately. If you're unlucky, you'll
get strange results much later in your program, and you'll have a difficult time figuring out what went
wrong.
The compiler is like a blind man pacing off the distance from a house. He starts out at the first house,
MainStreet[0]. When you ask him to go to the sixth house on Main Street, he says to himself, "I
must go five more houses. Each house is four big paces. I must go an additional 20 steps." If you ask
him to go to MainStreet[100], and Main Street is only 25 houses long, he will pace off 400 steps.
Long before he gets there, he will, no doubt, step in front of a moving bus. So be careful where you
send him.
Listing 11.2 shows what happens when you write past the end of an array.
WARNING: Do not run this program; it may crash your system!
Listing 11.2. Writing past the end of an array.
1:
2:
3:
4:
//Listing 11.2
// Demonstrates what happens when you write past the end
// of an array5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
0)
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48: }
#include <iostream.h>
int main()
{
// sentinels
long sentinelOne[3];
long TargetArray[25]; // array to fill
long sentinelTwo[3];
int i;
for (i=0; i<3; i++)
sentinelOne[i] = sentinelTwo[i] = 0;
for (i=0; i<25; i++)
TargetArray[i] = 0;
cout << "Test 1: \n";
// test current values (should be
cout << "TargetArray[0]: " << TargetArray[0] << "\n";
cout << "TargetArray[24]: " << TargetArray[24] << "\n\n";
for (i = 0; i<3; i++)
{
cout << "sentinelOne[" <<
cout << sentinelOne[i] <<
cout << "sentinelTwo[" <<
cout << sentinelTwo[i]<<
}
i << "]: ";
"\n";
i << "]: ";
"\n";
cout << "\nAssigning...";
for (i = 0; i<=25; i++)
TargetArray[i] = 20;
cout << "\nTest 2: \n";
cout << "TargetArray[0]: " << TargetArray[0] << "\n";
cout << "TargetArray[24]: " << TargetArray[24] << "\n";
cout << "TargetArray[25]: " << TargetArray[25] << "\n\n";
for (i = 0; i<3; i++)
{
cout << "sentinelOne[" << i << "]: ";
cout << sentinelOne[i]<< "\n";
cout << "sentinelTwo[" << i << "]: ";
cout << sentinelTwo[i]<< "\n";
}
return 0;Output: Test 1:
TargetArray[0]: 0
TargetArray[24]: 0
SentinelOne[0]:
SentinelTwo[0]:
SentinelOne[1]:
SentinelTwo[1]:
SentinelOne[2]:
SentinelTwo[2]:
0
0
0
0
0
0
Assigning...
Test 2:
TargetArray[0]: 20
TargetArray[24]: 20
TargetArray[25]: 20
SentinelOne[0]:
SentinelTwo[0]:
SentinelOne[1]:
SentinelTwo[1]:
SentinelOne[2]:
SentinelTwo[2]:
20
0
0
0
0
0
Analysis: Lines 9 and 10 declare two arrays of three integers that act as sentinels around
TargetArray. These sentinel arrays are initialized with the value 0. If memory is written to beyond
the end of TargetArray, the sentinels are likely to be changed. Some compilers count down in
memory; others count up. For this reason, the sentinels are placed on both sides of TargetArray.
Lines 19-29 confirm the sentinel values in Test 1. In line 33 TargetArray's members are all
initialized to the value 20, but the counter counts to TargetArray offset 25, which doesn't exist in
TargetArray.
Lines 36-38 print TargetArray's values in Test 2. Note that TargetArray[25] is perfectly
happy to print the value 20. However, when SentinelOne and SentinelTwo are printed,
SentinelTwo[0] reveals that its value has changed. This is because the memory that is 25
elements after TargetArray[0] is the same memory that is at SentinelTwo[0]. When the
nonexistent TargetArray[0] was accessed, what was actually accessed was SentinelTwo[0].
This nasty bug can be very hard to find, because SentinelTwo[0]'s value was changed in a part of
the code that was not writing to SentinelTwo at all.
This code uses "magic numbers" such as 3 for the size of the sentinel arrays and 25 for the size of
TargetArray. It is safer to use constants, so that you can change all these values in one place.
Fence Post ErrorsIt is so common to write to one past the end of an array that this bug has its own name. It is called a
fence post error. This refers to the problem in counting how many fence posts you need for a 10-foot
fence if you need one post for every foot. Most people answer 10, but of course you need 11. Figure
11.2 makes this clear.
Figure 11.2. Fence post errors.
This sort of "off by one" counting can be the bane of any programmer's life. Over time, however,
you'll get used to the idea that a 25-element array counts only to element 24, and that everything
counts from 0. (Programmers are often confused why office buildings don't have a floor zero. Indeed,
some have been known to push the 4 elevator button when they want to get to the fifth floor.)
NOTE: Some programmers refer to ArrayName[0] as the zeroth element. Getting
into this habit is a big mistake. If ArrayName[0] is the zeroth element, what is
ArrayName[1]? The oneth? If so, when you see ArrayName[24], will you realize
that it is not the 24th element, but rather the 25th? It is far better to say that
ArrayName[0] is at offset zero and is the first element.
Initializing Arrays
You can initialize a simple array of built-in types, such as integers and characters, when you first
declare the array. After the array name, you put an equal sign (=) and a list of comma-separated values
enclosed in braces. For example,
int IntegerArray[5] = { 10, 20, 30, 40, 50 };
declares IntegerArray to be an array of five integers. It assigns IntegerArray[0] the value
10, IntegerArray[1] the value 20, and so forth.
If you omit the size of the array, an array just big enough to hold the initialization is created.
Therefore, if you write
int IntegerArray[] = { 10, 20, 30, 40, 50 };
you will create exactly the same array as you did in the previous example.
If you need to know the size of the array, you can ask the compiler to compute it for you. For example,
const USHORT IntegerArrayLength;
IntegerArrayLength = sizeof(IntegerArray)/sizeof(IntegerArray[0]);
sets the constant USHORT variable IntegerArrayLength to the result obtained from dividing thesize of the entire array by the size of each individual entry in the array. That quotient is the number of
members in the array.
You cannot initialize more elements than you've declared for the array. Therefore,
int IntegerArray[5] = { 10, 20, 30, 40, 50, 60};
generates a compiler error because you've declared a five-member array and initialized six values. It is
legal, however, to write
int IntegerArray[5] = { 10, 20};
Although uninitialized array members have no guaranteed values, actually, aggregates will be
initialized to 0. If you don't initialize an array member, its value will be set to 0.
DO let the compiler set the size of initialized arrays. DON'T write past the end of the
array. DO give arrays meaningful names, as you would with any variable.DO remember
that the first member of the array is at offset 0.
Declaring Arrays
Arrays can have any legal variable name, but they cannot have the same name as another variable or
array within their scope. Therefore, you cannot have an array named myCats[5] and a variable
named myCats at the same time.
You can dimension the array size with a const or with an enumeration. Listing 11.3 illustrates this.
Listing 11.3. Using consts and enums in arrays.
1:
2:
3:
4:
5:
6:
7:
8:
9:
};
10:
11:
12:
// Listing 11.3
// Dimensioning arrays with consts and enumerations
#include <iostream.h>
int main()
{
enum WeekDays { Sun, Mon, Tue,
Wed, Thu, Fri, Sat, DaysInWeek };
int ArrayWeek[DaysInWeek] = { 10, 20, 30, 40, 50, 60, 70
cout << "The value at Tuesday is: " << ArrayWeek[Tue];
return 0;13: }
Output: The value at Tuesday is: 30
Analysis: Line 7 creates an enumeration called WeekDays. It has eight members. Sunday is equal to
0, and DaysInWeek is equal to 7.
Line 11 uses the enumerated constant Tue as an offset into the array. Because Tue evaluates to 2, the
third element of the array, DaysInWeek[2], is returned and printed in line 11.
Arrays
To declare an array, write the type of object stored, followed by the name of the array and a subscript
with the number of objects to be held in the array. Example 1
int MyIntegerArray[90];
Example 2
long * ArrayOfPointersToLongs[100];
To access members of the array, use the subscript operator. Example 1
int theNinethInteger = MyIntegerArray[8];
Example 2
long * pLong = ArrayOfPointersToLongs[8]
Arrays count from zero. An array of n items is numbered from 0 to n-1.
Arrays of Objects
Any object, whether built-in or user-defined, can be stored in an array. When you declare the array,
you tell the compiler the type of object to store and the number of objects for which to allocate room.
The compiler knows how much room is needed for each object based on the class declaration. The
class must have a default constructor that takes no arguments so that the objects can be created when
the array is defined.
Accessing member data in an array of objects is a two-step process. You identify the member of the
array by using the index operator ([ ]), and then you add the member operator (.) to access the
particular member variable. Listing 11.4 demonstrates how you would create an array of five CATs.
Listing 11.4. Creating an array of objects.1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32: }
// Listing 11.4 - An array of objects
#include <iostream.h>
class CAT
{
public:
CAT() { itsAge = 1; itsWeight=5; }
~CAT() {}
int GetAge() const { return itsAge; }
int GetWeight() const { return itsWeight; }
void SetAge(int age) { itsAge = age; }
private:
int itsAge;
int itsWeight;
};
Output:
cat #2:
cat #3:
cat #4:
cat #5:
int main()
{
CAT Litter[5];
int i;
for (i = 0; i < 5; i++)
Litter[i].SetAge(2*i +1);
for (i = 0; i < 5; i++)
{
cout << "Cat #" << i+1<< ": ";
cout << Litter[i].GetAge() << endl;
}
return 0;
cat #1: 1
3
5
7
9
Analysis: Lines 5-17 declare the CAT class. The CAT class must have a default constructor so that
CAT objects can be created in an array. Remember that if you create any other constructor, the
compiler-supplied default constructor is not created; you must create your own.
The first for loop (lines 23 and 24) sets the age of each of the five CATs in the array. The second for
loop (lines 26 and 27) accesses each member of the array and calls GetAge().Each individual CAT's GetAge() method is called by accessing the member in the array,
Litter[i], followed by the dot operator (.), and the member function.
Multidimensional Arrays
It is possible to have arrays of more than one dimension. Each dimension is represented as a subscript
in the array. Therefore, a two-dimensional array has two subscripts; a three-dimensional array has
three subscripts; and so on. Arrays can have any number of dimensions, although it is likely that most
of the arrays you create will be of one or two dimensions.
A good example of a two-dimensional array is a chess board. One dimension represents the eight
rows; the other dimension represents the eight columns. Figure 11.3 illustrates this idea.
Suppose that you have a class named SQUARE. The declaration of an array named Board that
represents it would be
SQUARE Board[8][8];
You could also represent the same data with a one-dimensional, 64-square array. For example,
SQUARE Board[64]
This doesn't correspond as closely to the real-world object as the two-dimension. When the game
begins, the king is located in the fourth position in the first row. Counting from zero array, that
position corresponds to
Board[0][3];
assuming that the first subscript corresponds to row, and the second to column. The layout of
positions for the entire board is illustrated in Figure 11.3.
Figure 11.3. A chess board and a two-dimensional array.
Initializing Multidimensional Arrays
You can initialize multidimensional arrays. You assign the list of values to array elements in order,
with the last array subscript changing while each of the former holds steady. Therefore, if you have an
array
int theArray[5][3]
the first three elements go into theArray[0]; the next three into theArray[1]; and so forth.
You initialize this array by writingint theArray[5][3] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 }
For the sake of clarity, you could group the initializations with braces. For example,
int theArray[5][3] = {
{4,5,6},
{7,8,9},
{10,11,12},
{13,14,15} };
{1,2,3},
The compiler ignores the inner braces, which make it easier to understand how the numbers are
distributed.
Each value must be separated by a comma, without regard to the braces. The entire initialization set
must be within braces, and it must end with a semicolon.
Listing 11.5 creates a two-dimensional array. The first dimension is the set of numbers from 0 to 5.
The second dimension consists of the double of each value in the first dimension.
Listing 11.5. Creating a multidimensional array.
1:
#include <iostream.h>
2:
int main()
3:
{
4:
int SomeArray[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},
{4,8}};
5:
for (int i = 0; i<5; i++)
6:
for (int j=0; j<2; j++)
7:
{
8:
cout << "SomeArray[" << i << "][" << j << "]: ";
9:
cout << SomeArray[i][j]<< endl;
10:
}
11:
12:
return 0;
13: }
Output: SomeArray[0][0]: 0
SomeArray[0][1]: 0
SomeArray[1][0]: 1
SomeArray[1][1]: 2
SomeArray[2][0]: 2
SomeArray[2][1]: 4
SomeArray[3][0]: 3
SomeArray[3][1]: 6SomeArray[4][0]: 4
SomeArray[4][1]: 8
Analysis: Line 4 declares SomeArray to be a two-dimensional array. The first dimension consists of
five integers; the second dimension consists of two integers. This creates a 5x2 grid, as Figure 11.4
shows.
Figure 11.4. A 5x2 array.
The values are initialized in pairs, although they could be computed as well. Lines 5 and 6 create a
nested for loop. The outer for loop ticks through each member of the first dimension. For every
member in that dimension, the inner for loop ticks through each member of the second dimension.
This is consistent with the printout. SomeArray[0][0] is followed by SomeArray[0][1]. The
first dimension is incremented only after the second dimension is incremented by 1. Then the second
dimension starts over.
A Word About Memory
When you declare an array, you tell the compiler exactly how many objects you expect to store in it.
The compiler sets aside memory for all the objects, even if you never use it. This isn't a problem with
arrays for which you have a good idea of how many objects you'll need. For example, a chess board
has 64 squares, and cats have between 1 and 10 kittens. When you have no idea of how many objects
you'll need, however, you must use more advanced data structures.
This book looks at arrays of pointers, arrays built on the free store, and various other collections. Other
more advanced data structures that solve large data storage problems are beyond the scope of this
book. Two of the great things about programming are that there are always more things to learn and
that there are always more books from which to learn.
Arrays of Pointers
The arrays discussed so far store all their members on the stack. Usually stack memory is severely
limited, whereas free store memory is far larger. It is possible to declare each object on the free store
and then to store only a pointer to the object in the array. This dramatically reduces the amount of
stack memory used. Listing 11.6 rewrites the array from Listing 11.4, but it stores all the objects on
the free store. As an indication of the greater memory that this enables, the array is expanded from 5 to
500, and the name is changed from Litter to Family.
Listing 11.6. Storing an array on the free store.
1:
2:
3:
4:
5:
// Listing 11.6 - An array of pointers to objects
#include <iostream.h>
class CAT6:
{
7:
public:
8:
CAT() { itsAge = 1; itsWeight=5; }
9:
~CAT() {}
//
destructor
10:
int GetAge() const { return itsAge; }
11:
int GetWeight() const { return itsWeight; }
12:
void SetAge(int age) { itsAge = age; }
13:
14:
private:
15:
int itsAge;
16:
int itsWeight;
17:
};
18:
19:
int main()
20:
{
21:
CAT * Family[500];
22:
int i;
23:
CAT * pCat;
24:
for (i = 0; i < 500; i++)
25:
{
26:
pCat = new CAT;
27:
pCat->SetAge(2*i +1);
28:
Family[i] = pCat;
29:
}
30:
31:
for (i = 0; i < 500; i++)
32:
{
33:
cout << "Cat #" << i+1 << ": ";
34:
cout << Family[i]->GetAge() << endl;
35:
}
36:
return 0;
37: }
Output: Cat #1: 1
Cat #2: 3
Cat #3: 5
...
Cat #499: 997
Cat #500: 999
Analysis: The CAT object declared in lines 5-17 is identical with the CAT object declared in Listing
11.4. This time, however, the array declared in line 21 is named Family, and it is declared to hold
500 pointers to CAT objects.
In the initial loop (lines 24-29), 500 new CAT objects are created on the free store, and each one has itsage set to twice the index plus one. Therefore, the first CAT is set to 1, the second CAT to 3, the third
CAT to 5, and so on. Finally, the pointer is added to the array.
Because the array has been declared to hold pointers, the pointer--rather than the dereferenced value in
the pointer--is added to the array.
The second loop (lines 31 and 32) prints each of the values. The pointer is accessed by using the index,
Family[i]. That address is then used to access the GetAge() method.
In this example, the array Family and all its pointers are stored on the stack, but the 500 CATs that
are created are stored on the free store.
Declaring Arrays on the Free Store
It is possible to put the entire array on the free store, also known as the heap. You do this by calling
new and using the subscript operator. The result is a pointer to an area on the free store that holds the
array. For example,
CAT *Family = new CAT[500];
declares Family to be a pointer to the first in an array of 500 CATs. In other words, Family points
to--or has the address of--Family[0].
The advantage of using Family in this way is that you can use pointer arithmetic to access each
member of Family. For example, you can write
CAT *Family = new CAT[500];
CAT *pCat = Family;
pCat->SetAge(10);
pCat++;
pCat->SetAge(20);
//pCat points to Family[0]
// set Family[0] to 10
// advance to Family[1]
// set Family[1] to 20
This declares a new array of 500 CATs and a pointer to point to the start of the array. Using that
pointer, the first CAT's SetAge() function is called with a value of 10. The pointer is then
incremented to point to the next CAT, and the second Cat's SetAge() method is then called.
A Pointer to an Array Versus an Array of Pointers
Examine these three declarations:
1:
2:
3:
Cat
FamilyOne[500]
CAT * FamilyTwo[500];
CAT * FamilyThree = new CAT[500];FamilyOne is an array of 500 CATs. FamilyTwo is an array of 500 pointers to CATs.
FamilyThree is a pointer to an array of 500 CATs.
The differences among these three code lines dramatically affect how these arrays operate. What is
perhaps even more surprising is that FamilyThree is a variant of FamilyOne, but is very different
from FamilyTwo.
This raises the thorny issue of how pointers relate to arrays. In the third case, FamilyThree is a
pointer to an array. That is, the address in FamilyThree is the address of the first item in that array.
This is exactly the case for FamilyOne.
Pointers and Array Names
In C++ an array name is a constant pointer to the first element of the array. Therefore, in the
declaration
CAT Family[50];
Family is a pointer to &Family[0], which is the address of the first element of the array Family.
It is legal to use array names as constant pointers, and vice versa. Therefore, Family + 4 is a
legitimate way of accessing the data at Family[4].
The compiler does all the arithmetic when you add to, increment, and decrement pointers. The address
accessed when you write Family + 4 isn't 4 bytes past the address of Family--it is four objects. If
each object is 4 bytes long, Family + 4 is 16 bytes. If each object is a CAT that has four long
member variables of 4 bytes each and two short member variables of 2 bytes each, each CAT is 20
bytes, and Family + 4 is 80 bytes past the start of the array.
Listing 11.7 illustrates declaring and using an array on the free store.
Listing 11.7. Creating an array by using new.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
// Listing 11.7 - An array on the free store
#include <iostream.h>
class CAT
{
public:
CAT() { itsAge = 1; itsWeight=5; }
~CAT();
int GetAge() const { return itsAge; }
int GetWeight() const { return itsWeight; }12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
38:
39:
40:
41:
42:
43:
44:
45: }
void SetAge(int age) { itsAge = age; }
private:
int itsAge;
int itsWeight;
};
CAT :: ~CAT()
{
// cout << "Destructor called!\n";
}
int main()
{
CAT * Family = new CAT[500];
int i;
CAT * pCat;
for (i = 0; i < 500; i++)
{
pCat = new CAT;
pCat->SetAge(2*i +1);
Family[i] = *pCat;
delete pCat;
}
for (i = 0; i < 500; i++)
{
cout << "Cat #" << i+1 << ": ";
cout << Family[i].GetAge() << endl;
}
delete [] Family;
return 0;
Output: Cat #1: 1
Cat #2: 3
Cat #3: 5
...
Cat #499: 997
Cat #500: 999
Analysis: Line 26 declares the array Family, which holds 500 CAT objects. The entire array is
created on the free store with the call to new CAT[500].
Each CAT object added to the array also is created on the free store (line 31). Note, however, that thepointer isn't added to the array this time; the object itself is. This array isn't an array of pointers to
CATs. It is an array of CATs.
Deleting Arrays on the Free Store
Family is a pointer, a pointer to the array on the free store. When, on line 33, the pointer pCat is
dereferenced, the CAT object itself is stored in the array (why not? the array is on the free store). But
pCat is used again in the next iteration of the loop. Isn't there a danger that there will now be no
pointer to that CAT object, and a memory leak has been created?
This would be a big problem, except that deleting Family returns all the memory set aside for the
array. The compiler is smart enough to destroy each object in the array and to return its memory to the
free store.
To see this, change the size of the array from 500 to 10 in lines 26, 29, and 37. Then uncomment the
cout statement in line 21. When line 40 is reached and the array is destroyed, each CAT object
destructor is called.
When you create an item on the heap by using new, you always delete that item and free its memory
with delete. Similarly, when you create an array by using new <class>[size], you delete that
array and free all its memory with delete[]. The brackets signal the compiler that this array is
being deleted.
If you leave the brackets off, only the first object in the array will be deleted. You can prove this to
yourself by removing the bracket on line 40. If you edited line 21 so that the destructor prints, you
should now see only one CAT object destroyed. Congratulations! You just created a memory leak.
DO remember that an array of n items is numbered from zero through n-1. DON'T write
or read past the end of an array. DON'T confuse an array of pointers with a pointer to an
array. DO use array indexing with pointers that point to arrays.
char Arrays
A string is a series of characters. The only strings you've seen until now have been unnamed string
constants used in cout statements, such as
cout << "hello world.\n";
In C++ a string is an array of chars ending with a null character. You can declare and initialize a
string just as you would any other array. For example,
char Greeting[] ={ `H', `e', `l', `l', `o', ` `, `W','o','r','l','d', `\0' };
The last character, `\0', is the null character, which many C++ functions recognize as the terminator
for a string. Although this character-by-character approach works, it is difficult to type and admits too
many opportunities for error. C++ enables you to use a shorthand form of the previous line of code. It
is
char Greeting[] = "Hello World";
You should note two things about this syntax:
-%)
$."
Instead of single quoted characters separated by commas and surrounded by braces, you have a
double-quoted string, no commas, and no braces.
You don't need to add the null character because the compiler adds it for you.
The string Hello World is 12 bytes. Hello is 5 bytes, the space 1, World 5, and the null
character 1.
You can also create uninitialized character arrays. As with all arrays, it is important to ensure that you
don't put more into the buffer than there is room for.
Listing 11.8 demonstrates the use of an uninitialized buffer.
Listing 11.8. Filling an array.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12: }
//Listing 11.8 char array buffers
#include <iostream.h>
int main()
{
char buffer[80];
cout << "Enter the string: ";
cin >> buffer;
cout << "Here's the buffer: " << buffer << endl;
return 0;
Output: Enter the string: Hello World
Here's the buffer: Hello
Analysis: On line 7, a buffer is declared to hold 80 characters. This is large enough to hold a 79-
character string and a terminating null character.
On line 8, the user is prompted to enter a string, which is entered into buffer on line 9. It is the syntaxof cin to write a terminating null to buffer after it writes the string.
There are two problems with the program in Listing 11.8. First, if the user enters more than 79
characters, cin writes past the end of the buffer. Second, if the user enters a space, cin thinks that it
is the end of the string, and it stops writing to the buffer.
To solve theseproblems, you must call a special method on cin: get(). cin.get() takes three
parameters:
The buffer to fill
The maximum number of characters to get
The delimiter that terminates input
The default delimiter is newline. Listing 11.9 illustrates its use.
Listing 11.9. Filling an array.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12: }
//Listing 11.9 using cin.get()
#include <iostream.h>
int main()
{
char buffer[80];
cout << "Enter the string: ";
cin.get(buffer, 79);
// get up to 79 or newline
cout << "Here's the buffer: " << buffer << endl;
return 0;
Output: Enter the string: Hello World
Here's the buffer: Hello World
Analysis: Line 9 calls the method get() of cin. The buffer declared in line 7 is passed in as the first
argument. The second argument is the maximum number of characters to get. In this case, it must be
79 to allow for the terminating null. There is no need to provide a terminating character because the
default value of newline is sufficient.
cin and all its variations are covered on Day 17, "The Preprocessor," when streams are discussed in
depth.
strcpy() and strncpy()C++ inherits from C a library of functions for dealing with strings. Among the many functions
provided are two for copying one string into another: strcpy() and strncpy(). strcpy()
copies the entire contents of one string into a designated buffer. Listing 11.10 demonstrates the use of
strcpy().
Listing 11.10. Using strcpy().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13: }
#include <iostream.h>
#include <string.h>
int main()
{
char String1[] = "No man is an island";
char String2[80];
strcpy(String2,String1);
cout << "String1: " << String1 << endl;
cout << "String2: " << String2 << endl;
return 0;
Output: String1: No man is an island
String2: No man is an island
Analysis: The header file string.h is included in line 2. This file contains the prototype of the
strcpy() function. strcpy() takes two character arrays--a destination followed by a source. If
the source were larger than the destination, strcpy() would overwrite past the end of the buffer.
To protect against this, the standard library also includes strncpy(). This variation takes a
maximum number of characters to copy. strncpy() copies up to the first null character or the
maximum number of characters specified into the destination buffer.
Listing 11.11 illustrates the use of strncpy().
Listing 11.11. Using strncpy().
1:
2:
3:
4:
5:
6:
7:
8:
9:
#include <iostream.h>
#include <string.h>
int main()
{
const int MaxLength = 80;
char String1[] = "No man is an island";
char String2[MaxLength+1];10:
11:
12:
13:
14:
15: }
strncpy(String2,String1,MaxLength);
cout << "String1: " << String1 << endl;
cout << "String2: " << String2 << endl;
return 0;
Output: String1: No man is an island
String2: No man is an island
Analysis: In line 10, the call to strcpy() has been changed to a call to strncpy(), which takes a
third parameter: the maximum number of characters to copy. The buffer String2 is declared to take
MaxLength+1 characters. The extra character is for the null, which both strcpy() and
strncpy() automatically add to the end of the string.
String Classes
Most C++ compilers come with a class library that includes a large set of classes for data
manipulation. A standard component of a class library is a String class.
C++ inherited the null-terminated string and the library of functions that includes strcpy() from C,
but these functions aren't integrated into an object-oriented framework. A String class provides an
encapsulated set of data and functions for manipulating that data, as well as accessor functions so that
the data itself is hidden from the clients of the String class.
If your compiler doesn't already provide a String class--and perhaps even if it does--you might want
to write your own. The remainder of this chapter discusses the design and partial implementation of
String classes.
At a minimum, a String class should overcome the basic limitations of character arrays. Like all
arrays, character arrays are static. You define how large they are. They always take up that much room
in memory even if you don't need it all. Writing past the end of the array is disastrous.
A good String class allocates only as much memory as it needs, and always enough to hold
whatever it is given. If it can't allocate enough memory, it should fail gracefully.
Listing 11.12 provides a first approximation of a String class.
Listing 11.12. Using a String class.
1:
2:
3:
4:
5:
//Listing 11.12
#include <iostream.h>
#include <string.h>6:
// Rudimentary string class
7:
class String
8:
{
9:
public:
10:
// constructors
11:
String();
12:
String(const char *const);
13:
String(const String &);
14:
~String();
15:
16:
// overloaded operators
17:
char & operator[](unsigned short offset);
18:
char operator[](unsigned short offset) const;
19:
String operator+(const String&);
20:
void operator+=(const String&);
21:
String & operator= (const String &);
22:
23:
// General accessors
24:
unsigned short GetLen()const { return itsLen; }
25:
const char * GetString() const { return itsString; }
26:
27:
private:
28:
String (unsigned short);
// private
constructor
29:
char * itsString;
30:
unsigned short itsLen;
31:
};
32:
33:
// default constructor creates string of 0 bytes
34:
String::String()
35:
{
36:
itsString = new char[1];
37:
itsString[0] = `\0';
38:
itsLen=0;
39:
}
40:
41:
// private (helper) constructor, used only by
42:
// class methods for creating a new string of
43:
// required size. Null filled.
44:
String::String(unsigned short len)
45:
{
46:
itsString = new char[len+1];
47:
for (unsigned short i = 0; i<=len; i++)
48:
itsString[i] = `\0';
49:
itsLen=len;
50:
}51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
// Converts a character array to a String
String::String(const char * const cString)
{
itsLen = strlen(cString);
itsString = new char[itsLen+1];
for (unsigned short i = 0; i<itsLen; i++)
itsString[i] = cString[i];
itsString[itsLen]='\0';
}
// copy constructor
String::String (const String & rhs)
{
itsLen=rhs.GetLen();
itsString = new char[itsLen+1];
for (unsigned short i = 0; i<itsLen;i++)
itsString[i] = rhs[i];
itsString[itsLen] = `\0';
}
// destructor, frees allocated memory
String::~String ()
{
delete [] itsString;
itsLen = 0;
}
// operator equals, frees existing memory
// then copies string and size
String& String::operator=(const String & rhs)
{
if (this == &rhs)
return *this;
delete [] itsString;
itsLen=rhs.GetLen();
itsString = new char[itsLen+1];
for (unsigned short i = 0; i<itsLen;i++)
itsString[i] = rhs[i];
itsString[itsLen] = `\0';
return *this;
}
//nonconstant offset operator, returns
// reference to character so it can be
// changed!97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
char & String::operator[](unsigned short offset)
{
if (offset > itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
}
// constant offset operator for use
// on const objects (see copy constructor!)
char String::operator[](unsigned short offset) const
{
if (offset > itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
}
// creates a new string by adding current
// string to rhs
String String::operator+(const String& rhs)
{
unsigned short totalLen = itsLen + rhs.GetLen();
String temp(totalLen);
for (unsigned short i = 0; i<itsLen; i++)
temp[i] = itsString[i];
for (unsigned short j = 0; j<rhs.GetLen(); j++, i++)
temp[i] = rhs[j];
temp[totalLen]='\0';
return temp;
}
// changes current string, returns nothing
void String::operator+=(const String& rhs)
{
unsigned short rhsLen = rhs.GetLen();
unsigned short totalLen = itsLen + rhsLen;
String temp(totalLen);
for (unsigned short i = 0; i<itsLen; i++)
temp[i] = itsString[i];
for (unsigned short j = 0; j<rhs.GetLen(); j++, i++)
temp[i] = rhs[i-itsLen];
temp[totalLen]='\0';
*this = temp;
}143:
int main()
144:
{
145:
String s1("initial test");
146:
cout << "S1:\t" << s1.GetString() << endl;
147:
148:
char * temp = "Hello World";
149:
s1 = temp;
150:
cout << "S1:\t" << s1.GetString() << endl;
151:
152:
char tempTwo[20];
153:
strcpy(tempTwo,"; nice to be here!");
154:
s1 += tempTwo;
155:
cout << "tempTwo:\t" << tempTwo << endl;
156:
cout << "S1:\t" << s1.GetString() << endl;
157:
158:
cout << "S1[4]:\t" << s1[4] << endl;
159:
s1[4]='x';
160:
cout << "S1:\t" << s1.GetString() << endl;
161:
162:
cout << "S1[999]:\t" << s1[999] << endl;
163:
164:
String s2(" Another string");
165:
String s3;
166:
s3 = s1+s2;
167:
cout << "S3:\t" << s3.GetString() << endl;
168:
169:
String s4;
170:
s4 = "Why does this work?";
171:
cout << "S4:\t" << s4.GetString() << endl;
172:
return 0;
173: }
Output: S1:
initial test
S1:
Hello world
tempTwo:
; nice to be
S1:
Hello world; nice to
S1[4]:
o
S1:
Hellx World; nice to
S1[999]:
!
S3:
Hellx World; nice to
S4:
Why does this work?
here!
be here!
be here!
be here! Another string
Analysis: Lines 7-31 are the declaration of a simple String class. Lines 11-13 contain three
constructors: the default constructor, the copy constructor, and a constructor that takes an existing null-
terminated (C-style) string.
This String class overloads the offset operator ([ ]), operator plus (+), and operator plus-equals(+=). The offset operator is overloaded twice: once as a constant function returning a char and again
as a nonconstant function returning a reference to a char.
The nonconstant version is used in statements such as
SomeString[4]='x';
as seen in line 159. This enables direct access to each of the characters in the string. A reference to the
character is returned so that the calling function can manipulate it.
The constant version is used when a constant String object is being accessed, such as in the
implementation of the copy constructor, (line 63). Note that rhs[i] is accessed, yet rhs is declared
as a const String &. It isn't legal to access this object by using a nonconstant member function.
Therefore, the reference operator must be overloaded with a constant accessor.
If the object being returned were large, you might want to declare the return value to be a constant
reference. However, because a char is only one byte, there would be no point in doing that.
The default constructor is implemented in lines 33-39. It creates a string whose length is 0. It is the
convention of this String class to report its length not counting the terminating null. This default
string contains only a terminating null.
The copy constructor is implemented in lines 63-70. It sets the new string's length to that of the
existing string--plus 1 for the terminating null. It copies each character from the existing string to the
new string, and it null-terminates the new string.
Lines 53-60 implement the constructor that takes an existing C-style string. This constructor is similar
to the copy constructor. The length of the existing string is established by a call to the standard
String library function strlen().
On line 28, another constructor, String(unsigned short), is declared to be a private member
function. It is the intent of the designer of this class that no client class ever create a String of
arbitrary length. This constructor exists only to help in the internal creation of Strings as required,
for example, by operator+=, on line 130. This will be discussed in depth when operator+= is
described, below.
The String(unsigned short) constructor fills every member of its array with NULL.
Therefore, the for loop checks for i<=len rather than i<len.
The destructor, implemented in lines 73-77, deletes the character string maintained by the class. Be
sure to include the brackets in the call to the delete operator, so that every member of the array is
deleted, instead of only the first.
The assignment operator first checks whether the right-hand side of the assignment is the same as the
left-hand side. If it isn't, the current string is deleted, and the new string is created and copied intoplace. A reference is returned to facilitate assignments lik
String1 = String2 = String3;
The offset operator is overloaded twice. Rudimentary bounds checking is performed both times. If the
user attempts to access a character at a location beyond the end of the array, the last character--that is,
len-1--is returned.
Lines 117-127 implement operator plus (+) as a concatenation operator. It is convenient to be able to
write
String3 = String1 + String2;
and have String3 be the concatenation of the other two strings. To accomplish this, the operator
plus function computes the combined length of the two strings and creates a temporary string temp.
This invokes the private constructor, which takes an integer, and creates a string filled with nulls. The
nulls are then replaced by the contents of the two strings. The left-hand side string (*this) is copied
first, followed by the right-hand side string (rhs).
The first for loop counts through the string on the left-hand side and adds each character to the new
string. The second for loop counts through the right-hand side. Note that i continues to count the
place for the new string, even as j counts into the rhs string.
Operator plus returns the temp string by value, which is assigned to the string on the left-hand side of
the assignment (string1). Operator += operates on the existing string--that is, the left-hand side of
the statement string1 += string2. It works just like operator plus, except that the temp value
is assigned to the current string (*this = temp) in line 140.
The main()function (lines 143-173) acts as a test driver program for this class. Line 145 creates a
String object by using the constructor that takes a null-terminated C-style string. Line 146 prints its
contents by using the accessor function GetString(). Line 148 creates another C-style string. Line
149 tests the assignment operator, and line 150 prints the results.
Line 152 creates a third C-style string, tempTwo. Line 153 invokes strcpy to fill the buffer with the
characters ; nice to be here! Line 154 invokes operator += and concatenates tempTwo onto
the existing string s1. Line 156 prints the results.
In line 158, the fifth character in s1 is accessed and printed. It is assigned a new value in line 159.
This invokes the nonconstant offset operator ([ ]). Line 160 prints the result, which shows that the
actual value has, in fact, been changed.
Line 162 attempts to access a character beyond the end of the array. The last character of the array is
returned, as designed.
Lines 164-165 create two more String objects, and line 166 calls the addition operator. Line 167prints the results.
Line 169 creates a new String object, s4. Line 170 invokes the assignment operator. Line 171
prints the results. You might be thinking, "The assignment operator is defined to take a constant
String reference in line 21, but here the program passes in a C-style string. Why is this legal?"
The answer is that the compiler expects a String, but it is given a character array. Therefore, it
checks whether it can create a String from what it is given. In line 12, you declared a constructor
that creates Strings from character arrays. The compiler creates a temporary String from the
character array and passes it to the assignment operator. This is known as implicit casting, or
promotion. If you had not declared--and provided the implementation for--the constructor that takes a
character array, this assignment would have generated a compiler error.
Linked Lists and Other Structures
Arrays are much like Tupperware. They are great containers, but they are of a fixed size. If you pick a
container that is too large, you waste space in your storage area. If you pick one that is too small, its
contents spill all over and you have a big mess.
One way to solve this problem is with a linked list. A linked list is a data structure that consists of
small containers that are designed to fit and that are linked together as needed. The idea is to write a
class that holds one object of your data--such as one CAT or one Rectangle--and that can point at
the next container. You create one container for each object that you need to store, and you chain them
together as needed.
The containers are called nodes. The first node in the list is called the head, and the last node in the list
is called the tail.
Lists come in three fundamental forms. From simplest to most complex, they are
)** Singly linked
%,( Doubly linked
"%! Trees
In a singly linked list, each node points forward to the next one, but not backward. To find a particular
node, start at the top and go from node to node, as in a treasure hunt ("The next node is under the
sofa"). A doubly linked list enables you to move backward and forward in the chain. A tree is a
complex structure built from nodes, each of which can point in two or three directions. Figure 11.5
shows these three fundamental structures.
Computer scientists have created even more complex and clever data structures, nearly all of which
rely on interconnecting nodes. Listing 11.13 shows how to create and use a simple linked list.Figure 11.5 Linked lists.
Listing 11.13. Implementing a linked list .
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
// Listing 11.13
// Linked list simple implementation
#include <iostream.h>
// object to add to list
class CAT
{
public:
CAT() { itsAge = 1;}
CAT(int age):itsAge(age){}
~CAT(){};
int GetAge() const { return itsAge; }
private:
int itsAge;
};
// manages list, orders by cat's age!
class Node
{
public:
Node (CAT*);
~Node();
void SetNext(Node * node) { itsNext = node; }
Node * GetNext() const { return itsNext; }
CAT * GetCat() const { return itsCat; }
void Insert(Node *);
void Display();
private:
CAT *itsCat;
Node * itsNext;
};
Node::Node(CAT* pCat):
itsCat(pCat),
itsNext(0)
{}
Node::~Node()
{42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
)
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
cout << "Deleting node...\n";
delete itsCat;
itsCat = 0;
delete itsNext;
itsNext = 0;
}
// ************************************
// Insert
// Orders cats based on their ages
// Algorithim: If you are last in line, add the cat
// Otherwise, if the new cat is older than you
// and also younger than next in line, insert it after
// this one. Otherwise call insert on the next in line
// ************************************
void Node::Insert(Node* newNode)
{
if (!itsNext)
itsNext = newNode;
else
{
int NextCatsAge = itsNext->GetCat()->GetAge();
int NewAge = newNode->GetCat()->GetAge();
int ThisNodeAge = itsCat->GetAge();
if (
NewAge >= ThisNodeAge && NewAge < NextCatsAge
{
newNode->SetNext(itsNext);
itsNext = newNode;
}
else
itsNext->Insert(newNode);
}
}
void Node::Display()
{
if (itsCat->GetAge() > 0)
{
cout << "My cat is ";
cout << itsCat->GetAge() << " years old\n";
}
if (itsNext)
itsNext->Display();
}87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111: }
int main()
{
Node *pNode = 0;
CAT * pCat = new CAT(0);
int age;
Node *pHead = new Node(pCat);
while (1)
{
cout << "New Cat's age? (0 to quit): ";
cin >> age;
if (!age)
break;
pCat = new CAT(age);
pNode = new Node(pCat);
pHead->Insert(pNode);
}
pHead->Display();
delete pHead;
cout << "Exiting...\n\n";
return 0;
Output: New Cat's
New Cat's age? (0
New Cat's age? (0
New Cat's age? (0
New Cat's age? (0
New Cat's age? (0
New Cat's age? (0
My cat is 1 years
My cat is 2 years
My cat is 3 years
My cat is 5 years
My cat is 7 years
My cat is 9 years
Deleting node...
Deleting node...
Deleting node...
Deleting node...
Deleting node...
Deleting node...
Deleting node...
age? (0 to quit): 1
to quit): 9
to quit): 3
to quit): 7
to quit): 2
to quit): 5
to quit): 0
old
old
old
old
old
oldExiting...
Analysis: Lines 7-16 declare a simplified CAT class. It has two constructors, a default constructor that
initializes the member variable itsAge to 1, and a constructor that takes an integer and initializes
itsAge to that value.
Lines 19-32 declare the class Node. Node is designed specifically to hold a CAT object in a list.
Normally, you would hide Node inside a CatList class. It is exposed here to illustrate how linked
lists work.
It is possible to make a more generic Node that would hold any kind of object in a list. You'll learn
about doing that on Day 14, "Special Classes and Functions," when templates are discussed.
Node's constructor takes a pointer to a CAT object. The copy constructor and assignment operator
have been left out to save space. In a real-world application, they would be included.
Three accessor functions are defined. SetNext() sets the member variable itsNext to point to the
Node object supplied as its parameter. GetNext() and GetCat() return the appropriate member
variables. GetNext() and GetCat() are declared const because they don't change the Node
object.
Insert() is the most powerful member function in the class. Insert() maintains the linked list
and adds Nodes to the list based on the age of the CAT that they point to.
The program begins at line 88. The pointer pNode is created and initialized to 0. A dummy CAT
object is created, and its age is initialized to 0, to ensure that the pointer to the head of the list
(pHead) is always first.
Beginning on line 99, the user is prompted for an age. If the user presses 0, this is taken as a signal that
no more CAT objects are to be created. For all other values, a CAT object is created on line 103, and
the member variable itsAge is set to the supplied value. The CAT objects are created on the free
store. For each CAT created, a Node object is created on line 104.
After the CAT and Node objects are created, the first Node in the list is told to insert the newly
created node, on line 105.
Note that the program doesn't know--or care--how Node is inserted or how the list is maintained. That
is entirely up to the Node object itself.
The call to Insert() causes program execution to jump to line 57. Insert() is always called on
pHead first.
The test in line 59 fails the first time a new Node is added. Therefore, pHead is pointed at the first
new Node. In the output, this is the node with a CAT whose itsAge value was set to 1.When the second CAT object's itsAge variable is set to 9, pHead is called again. This time, its
member variable itsNext isn't null, and the else statement in lines 61 to 74 is invoked.
Three local variables--NextCatsAge, NewAge, and ThisNodeAge--are filled with the values of
The current Node's age--the age of pHead's CAT is 0
The age of the CAT held by the new Node--in this case, 9
The age of the CAT object held by the next node in line--in this case, 1
The test in line 67 could have been written as
if ( newNode->GetCat()->GetAge() > itsCat->GetAge() && \\
newNode->GetCat()->GetAge()< itsNext->GetCat()->GetAge())
which would have eliminated the three temporary variables while creating code that is more confusing
and harder to read. Some C++ programmers see this as macho--until they have a bug and can't figure
out which one of the values is wrong.
If the new CAT's age is greater than the current CAT's age and less than the next CAT's age, the proper
place to insert the new CAT's age is immediately after the current Node. In this case, the if statement
is true. The new Node is set to point to what the current Node points to, and the current Node is set
to point to the new Node. Figure 11.6 illustrates this.
Figure 11.6. Inserting a Node.
If the test fails, this isn't the proper place to insert the Node, and Insert() is called on the next
Node in the list. Note that the current call to Insert() doesn't return until after the recursive call to
Insert() returns. Therefore, these calls pile up on the stack. If the list gets too long, it will blow the
stack and crash the program. There are other ways to do this that aren't so stack-intensive, but they are
beyond the scope of this book.
Once the user is finished adding CAT objects, display is called on the first Node: pHead. The CAT
object's age is displayed if the current Node points to a CAT (pHead does not). Then, if the current
Node points to another Node, display() is called on that Node.
Finally, delete is called on pHead. Because the destructor deletes the pointer to the next Node,
delete is called on that Node as well. It walks the entire list, eliminating each Node and freeing the
memory of itsCat. Note that the last Node has its member variable itsNext set to zero, and
delete is called on that pointer as well. It is always safe to call delete on zero, for it has no effect.
Array Classes
Writing your own Array class has many advantages over using the built-in arrays. For starters, you
can prevent array overruns. You might also consider making your array class dynamically sized: Atcreation it might have only one member, growing as needed during the course of the program.
You might want to sort or otherwise order the members of the array. There are a number of powerful
Array variants you might consider. Among the most popular are:
)') Ordered collection: Each member is in sorted order.
$/+ Set: No member appears more than once.
/). Dictionary: This uses matched pairs in which one value acts as a key to retrieve the other value.
)'!
&),
Sparse array: Indices are permitted for a large set, but only those values actually added to the
array consume memory. Thus, you can ask for SparseArray[5] or SparseArray[200],
but it is possible that memory is allocated only for a small number of entries.
Bag: An unordered collection that is added to and retrieved in random order.
By overloading the index operator ([ ]), you can turn a linked list into an ordered collection. By
excluding duplicates, you can turn a collection into a set. If each object in the list has a pair of matched
values, you can use a linked list to build a dictionary or a sparse array.
Summary
Today you learned how to create arrays in C++. An array is a fixed-size collection of objects that are
all of the same type.
Arrays don't do bounds checking. Therefore it is legal--even if disastrous--to read or write past the end
of an array. Arrays count from 0. A common mistake is to write to offset n of an array of n members.
Arrays can be one dimensional or multidimensional. In either case, the members of the array can be
initialized, as long as the array contains either built-in types, such as int, or objects of a class that has
a default constructor.
Arrays and their contents can be on the free store or on the stack. If you delete an array on the free
store, remember to use the brackets in the call to delete.
Array names are constant pointers to the first elements of the array. Pointers and arrays use pointer
arithmetic to find the next element of an array.
You can create linked lists to manage collections whose size you won't know at compile time. From
linked lists, you can create any number of more complex data structures.
Strings are arrays of characters, or chars. C++ provides special features for managing char arrays,
including the ability to initialize them with quoted strings.Q&A
Q. What happens if I write to element 25 in a 24-member array?
A. You will write to other memory, with potentially disastrous effects on your program.
Q. What is in an uninitialized array element?
A. Whatever happens to be in memory at a given time. The results of using this member
without assigning a value are unpredictable.
Q. Can I combine arrays?
A. Yes. With simple arrays you can use pointers to combine them into a new, larger array. With
strings you can use some of the built-in functions, such as strcat, to combine strings.
Q. Why should I create a linked list if an array will work?
A. An array must have a fixed size, whereas a linked list can be sized dynamically at runtime.
Q. Why would I ever use built-in arrays if I can make a better array class?
A. Built-in arrays are quick and easy to use.
Q. Must a string class use a char * to hold the contents of the string?
A. No. It can use any memory storage the designer thinks is best.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material covered
and exercises to provide you with experience in using what you've learned. Try to answer the quiz and
exercise questions before checking the answers in Appendix D, and make sure you understand the
answers before continuing to the next chapter.
Quiz
1. What are the first and last elements in SomeArray[25]?
2. How do you declare a multidimensional array?
3. Initialize the members of the array in Question 2.
4. How many elements are in the array SomeArray[10][5][20]?
5. What is the maximum number of elements that you can add to a linked list?6. Can you use subscript notation on a linked list?
7. What is the last character in the string "Brad is a nice guy"?
Exercises
1. Declare a two-dimensional array that represents a tic-tac-toe game board.
2. Write the code that initializes all the elements in the array you created in Exercise 1 to the
value 0.
3. Write the declaration for a Node class that holds unsigned short integers.
4. BUG BUSTERS: What is wrong with this code fragment?
unsigned short SomeArray[5][4];
for (int i = 0; i<4; i++)
for (int j = 0; j<5; j++)
SomeArray[i][j] = i+j;
5. BUG BUSTERS: What is wrong with this code fragment?
unsigned short SomeArray[5][4];
for (int i = 0; i<=5; i++)
for (int j = 0; j<=4; j++)
SomeArray[i][j] = 0;
Day 12
Inheritance
What Is Inheritance?
What is a dog? When you look at your pet, what do you see? A biologist sees a network of interacting
organs, a physicist sees atoms and forces at work, and a taxonomist sees a representative of the
species canine domesticus.
It is that last assessment that interests us at the moment. A dog is a kind of canine, a canine is a kind
of mammal, and so forth. Taxonomists divide the world of living things into Kingdom, Phylum, Class,
Order, Family, Genus, and Species.
This hierarchy establishes an is-a relationship. A dog is a kind of canine. We see this relationship
everywhere: A Toyota is a kind of car, which is a kind of vehicle. A sundae is a kind of dessert, which
is a kind of food.
What do we mean when we say something is a kind of something else? We mean that it is a
specialization of that thing. That is, a car is a special kind of vehicle.
Inheritance and DerivationThe concept dog inherits, that is, it automatically gets, all the features of a mammal. Because it is a
mammal, we know that it moves and that it breathes air--all mammals move and breathe air by
definition. The concept of a dog adds the idea of barking, wagging its tail, and so forth to that
definition. We can further divide dogs into hunting dogs and terriers, and we can divide terriers into
Yorkshire Terriers, Dandie Dinmont Terriers, and so forth.
A Yorkshire Terrier is a kind of terrier, therefore it is a kind of dog, therefore a kind of mammal,
therefore a kind of animal, and therefore a kind of living thing. This hierarchy is represented in Figure
12.1.
Figure 12.1.Hierarchy of Animals.
C++ attempts to represent these relationships by enabling you to define classes that derive from one
another. Derivation is a way of expressing the is-a relationship. You derive a new class, Dog, from the
class Mammal. You don't have to state explicitly that dogs move, because they inherit that from
Mammal.
New Term: A class which adds new functionality to an existing class is said to derive from
that original class. The original class is said to be the new class's base class.
If the Dog class derives from the Mammal class, then Mammal is a base class of Dog. Derived classes
are supersets of their base classes. Just as dog adds certain features to the idea of mammal, the Dog
class will add certain methods or data to the Mammal class.
Typically, a base class will have more than one derived class. Just as dogs, cats, and horses are all
types of mammals, their classes would all derive from the Mammal class.
The Animal Kingdom
To facilitate the discussion of derivation and inheritance, this chapter will focus on the relationships
among a number of classes representing animals. You can imagine that you have been asked to design
a children's game--a simulation of a farm.
In time you will develop a whole set of farm animals, including horses, cows, dogs, cats, sheep, and
so forth. You will create methods for these classes so that they can act in the ways the child might
expect, but for now you'll stub-out each method with a simple print statement.
Stubbing-out a function means you'll write only enough to show that the function was called, leaving
the details for later when you have more time. Please feel free to extend the minimal code provided in
this chapter to enable the animals to act more realistically.
The Syntax of DerivationWhen you declare a class, you can indicate what class it derives from by writing a colon after the class
name, the type of derivation (public or otherwise), and the class from which it derives. The following
is an example.
class Dog : public Mammal
The type of derivation will be discussed later in this chapter. For now, always use public. The class
from which you derive must have been declared earlier, or you will get a compiler error. Listing 12.1
illustrates how to declare a Dog class that is derived from a Mammal class.
Listing 12.1. Simple inheritance.
1:
2:
3:
4:
};
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
//Listing 12.1 Simple inheritance
#include <iostream.h>
enum BREED { YORKIE, CAIRN, DANDIE, SHETLAND, DOBERMAN, LAB
class Mammal
{
public:
// constructors
Mammal();
~Mammal();
//accessors
int GetAge()const;
void SetAge(int);
int GetWeight() const;
void SetWeight();
//Other methods
void Speak();
void Sleep();
protected:
int itsAge;
int itsWeight;
};
class Dog : public Mammal
{
public:33:
// Constructors
34:
Dog();
35:
~Dog();
36:
37:
// Accessors
38:
BREED GetBreed() const;
39:
void SetBreed(BREED);
40:
41:
// Other methods
42:
// WagTail();
43:
// BegForFood();
44:
45:
protected:
46:
BREED itsBreed;
47: };
This program has no output because it is only a set of class declarations without their
implementations. Nonetheless, there is much to see here.
Analysis: On lines 6-27, the Mammal class is declared. Note that in this example, Mammal does not
derive from any other class. In the real world, mammals do derive--that is, mammals are kinds of
animals. In a C++ program, you can represent only a fraction of the information you have about any
given object. Reality is far too complex to capture all of it, so every C++ hierarchy is an arbitrary
representation of the data available. The trick of good design is to represent the areas that you care
about in a way that maps back to reality in a reasonably faithful manner.
The hierarchy has to begin somewhere; this program begins with Mammal. Because of this decision,
some member variables that might properly belong in a higher base class are now represented here.
For example, certainly all animals have an age and weight, so if Mammal is derived from Animal,
we might expect to inherit those attributes. As it is, the attributes appear in the Mammal class.
To keep the program reasonably simple and manageable, only six methods have been put in the
Mammal class--four accessor methods, Speak(), and Sleep().
The Dog class inherits from Mammal, as indicated on line 29. Every Dog object will have three
member variables: itsAge, itsWeight, and itsBreed. Note that the class declaration for Dog
does not include the member variables itsAge and itsWeight. Dog objects inherit these variables
from the Mammal class, along with all of Mammal's methods except the copy operator and the
constructors and destructor.
Private Versus Protected
You may have noticed that a new access keyword, protected, has been introduced on lines 24 and
45 of Listing 12.1. Previously, class data had been declared private. However, private membersare not available to derived classes. You could make itsAge and itsWeight public, but that is not
desirable. You don't want other classes accessing these data members directly.
What you want is a designation that says, "Make these visible to this class and to classes that derive
from this class." That designation is protected. Protected data members and functions are fully visible
to derived classes, but are otherwise private.
There are, in total, three access specifiers: public, protected, and private. If a function has an object of
your class, it can access all the public member data and functions. The member functions, in turn, can
access all private data members and functions of their own class, and all protected data members and
functions of any class from which they derive.
Thus, the function Dog::WagTail() can access the private data itsBreed and can access the
protected data in the Mammal class.
Even if other classes are layered between Mammal and Dog (for example, DomesticAnimals), the
Dog class will still be able to access the protected members of Mammal, assuming that these other
classes all use public inheritance. Private inheritance is discussed on Day 15, "Advanced Inheritance."
Listing 12.2 demonstrates how to create objects of type Dog and access the data and functions of that
type.
Listing 12.2. Using a derived object.
1:
2:
3:
4:
};
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
//Listing 12.2 Using a derived object
#include <iostream.h>
enum BREED { YORKIE, CAIRN, DANDIE, SHETLAND, DOBERMAN, LAB
class Mammal
{
public:
// constructors
Mammal():itsAge(2), itsWeight(5){}
~Mammal(){}
//accessors
int GetAge()const { return itsAge; }
void SetAge(int age) { itsAge = age; }
int GetWeight() const { return itsWeight; }
void SetWeight(int weight) { itsWeight = weight; }
//Other methods
void Speak()const { cout << "Mammal sound!\n"; }21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56: }
void Sleep()const { cout << "shhh. I'm sleeping.\n"; }
protected:
int itsAge;
int itsWeight;
};
class Dog : public Mammal
{
public:
// Constructors
Dog():itsBreed(YORKIE){}
~Dog(){}
// Accessors
BREED GetBreed() const { return itsBreed; }
void SetBreed(BREED breed) { itsBreed = breed; }
// Other methods
void WagTail() { cout << "Tail wagging...\n"; }
void BegForFood() { cout << "Begging for food...\n"; }
private:
BREED itsBreed;
};
int main()
{
Dog fido;
fido.Speak();
fido.WagTail();
cout << "Fido is " << fido.GetAge() << " years old\n";
return 0;
Output: Mammal sound!
Tail wagging...
Fido is 2 years old
Analysis: On lines 6-27, the Mammal class is declared (all of its functions are inline to save space
here). On lines 29-47, the Dog class is declared as a derived class of Mammal. Thus, by these
declarations, all Dogs have an age, a weight, and a breed.On line 51, a Dog is declared: Fido. Fido inherits all the attributes of a Mammal, as well as all the
attributes of a Dog. Thus, Fido knows how to WagTail(), but also knows how to Speak() and
Sleep().
Constructors and Destructors
Dog objects are Mammal objects. This is the essence of the is-a relationship. When Fido is created,
his base constructor is called first, creating a Mammal. Then the Dog constructor is called, completing
the construction of the Dog object. Because we gave Fido no parameters, the default constructor was
called in each case. Fido doesn't exist until he is completely constructed, which means that both his
Mammal part and his Dog part must be constructed. Thus, both constructors must be called.
When Fido is destroyed, first the Dog destructor will be called and then the destructor for the
Mammal part of Fido. Each destructor is given an opportunity to clean up after its own part of Fido.
Remember to clean up after your Dog! Listing 12.3 demonstrates this.
Listing 12.3. Constructors and destructors called.
1:
2:
3:
4:
};
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
//Listing 12.3 Constructors and destructors called.
#include <iostream.h>
enum BREED { YORKIE, CAIRN, DANDIE, SHETLAND, DOBERMAN, LAB
class Mammal
{
public:
// constructors
Mammal();
~Mammal();
//accessors
int GetAge() const { return itsAge; }
void SetAge(int age) { itsAge = age; }
int GetWeight() const { return itsWeight; }
void SetWeight(int weight) { itsWeight = weight; }
//Other methods
void Speak() const { cout << "Mammal sound!\n"; }
void Sleep() const { cout << "shhh. I'm sleeping.\n"; }
protected:
int itsAge;
int itsWeight;27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
};
class Dog : public Mammal
{
public:
// Constructors
Dog();
~Dog();
// Accessors
BREED GetBreed() const { return itsBreed; }
void SetBreed(BREED breed) { itsBreed = breed; }
// Other methods
void WagTail() { cout << "Tail wagging...\n"; }
void BegForFood() { cout << "Begging for food...\n"; }
private:
BREED itsBreed;
};
Mammal::Mammal():
itsAge(1),
itsWeight(5)
{
cout << "Mammal constructor...\n";
}
Mammal::~Mammal()
{
cout << "Mammal destructor...\n";
}
Dog::Dog():
itsBreed(YORKIE)
{
cout << "Dog constructor...\n";
}
Dog::~Dog()
{
cout << "Dog destructor...\n";
}
int main()
{73:
74:
75:
76:
77:
78: }
Dog fido;
fido.Speak();
fido.WagTail();
cout << "Fido is " << fido.GetAge() << " years old\n";
return 0;
Output: Mammal constructor...
Dog constructor...
Mammal sound!
Tail wagging...
Fido is 1 years old
Dog destructor...
Mammal destructor...
Analysis: Listing 12.3 is just like Listing 12.2, except that the constructors and destructors now print
to the screen when called. Mammal's constructor is called, then Dog's. At that point the Dog fully
exists, and its methods can be called. When fido goes out of scope, Dog's destructor is called,
followed by a call to Mammal's destructor.
Passing Arguments to Base Constructors
It is possible that you'll want to overload the constructor of Mammal to take a specific age, and that
you'll want to overload the Dog constructor to take a breed. How do you get the age and weight
parameters passed up to the right constructor in Mammal? What if Dogs want to initialize weight but
Mammals don't?
Base class initialization can be performed during class initialization by writing the base class name,
followed by the parameters expected by the base class. Listing 12.4 demonstrates this.
Listing 12.4. Overloading constructors in derived classes.
1:
2:
3:
4:
};
5:
6:
7:
8:
9:
10:
11:
//Listing 12.4 Overloading constructors in derived classes
#include <iostream.h>
enum BREED { YORKIE, CAIRN, DANDIE, SHETLAND, DOBERMAN, LAB
class Mammal
{
public:
// constructors
Mammal();
Mammal(int age);12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
~Mammal();
//accessors
int GetAge() const { return itsAge; }
void SetAge(int age) { itsAge = age; }
int GetWeight() const { return itsWeight; }
void SetWeight(int weight) { itsWeight = weight; }
//Other methods
void Speak() const { cout << "Mammal sound!\n"; }
void Sleep() const { cout << "shhh. I'm sleeping.\n"; }
protected:
int itsAge;
int itsWeight;
};
class Dog : public Mammal
{
public:
// Constructors
Dog();
Dog(int age);
Dog(int age, int weight);
Dog(int age, BREED breed);
Dog(int age, int weight, BREED breed);
~Dog();
// Accessors
BREED GetBreed() const { return itsBreed; }
void SetBreed(BREED breed) { itsBreed = breed; }
// Other methods
void WagTail() { cout << "Tail wagging...\n"; }
void BegForFood() { cout << "Begging for food...\n"; }
private:
BREED itsBreed;
};
Mammal::Mammal():
itsAge(1),
itsWeight(5)
{58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
cout << "Mammal constructor...\n";
}
Mammal::Mammal(int age):
itsAge(age),
itsWeight(5)
{
cout << "Mammal(int) constructor...\n";
}
Mammal::~Mammal()
{
cout << "Mammal destructor...\n";
}
Dog::Dog():
Mammal(),
itsBreed(YORKIE)
{
cout << "Dog constructor...\n";
}
Dog::Dog(int age):
Mammal(age),
itsBreed(YORKIE)
{
cout << "Dog(int) constructor...\n";
}
Dog::Dog(int age, int weight):
Mammal(age),
itsBreed(YORKIE)
{
itsWeight = weight;
cout << "Dog(int, int) constructor...\n";
}
Dog::Dog(int age, int weight, BREED breed):
Mammal(age),
itsBreed(breed)
{
itsWeight = weight;
cout << "Dog(int, int, BREED) constructor...\n";
}
Dog::Dog(int age, BREED breed):104:
Mammal(age),
105:
itsBreed(breed)
106:
{
107:
cout << "Dog(int, BREED) constructor...\n";
108:
}
109:
110:
Dog::~Dog()
111:
{
112:
cout << "Dog destructor...\n";
113:
}
114:
int main()
115:
{
116:
Dog fido;
117:
Dog rover(5);
118:
Dog buster(6,8);
119:
Dog yorkie (3,YORKIE);
120:
Dog dobbie (4,20,DOBERMAN);
121:
fido.Speak();
122:
rover.WagTail();
123:
cout << "Yorkie is " << yorkie.GetAge() << " years
old\n";
124:
cout << "Dobbie weighs ";
125:
cout << dobbie.GetWeight() << " pounds\n";
126:
return 0;
127: }
NOTE: The output has been numbered here so that each line can be referred to in the
analysis.
Output: 1: Mammal constructor...
2: Dog constructor...
3: Mammal(int) constructor...
4: Dog(int) constructor...
5: Mammal(int) constructor...
6: Dog(int, int) constructor...
7: Mammal(int) constructor...
8: Dog(int, BREED) constructor....
9: Mammal(int) constructor...
10: Dog(int, int, BREED) constructor...
11: Mammal sound!
12: Tail wagging...
13: Yorkie is 3 years old.
14: Dobbie weighs 20 pounds.
15: Dog destructor. . .16:
17:
18:
19:
20:
21:
22:
23:
24:
Mammal destructor...
Dog destructor...
Mammal destructor...
Dog destructor...
Mammal destructor...
Dog destructor...
Mammal destructor...
Dog destructor...
Mammal destructor...
Analysis: In Listing 12.4, Mammal's constructor has been overloaded on line 11 to take an integer,
the Mammal's age. The implementation on lines 61-66 initializes itsAge with the value passed into
the constructor and initializes itsWeight with the value 5.
Dog has overloaded five constructors, on lines 35-39. The first is the default constructor. The second
takes the age, which is the same parameter that the Mammal constructor takes. The third constructor
takes both the age and the weight, the fourth takes the age and breed, and the fifth takes the age,
weight, and breed.
Note that on line 74 Dog's default constructor calls Mammal's default constructor. Although it is not
strictly necessary to do this, it serves as documentation that you intended to call the base constructor,
which takes no parameters. The base constructor would be called in any case, but actually doing so
makes your intentions explicit.
The implementation for the Dog constructor, which takes an integer, is on lines 80-85. In its
initialization phase (lines 81-82), Dog initializes its base class, passing in the parameter, and then it
initializes its breed.
Another Dog constructor is on lines 87-93. This one takes two parameters. Once again it initializes its
base class by calling the appropriate constructor, but this time it also assigns weight to its base
class's variable itsWeight. Note that you cannot assign to the base class variable in the
initialization phase. Because Mammal does not have a constructor that takes this parameter, you must
do this within the body of the Dog's constructor.
Walk through the remaining constructors to make sure you are comfortable with how they work. Note
what is initialized and what must wait for the body of the constructor.
The output has been numbered so that each line can be referred to in this analysis. The first two lines
of output represent the instantiation of Fido, using the default constructor.
In the output, lines 3 and 4 represent the creation of rover. Lines 5 and 6 represent buster. Note
that the Mammal constructor that was called is the constructor that takes one integer, but the Dog
constructor is the constructor that takes two integers.After all the objects are created, they are used and then go out of scope. As each object is destroyed,
first the Dog destructor and then the Mammal destructor is called, five of each in total.
Overriding Functions
A Dog object has access to all the member functions in class Mammal, as well as to any member
functions, such as WagTail(), that the declaration of the Dog class might add. It can also override a
base class function. Overriding a function means changing the implementation of a base class function
in a derived class. When you make an object of the derived class, the correct function is called.
New Term: When a derived class creates a function with the same return type and signature as
a member function in the base class, but with a new implementation, it is said to be overriding
that method.
When you override a function, it must agree in return type and in signature with the function in the
base class. The signature is the function prototype other than the return type: that is, the name, the
parameter list, and the keyword const if used.
New Term: The signature of a function is its name, as well as the number and type of its
parameters. The signature does not include the return type.
Listing 12.5 illustrates what happens if the Dog class overrides the Speak() method in Mammal. To
save room, the accessor functions have been left out of these classes.
Listing 12.5. Overriding a base class methodin a derived class.
1:
class
2:
3:
4:
};
5:
6:
7:
8:
9:
10:
11:
12:
13:
//Listing 12.5 Overriding a base class method in a derived
#include <iostream.h>
enum BREED { YORKIE, CAIRN, DANDIE, SHETLAND, DOBERMAN, LAB
class Mammal
{
public:
// constructors
Mammal() { cout << "Mammal constructor...\n"; }
~Mammal() { cout << "Mammal destructor...\n"; }
//Other methods14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47: }
void Speak()const { cout << "Mammal sound!\n"; }
void Sleep()const { cout << "shhh. I'm sleeping.\n"; }
protected:
int itsAge;
int itsWeight;
};
class Dog : public Mammal
{
public:
// Constructors
Dog(){ cout << "Dog constructor...\n"; }
~Dog(){ cout << "Dog destructor...\n"; }
// Other methods
void WagTail() { cout << "Tail wagging...\n"; }
void BegForFood() { cout << "Begging for food...\n"; }
void Speak()const { cout << "Woof!\n"; }
private:
BREED itsBreed;
};
int main()
{
Mammal bigAnimal;
Dog fido;
bigAnimal.Speak();
fido.Speak();
return 0;
Output: Mammal constructor...
Mammal constructor...
Dog constructor...
Mammal sound!
Woof!
Dog destructor...
Mammal destructor...
Mammal destructor...
Analysis: On line 34, the Dog class overrides the Speak() method, causing Dog objects to sayWoof! when the Speak() method is called. On line 42, a Mammal object, bigAnimal, is created,
causing the first line of output when the Mammal constructor is called. On line 43, a Dog object,
fido, is created, causing the next two lines of output, where the Mammal constructor and then the
Dog constructor are called.
On line 44, the Mammal object calls its Speak() method, then on line 45, the Dog object calls its
Speak() method. The output reflects that the correct methods were called. Finally, the two objects
go out of scope and the destructors are called.
Overloading Versus Overriding
These terms are similar, and they do similar things. When you overload a method, you create more
than one method with the same name, but with a different signature. When you override a method,
you create a method in a derived class with the same name as a method in the base class and the same
signature.
Hiding the Base Class Method
In the previous listing, the Dog class's Speak() method hides the base class's method. This is just
what is wanted, but it can have unexpected results. If Mammal has a method, Move(), which is
overloaded, and Dog overrides that method, the Dog method will hide all of the Mammal methods
with that name.
If Mammal overloads Move() as three methods--one that takes no parameters, one that takes an
integer, and one that takes an integer and a direction--and Dog overrides just the Move() method that
takes no parameters, it will not be easy to access the other two methods using a Dog object. Listing
12.6 illustrates this problem.
Listing 12.6. Hiding methods.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
//Listing 12.6 Hiding methods
#include <iostream.h>
class Mammal
{
public:
void Move() const { cout << "Mammal move one step\n"; }
void Move(int distance) const
{
cout << "Mammal move ";
cout << distance <<" _steps.\n";
}
protected:15:
int itsAge;
16:
int itsWeight;
17:
};
18:
19:
class Dog : public Mammal
20:
{
21:
public:
22: // You may receive a warning that you are hiding a function!
23:
void Move() const { cout << "Dog move 5 steps.\n"; }
24:
};
25:
26:
int main()
27:
{
28:
Mammal bigAnimal;
29:
Dog fido;
30:
bigAnimal.Move();
31:
bigAnimal.Move(2);
32:
fido.Move();
33:
// fido.Move(10);
34:
return 0;
35: }
Output: Mammal move one step
Mammal move 2 steps.
Dog move 5 steps.
Analysis: All of the extra methods and data have been removed from these classes. On lines 8 and 9,
the Mammal class declares the overloaded Move() methods. On line 18, Dog overrides the version
of Move() with no parameters. These are invoked on lines 30-32, and the output reflects this as
executed.
Line 33, however, is commented out, as it causes a compile-time error. While the Dog class could
have called the Move(int) method if it had not overridden the version of Move() without
parameters, now that it has done so it must override both if it wishes to use both. This is reminiscent
of the rule that if you supply any constructor, the compiler will no longer supply a default constructor.
It is a common mistake to hide a base class method when you intend to override it, by forgetting to
include the keyword const. const is part of the signature, and leaving it off changes the signature
and thus hides the method rather than overriding it.
Overriding Versus Hiding
In the next section, virtual methods are described. Overriding a virtual method supports
polymorphism--hiding it undermines polymorphism. You'll see more on this very soon.Calling the Base Method
If you have overridden the base method, it is still possible to call it by fully qualifying the name of the
method. You do this by writing the base name, followed by two colons and then the method name.
For example: Mammal::Move().
It would have been possible to rewrite line 28 in Listing 12.6 so that it would compile, by writing
28:
fido.Mammal::Move(10);
This calls the Mammal method explicitly. Listing 12.7 fully illustrates this idea.
Listing 12.7. Calling base method from overridden method.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
//Listing 12.7 Calling base method from overridden method.
#include <iostream.h>
class Mammal
{
public:
void Move() const { cout << "Mammal move one step\n"; }
void Move(int distance) const
{
cout << "Mammal move " << distance;
cout << " steps.\n";
}
protected:
int itsAge;
int itsWeight;
};
class Dog : public Mammal
{
public:
void Move()const;
};
void Dog::Move() const
{
cout << "In dog move...\n";
Mammal::Move(3);
}32:
33:
34:
35:
36:
37:
38:
39:
40: }
int main()
{
Mammal bigAnimal;
Dog fido;
bigAnimal.Move(2);
fido.Mammal::Move(6);
return 0;
Output: Mammal move 2 steps.
Mammal move 6 steps.
Analysis: On line 35, a Mammal, bigAnimal, is created, and on line 36, a Dog, fido, is created.
The method call on line 37 invokes the Move() method of Mammal, which takes an int.
The programmer wanted to invoke Move(int) on the Dog object, but had a problem. Dog overrides
the Move() method, but does not overload it and does not provide a version that takes an int. This
is solved by the explicit call to the base class Move(int) method on line 33.
DO extend the functionality of tested classes by deriving. DO change the behavior of
certain functions in the derived class by overriding the base class methods. DON'T hide
a base class function by changing the function signature.
Virtual Methods
This chapter has emphasized the fact that a Dog object is a Mammal object. So far that has meant only
that the Dog object has inherited the attributes (data) and capabilities (methods) of its base class. In
C++ the is-a relationship runs deeper than that, however.
C++ extends its polymorphism to allow pointers to base classes to be assigned to derived class
objects. Thus, you can write
Mammal* pMammal = new Dog;
This creates a new Dog object on the heap and returns a pointer to that object, which it assigns to a
pointer to Mammal. This is fine, because a dog is a mammal.
NOTE: This is the essence of polymorphism. For example, you could create many
different types of windows, including dialog boxes, scrollable windows, and list boxes,
and give them each a virtual draw() method. By creating a pointer to a window and
assigning dialog boxes and other derived types to that pointer, you can call draw()without regard to the actual run-time type of the object pointed to. The correct draw()
function will be called.
You can then use this pointer to invoke any method on Mammal. What you would like is for those
methods that are overridden in Dog() to call the correct function. Virtual functions let you do that.
Listing 12.8 illustrates how this works, and what happens with non-virtual methods.
Listing 12.8. Using virtual methods.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35: }
//Listing 12.8 Using virtual methods
#include <iostream.h>
class Mammal
{
public:
Mammal():itsAge(1) { cout << "Mammal constructor...\n"; }
~Mammal() { cout << "Mammal destructor...\n"; }
void Move() const { cout << "Mammal move one step\n"; }
virtual void Speak() const { cout << "Mammal speak!\n"; }
protected:
int itsAge;
};
class Dog : public Mammal
{
public:
Dog() { cout << "Dog Constructor...\n"; }
~Dog() { cout << "Dog destructor...\n"; }
void WagTail() { cout << "Wagging Tail...\n"; }
void Speak()const { cout << "Woof!\n"; }
void Move()const { cout << "Dog moves 5 steps...\n"; }
};
int main()
{
Mammal *pDog = new Dog;
pDog->Move();
pDog->Speak();
return 0;Output: Mammal constructor...
Dog Constructor...
Mammal move one step
Woof!
Analysis: On line 11, Mammal is provided a virtual method--speak(). The designer of this class
thereby signals that she expects this class eventually to be another class's base type. The derived class
will probably want to override this function.
On line 30, a pointer to Mammal is created (pDog), but it is assigned the address of a new Dog
object. Because a dog is a mammal, this is a legal assignment. The pointer is then used to call the
Move() function. Because the compiler knows pDog only to be a Mammal, it looks to the Mammal
object to find the Move() method.
On line 32, the pointer then calls the Speak() method. Because Speak() is virtual, the Speak()
method overridden in Dog is invoked.
This is almost magical. As far as the calling function knew, it had a Mammal pointer, but here a
method on Dog was called. In fact, if you had an array of pointers to Mammal, each of which pointed
to a subclass of Mammal, you could call each in turn and the correct function would be called. Listing
12.9 illustrates this idea.
Listing 12.9. Multiple virtual functions called in turn.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
//Listing 12.9 Multiple virtual functions called in turn
#include <iostream.h>
class Mammal
{
public:
Mammal():itsAge(1) { }
~Mammal() { }
virtual void Speak() const { cout << "Mammal speak!\n"; }
protected:
int itsAge;
};
class Dog : public Mammal
{
public:
void Speak()const { cout << "Woof!\n"; }
};21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
class Cat : public Mammal
{
public:
void Speak()const { cout << "Meow!\n"; }
};
class Horse : public Mammal
{
public:
void Speak()const { cout << "Winnie!\n"; }
};
class Pig : public Mammal
{
public:
void Speak()const { cout << "Oink!\n"; }
};
int main()
{
Mammal* theArray[5];
Mammal* ptr;
int choice, i;
for ( i = 0; i<5; i++)
{
cout << "(1)dog (2)cat (3)horse (4)pig: ";
cin >> choice;
switch (choice)
{
case 1: ptr = new Dog;
break;
case 2: ptr = new Cat;
break;
case 3: ptr = new Horse;
break;
case 4: ptr = new Pig;
break;
default: ptr = new Mammal;
break;
}
theArray[i] = ptr;
}
for (i=0;i<5;i++)
theArray[i]->Speak();67:
68: }
return 0;
Output: (1)dog (2)cat (3)horse
(1)dog (2)cat (3)horse (4)pig:
(1)dog (2)cat (3)horse (4)pig:
(1)dog (2)cat (3)horse (4)pig:
(1)dog (2)cat (3)horse (4)pig:
Woof!
Meow!
Winnie!
Oink!
Mammal speak!
(4)pig: 1
2
3
4
5
Analysis: This stripped-down program, which provides only the barest functionality to each class,
illustrates virtual functions in their purest form. Four classes are declared; Dog, Cat, Horse, and
Pig are all derived from Mammal.
On line 10, Mammal's Speak() function is declared to be virtual. On lines 18, 25, 32, and 38, the
four derived classes override the implementation of Speak().
The user is prompted to pick which objects to create, and the pointers are added to the array on lines
46-64.
NOTE: At compile time, it is impossible to know which objects will be created, and
thus which Speak() methods will be invoked. The pointer ptr is bound to its object
at runtime. This is called dynamic binding, or run-time binding, as opposed to static
binding, or compile-time binding.
How Virtual Functions Work
When a derived object, such as a Dog object, is created, first the constructor for the base class is
called and then the constructor for the derived class is called. Figure 12.2 shows what the Dog object
looks like after it is created. Note that the Mammal part of the object is contiguous in memory with
the Dog part.
Figure 12.2. The Dog object after it is created.
When a virtual function is created in an object, the object must keep track of that function. Many
compilers build a virtual function table, called a v-table. One of these is kept for each type, and each
object of that type keeps a virtual table pointer (called a vptr or v-pointer), which points to that
table.
While implementations vary, all compilers must accomplish the same thing, so you won't be toowrong with this description.
Figure 12.3. The v-table of a Mammal.
Each object's vptr points to the v-table which, in turn, has a pointer to each of the virtual functions.
(Note, pointers to functions will be discussed in depth on Day 14, "Special Classes and Functions.")
When the Mammal part of the Dog is created, the vptr is initialized to point to the correct part of the
v-table, as shown in Figure 12.3.
Figure 12.4. The v-table of a Dog.
When the Dog constructor is called, and the Dog part of this object is added, the vptr is adjusted to
point to the virtual function overrides (if any) in the Dog object (see Figure 12.4) .
When a pointer to a Mammal is used, the vptr continues to point to the correct function, depending
on the "real" type of the object. Thus, when Speak() is invoked, the correct function is invoked.
You Cant Get There from Here
If the Dog object had a method, WagTail(), which is not in the Mammal, you could not use the
pointer to Mammal to access that method (unless you cast it to be a pointer to Dog). Because
WagTail() is not a virtual function, and because it is not in a Mammal object, you can't get there
without either a Dog object or a Dog pointer.
Although you can transform the Mammal pointer into a Dog pointer, there are usually far better and
safer ways to call the WagTail() method. C++ frowns on explicit casts because they are error-
prone. This subject will be addressed in depth when multiple inheritance is covered tomorrow, and
again when templates are covered on Day 20, "Exceptions and Error Handling."
Slicing
Note that the virtual function magic operates only on pointers and references. Passing an object by
value will not enable the virtual functions to be invoked. Listing 12.10 illustrates this problem.
Listing 12.10. Data slicing when passing by value.
1:
2:
3:
4:
5:
6:
7:
8:
9:
//Listing 12.10 Data slicing with passing by value
#include <iostream.h>
enum BOOL { FALSE, TRUE };
class Mammal
{
public:
Mammal():itsAge(1) { }10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
~Mammal() { }
virtual void Speak() const { cout << "Mammal speak!\n"; }
protected:
int itsAge;
};
class Dog : public Mammal
{
public:
void Speak()const { cout << "Woof!\n"; }
};
class Cat : public Mammal
{
public:
void Speak()const { cout << "Meow!\n"; }
};
void ValueFunction (Mammal);
void PtrFunction
(Mammal*);
void RefFunction (Mammal&);
int main()
{
Mammal* ptr=0;
int choice;
while (1)
{
BOOL fQuit = FALSE;
cout << "(1)dog (2)cat (0)Quit: ";
cin >> choice;
switch (choice)
{
case 0: fQuit = TRUE;
break;
case 1: ptr = new Dog;
break;
case 2: ptr = new Cat;
break;
default: ptr = new Mammal;
break;
}
if (fQuit)
break;
PtrFunction(ptr);
RefFunction(*ptr);
ValueFunction(*ptr);56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73: }
}
return 0;
}
void ValueFunction (Mammal MammalValue)
{
MammalValue.Speak();
}
void PtrFunction (Mammal * pMammal)
{
pMammal->Speak();
}
void RefFunction (Mammal & rMammal)
{
rMammal.Speak();
Output: (1)dog (2)cat (0)Quit: 1
Woof
Woof
Mammal Speak!
(1)dog (2)cat (0)Quit: 2
Meow!
Meow!
Mammal Speak!
(1)dog (2)cat (0)Quit: 0
Analysis: On lines 6-26, stripped-down versions of the Mammal, Dog, and Cat classes are declared.
Three functions are declared--PtrFunction(), RefFunction(), and ValueFunction().
They take a pointer to a Mammal, a Mammal reference, and a Mammal object, respectively. All three
functions then do the same thing--they call the Speak() method.
The user is prompted to choose a Dog or Cat, and based on the choice he makes, a pointer to the
correct type is created on lines 44-49.
In the first line of the output, the user chooses Dog. The Dog object is created on the free store on line
44. The Dog is then passed as a pointer, as a reference, and by value to the three functions.
The pointer and references all invoke the virtual functions, and the Dog->Speak() member
function is invoked. This is shown on the first two lines of output after the user's choice.
The dereferenced pointer, however, is passed by value. The function expects a Mammal object, and so
the compiler slices down the Dog object to just the Mammal part. At that point, the Mammal
Speak() method is called, as reflected in the third line of output after the user's choice.This experiment is then repeated for the Cat object, with similar results.
Virtual Destructors
It is legal and common to pass a pointer to a derived object when a pointer to a base object is
expected. What happens when that pointer to a derived subject is deleted? If the destructor is virtual,
as it should be, the right thing happens--the derived class's destructor is called. Because the derived
class's destructor will automatically invoke the base class's destructor, the entire object will be
properly destroyed.
The rule of thumb is this: If any of the functions in your class are virtual, the destructor should be as
well.
Virtual Copy Constructors
As previously stated, no constructor can be virtual. Nonetheless, there are times when your program
desperately needs to be able to pass in a pointer to a base object and have a copy of the correct derived
object that is created. A common solution to this problem is to create a Clone() method in the base
class and to make that be virtual. The Clone() method creates a new object copy of the current
class, and returns that object.
Because each derived class overrides the Clone() method, a copy of the derived class is created.
Listing 12.11 illustrates how this is used.
Listing 12.11. Virtual copy constructor.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
//Listing 12.11 Virtual copy constructor
#include <iostream.h>
class Mammal
{
public:
Mammal():itsAge(1) { cout << "Mammal constructor...\n"; }
~Mammal() { cout << "Mammal destructor...\n"; }
Mammal (const Mammal & rhs);
virtual void Speak() const { cout << "Mammal speak!\n"; }
virtual Mammal* Clone() { return new Mammal(*this); }
int GetAge()const { return itsAge; }
protected:
int itsAge;
};
Mammal::Mammal (const Mammal & rhs):itsAge(rhs.GetAge())19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
{
cout << "Mammal Copy Constructor...\n";
}
class Dog : public Mammal
{
public:
Dog() { cout << "Dog constructor...\n"; }
~Dog() { cout << "Dog destructor...\n"; }
Dog (const Dog & rhs);
void Speak()const { cout << "Woof!\n"; }
virtual Mammal* Clone() { return new Dog(*this); }
};
Dog::Dog(const Dog & rhs):
Mammal(rhs)
{
cout << "Dog copy constructor...\n";
}
class Cat : public Mammal
{
public:
Cat() { cout << "Cat constructor...\n"; }
~Cat() { cout << "Cat destructor...\n"; }
Cat (const Cat &);
void Speak()const { cout << "Meow!\n"; }
virtual Mammal* Clone() { return new Cat(*this); }
};
Cat::Cat(const Cat & rhs):
Mammal(rhs)
{
cout << "Cat copy constructor...\n";
}
enum ANIMALS { MAMMAL, DOG, CAT};
const int NumAnimalTypes = 3;
int main()
{
Mammal *theArray[NumAnimalTypes];
Mammal* ptr;
int choice, i;
for ( i = 0; i<NumAnimalTypes; i++)
{
cout << "(1)dog (2)cat (3)Mammal: ";65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
25:
86: }
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
cin >> choice;
switch (choice)
{
case DOG: ptr = new Dog;
break;
case CAT: ptr = new Cat;
break;
default: ptr = new Mammal;
break;
}
theArray[i] = ptr;
}
Mammal *OtherArray[NumAnimalTypes];
for (i=0;i<NumAnimalTypes;i++)
{
theArray[i]->Speak();
OtherArray[i] = theArray[i]->Clone();
}
for (i=0;i<NumAnimalTypes;i++)
OtherArray[i]->Speak();
return 0;
(1)dog (2)cat (3)Mammal: 1
Mammal constructor...
Dog constructor...
(1)dog (2)cat (3)Mammal: 2
Mammal constructor...
Cat constructor...
(1)dog (2)cat (3)Mammal: 3
Mammal constructor...
Woof!
Mammal Copy Constructor...
Dog copy constructor...
Meow!
Mammal Copy Constructor...
Cat copy constructor...
Mammal speak!
Mammal Copy Constructor...
Woof!
Meow!
Mammal speak!
Analysis: Listing 12.11 is very similar to the previous two listings, except that a new virtual method
has been added to the Mammal class: Clone(). This method returns a pointer to a new Mammal
object by calling the copy constructor, passing in itself (*this) as a const reference.Dog and Cat both override the Clone() method, initializing their data and passing in copies of
themselves to their own copy constructors. Because Clone() is virtual, this will effectively create a
virtual copy constructor, as shown on line 81.
The user is prompted to choose dogs, cats, or mammals, and these are created on lines 62-74. A
pointer to each choice is stored in an array on line 75.
As the program iterates over the array, each object has its Speak() and its Clone() methods
called, in turn, on lines 80 and 81. The result of the Clone() call is a pointer to a copy of the object,
which is then stored in a second array on line 81.
On line 1 of the output, the user is prompted and responds with 1, choosing to create a dog. The
Mammal and Dog constructors are invoked. This is repeated for Cat and for Mammal on lines 4-8 of
the constructor.
Line 9 of the constructor represents the call to Speak() on the first object, the Dog. The virtual
Speak() method is called, and the correct version of Speak() is invoked. The Clone() function
is then called, and as this is also virtual, Dog's Clone() method is invoked, causing the Mammal
constructor and the Dog copy constructor to be called.
The same is repeated for Cat on lines 12-14, and then for Mammal on lines 15 and 16. Finally, the
new array is iterated, and each of the new objects has Speak() invoked.
The Cost of Virtual Methods
Because objects with virtual methods must maintain a v-table, there is some overhead in having
virtual methods. If you have a very small class from which you do not expect to derive other classes,
there may be no reason to have any virtual methods at all.
Once you declare any methods virtual, you've paid most of the price of the v-table (although each
entry does add a small memory overhead). At that point, you'll want the destructor to be virtual, and
the assumption will be that all other methods probably will be virtual as well. Take a long hard look at
any non-virtual methods, and be certain you understand why they are not virtual.
DO use virtual methods when you expect to derive from a class. DO use a virtual
destructor if any methods are virtual. DON'T mark the constructor as virtual.
Summary
Today you learned how derived classes inherit from base classes. This chapter discussed public
inheritance and virtual functions. Classes inherit all the public and protected data and functions from
their base classes.Protected access is public to derived classes and private to all other objects. Even derived classes
cannot access private data or functions in their base classes.
Constructors can be initialized before the body of the constructor. It is at this time that base
constructors are invoked and parameters can be passed to the base class.
Functions in the base class can be overridden in the derived class. If the base class functions are
virtual, and if the object is accessed by pointer or reference, the derived class's functions will be
invoked, based on the run-time type of the object pointed to.
Methods in the base class can be invoked by explicitly naming the function with the prefix of the base
class name and two colons. For example, if Dog inherits from Mammal, Mammal's walk() method
can be called with Mammal::walk().
In classes with virtual methods, the destructor should almost always be made virtual. A virtual
destructor ensures that the derived part of the object will be freed when delete is called on the
pointer. Constructors cannot be virtual. Virtual copy constructors can be effectively created by
making a virtual member function that calls the copy constructor.
Q&A
Q. Are inherited members and functions passed along to subsequent generations? If Dog
derives from Mammal, and Mammal derives from Animal, does Dog inherit Animal's
functions and data?
A. Yes. As derivation continues, derived classes inherit the sum of all the functions and data in
all their base classes.
Q. If, in the example above, Mammal overrides a function in Animal, which does Dog get,
the original or the overridden function?
A. If Dog inherits from Mammal, it gets the function in the state Mammal has it: the
overridden function.
Q. Can a derived class make a public base function private?
A. Yes, and it remains private for all subsequent derivation.
Q. Why not make all class functions virtual?
A. There is overhead with the first virtual function in the creation of a v-table. After that, the
overhead is trivial. Many C++ programmers feel that if one function is virtual, all others should
be. Other programmers disagree, feeling that there should always be a reason for what you do.
Q. If a function (SomeFunc()) is virtual in a base class and is also overloaded, so as totake either an integer or two integers, and the derived class overrides the form taking one
integer, what is called when a pointer to a derived object calls the two-integer form?
A. The overriding of the one-int form hides the entire base class function, and thus you will
get a compile error complaining that that function requires only one int.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material that
was covered, and exercises to provide you with experience in using what you've learned. Try to
answer the quiz and exercise questions before checking the answers in Appendix D, and make sure
you understand the answers before continuing to the next chapter.
Quiz
1. What is a v-table?
2. What is a virtual destructor?
3. How do you show the declaration of a virtual constructor?
4. How can you create a virtual copy constructor?
5. How do you invoke a base member function from a derived class in which you've
overridden that function?
6. How do you invoke a base member function from a derived class in which you have not
overridden that function?
7. If a base class declares a function to be virtual, and a derived class does not use the term
virtual when overriding that class, is it still virtual when inherited by a third-generation class?
8. What is the protected keyword used for?
Exercises
1. Show the declaration of a virtual function that takes an integer parameter and returns void.
2. Show the declaration of a class Square, which derives from Rectangle, which in turn
derives from Shape.
3. If, in Exercise 2, Shape takes no parameters, Rectangle takes two (length and
width), but Square takes only one (length), show the constructor initialization for
Square.
4. Write a virtual copy constructor for the class Square (in Exercise 3).5. BUG BUSTERS: What is wrong with this code snippet?
void SomeFunction (Shape);
Shape * pRect = new Rectangle;
SomeFunction(*pRect);
6. BUG BUSTERS: What is wrong with this code snippet?
class Shape()
{
public:
Shape();
virtual ~Shape();
virtual Shape(const Shape&);
};
Problems with Single Inheritance
Suppose you've been working with your animal classes for a while and you've divided the class
hierarchy into Birds and Mammals. The Bird class includes the member function Fly(). The
Mammal class has been divided into a number of types of Mammals, including Horse. The Horse
class includes the member functions Whinny() and Gallop().
Suddenly, you realize you need a Pegasus object: a cross between a Horse and a Bird. A
Pegasus can Fly(), it can Whinny(), and it can Gallop(). With single inheritance, you're in
quite a jam.
You can make Pegasus a Bird, but then it won't be able to Whinny() or Gallop(). You can
make it a Horse, but then it won't be able to Fly().
Your first solution is to copy the Fly() method into the Pegasus class and derive Pegasus from
Horse. This works fine, at the cost of having the Fly() method in two places (Bird and
Pegasus). If you change one, you must remember to change the other. Of course, a developer who
comes along months or years later to maintain your code must also know to fix both places.
Soon, however, you have a new problem. You wish to create a list of Horse objects and a list of
Bird objects. You'd like to be able to add your Pegasus objects to either list, but if a Pegasus is a
horse, you can't add it to a list of birds.You have a couple of potential solutions. You can rename the Horse method Gallop() to
Move(), and then override Move() in your Pegasus object to do the work of Fly(). You would
then override Move() in your other horses to do the work of Gallop(). Perhaps Pegasus could
be clever enough to gallop short distances and fly longer distances.
Pegasus::Move(long distance)
{
if (distance > veryFar)
fly(distance);
else
gallop(distance);
}
This is a bit limiting. Perhaps one day Pegasus will want to fly a short distance or gallop a long
distance. Your next solution might be to move Fly() up into Horse, as illustrated in Listing 13.1.
The problem is that most horses can't fly, so you have to make this method do nothing unless it is a
Pegasus.
Listing 13.1. If horses could fly...
1:
// Listing 13.1. If horses could fly...
2:
// Percolating Fly() up into Horse
3:
4:
#include <iostream.h>
5:
6:
class Horse
7:
{
8:
public:
9:
void Gallop(){ cout << "Galloping...\n"; }
10:
virtual void Fly() { cout << "Horses can't fly.\n" ; }
11:
private:
12:
int itsAge;
13:
};
14:
15:
class Pegasus : public Horse
16:
{
17:
public:
18:
virtual void Fly() { cout << "I can fly! I can fly! I can
fly!\n"; }
19:
};
20:
21:
const int NumberHorses = 5;
22:
int main()
23:
{
24:
Horse* Ranch[NumberHorses];25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44: }
Horse* pHorse;
int choice,i;
for (i=0; i<NumberHorses; i++)
{
cout << "(1)Horse (2)Pegasus: ";
cin >> choice;
if (choice == 2)
pHorse = new Pegasus;
else
pHorse = new Horse;
Ranch[i] = pHorse;
}
cout << "\n";
for (i=0; i<NumberHorses; i++)
{
Ranch[i]->Fly();
delete Ranch[i];
}
return 0;
Output: (1)Horse (2)Pegasus: 1
(1)Horse (2)Pegasus: 2
(1)Horse (2)Pegasus: 1
(1)Horse (2)Pegasus: 2
(1)Horse (2)Pegasus: 1
Horses can't
I can fly! I
Horses can't
I can fly! I
Horses can't
fly.
can fly! I can fly!
fly.
can fly! I can fly!
fly.
Analysis: This program certainly works, though at the expense of the Horse class having a Fly()
method. On line 10, the method Fly() is provided to Horse. In a real-world class, you might have
it issue an error, or fail quietly. On line 18, the Pegasus class overrides the Fly() method to "do
the right thing," represented here by printing a happy message.
The array of Horse pointers on line 24 is used to demonstrate that the correct Fly() method is
called based on the runtime binding of the Horse or Pegasus object.
Percolating Upward
Putting the required function higher in the class hierarchy is a common solution to this problem and
results in many functions "percolating up" into the base class. The base class is then in grave danger of
becoming a global namespace for all the functions that might be used by any of the derived classes.This can seriously undermine the class typing of C++, and can create a large and cumbersome base
class.
In general, you want to percolate shared functionality up the hierarchy, without migrating the interface
of each class. This means that if two classes that share a common base class (for example, Horse and
Bird both share Animal) have a function in common (both birds and horses eat, for example), you'll
want to move that functionality up into the base class and create a virtual function.
What you'll want to avoid, however, is percolating an interface (like Fly up where it doesn't belong),
just so you can call that function only on some derived classes.
Casting Down
An alternative to this approach, still within single inheritance, is to keep the Fly() method within
Pegasus, and only call it if the pointer is actually pointing to a Pegasus object. To make this
work, you'll need to be able to ask your pointer what type it is really pointing to. This is known as Run
Time Type Identification (RTTI). Using RTTI has only recently become an official part of C++.
If your compiler does not support RTTI, you can mimic it by putting a method that returns an
enumerated type in each of the classes. You can then test that type at runtime and call Fly() if it
returns Pegasus.
NOTE: Beware of adding RTTI to your classes. Use of it may be an indication of poor
design. Consider using virtual functions, templates, or multiple inheritance instead.
In order to call Fly() however, you must cast the pointer, telling it that the object it is pointing to is
a Pegasus object, not a Horse. This is called casting down, because you are casting the Horse
object down to a more derived type.
C++ now officially, though perhaps reluctantly, supports casting down using the new
dynamic_cast operator. Here's how it works.
If you have a pointer to a base class such as Horse, and you assign to it a pointer to a derived class,
such as Pegasus, you can use the Horse pointer polymorphically. If you then need to get at the
Pegasus object, you create a Pegasus pointer and use the dynamic_cast operator to make the
conversion.
At runtime, the base pointer will be examined. If the conversion is proper, your new Pegasus
pointer will be fine. If the conversion is improper, if you didn't really have a Pegasus object after
all, then your new pointer will be null. Listing 13.2 illustrates this point.
Listing 13.2. Casting down.1:
// Listing 13.2 Using dynamic_cast.
2:
// Using rtti
3:
4:
#include <iostream.h>
5:
enum TYPE { HORSE, PEGASUS };
6:
7:
class Horse
8:
{
9:
public:
10:
virtual void Gallop(){ cout << "Galloping...\n"; }
11:
12:
private:
13:
int itsAge;
14:
};
15:
16:
class Pegasus : public Horse
17:
{
18:
public:
19:
20:
virtual void Fly() { cout << "I can fly! I can fly! I can
fly!\n"; }
21:
};
22:
23:
const int NumberHorses = 5;
24:
int main()
25:
{
26:
Horse* Ranch[NumberHorses];
27:
Horse* pHorse;
28:
int choice,i;
29:
for (i=0; i<NumberHorses; i++)
30:
{
31:
cout << "(1)Horse (2)Pegasus: ";
32:
cin >> choice;
33:
if (choice == 2)
34:
pHorse = new Pegasus;
35:
else
36:
pHorse = new Horse;
37:
Ranch[i] = pHorse;
38:
}
39:
cout << "\n";
40:
for (i=0; i<NumberHorses; i++)
41:
{
42:
Pegasus *pPeg = dynamic_cast< Pegasus *> (Ranch[i]);
42:
if (pPeg)
43:
pPeg->Fly();
44:
else45:
46:
47:
48:
49:
50:
cout << "Just a horse\n";
delete Ranch[i];
}
return 0;
Output: (1)Horse (2)Pegasus: 1
(1)Horse (2)Pegasus: 2
(1)Horse (2)Pegasus: 1
(1)Horse (2)Pegasus: 2
(1)Horse (2)Pegasus: 1
Just a horse
I can fly! I can fly! I can fly!
Just a horse
I can fly! I can fly! I can fly!
Just a horse
Analysis: This solution also works. Fly() is kept out of Horse, and is not called on Horse objects.
When it is called on Pegasus objects, however, they must be explicitly cast; Horse objects don't
have the method Fly(), so the pointer must be told it is pointing to a Pegasus object before being
used.
The need for you to cast the Pegasus object is a warning that something may be wrong with your
design. This program effectively undermines the virtual function polymorphism, because it depends
on casting the object to its real runtime type.
Adding to Two Lists
The other problem with these solutions is that you've declared Pegasus to be a type of Horse, so
you cannot add a Pegasus object to a list of Birds. You've paid the price of either moving Fly()
up into Horse, or casting down the pointer, and yet you still don't have the full functionality you
need.
One final single inheritance solution presents itself. You can push Fly(), Whinny(), and
Gallop() all up into a common base class of both Bird and Horse: Animal. Now, instead of
having a list of Birds and a list of Horses, you can have one unified list of Animals. This works,
but percolates more functionality up into the base classes.
Alternatively, you can leave the methods where they are, but cast down Horses and Birds and
Pegasus objects, but that is even worse!
DO move functionality up the inheritance hierarchy. DON'T move interface up the
inheritance hierarchy. DO avoid switching on the runtime type of the object--use virtualmethods, templates, and multiple inheritance. DON'T cast pointers to base objects
down to derived objects.
Multiple Inheritance
It is possible to derive a new class from more than one base class. This is called Multiple Inheritance.
To derive from more than the base class, you separate each base class by commas in the class
designation. Listing 13.3 illustrates how to declare Pegasus so that it derives from both Horses
and Birds. The program then adds Pegasus objects to both types of lists.
Listing 13.3. Multiple inheritance.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
// Listing 13.3. Multiple inheritance.
// Multiple Inheritance
#include <iostream.h>
class Horse
{
public:
Horse() { cout << "Horse constructor... "; }
virtual ~Horse() { cout << "Horse destructor... "; }
virtual void Whinny() const { cout << "Whinny!... "; }
private:
int itsAge;
};
class Bird
{
public:
Bird() { cout << "Bird constructor... "; }
virtual ~Bird() { cout << "Bird destructor... "; }
virtual void Chirp() const { cout << "Chirp... "; }
virtual void Fly() const
{
cout << "I can fly! I can fly! I can fly! ";
}
private:
int itsWeight;
};
class Pegasus : public Horse, public Bird
{
public:33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
void Chirp() const { Whinny(); }
Pegasus() { cout << "Pegasus constructor... "; }
~Pegasus() { cout << "Pegasus destructor... "; }
};
const int MagicNumber = 2;
int main()
{
Horse* Ranch[MagicNumber];
Bird* Aviary[MagicNumber];
Horse * pHorse;
Bird * pBird;
int choice,i;
for (i=0; i<MagicNumber; i++)
{
cout << "\n(1)Horse (2)Pegasus: ";
cin >> choice;
if (choice == 2)
pHorse = new Pegasus;
else
pHorse = new Horse;
Ranch[i] = pHorse;
}
for (i=0; i<MagicNumber; i++)
{
cout << "\n(1)Bird (2)Pegasus: ";
cin >> choice;
if (choice == 2)
pBird = new Pegasus;
else
pBird = new Bird;
Aviary[i] = pBird;
}
cout << "\n";
for (i=0; i<MagicNumber; i++)
{
cout << "\nRanch[" << i << "]: " ;
Ranch[i]->Whinny();
delete Ranch[i];
}
for (i=0; i<MagicNumber; i++)
{
cout << "\nAviary[" << i << "]: " ;
Aviary[i]->Chirp();79:
80:
81:
82:
83: }
Aviary[i]->Fly();
delete Aviary[i];
}
return 0;
Output: (1)Horse (2)Pegasus: 1
Horse constructor...
(1)Horse (2)Pegasus: 2
Horse constructor... Bird constructor... Pegasus constructor...
(1)Bird (2)Pegasus: 1
Bird constructor...
(1)Bird (2)Pegasus: 2
Horse constructor... Bird constructor... Pegasus constructor...
Ranch[0]: Whinny!... Horse destructor...
Ranch[1]: Whinny!... Pegasus destructor... Bird destructor...
Horse destructor...
Aviary[0]: Chirp... I can fly! I can fly! I can fly! Bird
destructor...
Aviary[1]: Whinny!... I can fly! I can fly! I can fly!
Pegasus destructor... Bird destructor... Horse destructor...
Aviary[0]: Chirp... I can fly!
I can fly! I can fly! Bird destructor...
Aviary[1]: Whinny!... I can fly! I can fly! I can fly!
Pegasus destructor.. Bird destructor... Horse destructor...
Analysis: On lines 6-14, a Horse class is declared. The constructor and destructor print out a
message, and the Whinny() method prints the word Whinny!
On lines 16-25, a Bird class is declared. In addition to its constructor and destructor, this class has
two methods: Chirp() and Fly(), both of which print identifying messages. In a real program
these might, for example, activate the speaker or generate animated images.
Finally, on lines 30-36, the class Pegasus is declared. It derives both from Horse and from Bird.
The Pegasus class overrides the Chirp() method to call the Whinny() method, which it inherits
from Horse.
Two lists are created, a Ranch with pointers to Horse on line 41, and an Aviary with pointers to
Bird on line 42. On lines 46-55, Horse and Pegasus objects are added to the Ranch. On lines 56-
65, Bird and Pegasus objects are added to the Aviary.
Invocations of the virtual methods on both the Bird pointers and the Horse pointers do the right
things for Pegasus objects. For example, on line 78 the members of the Aviary array are used to
call Chirp() on the objects to which they point. The Bird class declares this to be a virtual method,
so the right function is called for each object.Note that each time a Pegasus object is created, the output reflects that both the Bird part and the
Horse part of the Pegasus object is also created. When a Pegasus object is destroyed, the Bird
and Horse parts are destroyed as well, thanks to the destructors being made virtual.
Declaring Multiple Inheritance
Declare an object to inherit from more than one class by listing the base classes following the colon
after the class name. Separate the base classes by commas. Example 1:
class Pegasus : public Horse, public Bird
Example 2:
class Schnoodle : public Schnauzer, public Poodle
The Parts of a Multiply Inherited Object
When the Pegasus object is created in memory, both of the base classes form part of the Pegasus
object, as illustrated in Figure 13.1.
Figure 13.1. Multiply inherited objects.
A number of issues arise with objects with multiple base classes. For example, what happens if two
base classes that happen to have the same name have virtual functions or data? How are multiple base
class constructors initialized? What happens if multiple base classes both derive from the same class?
The next sections will answer these questions, and explore how multiple inheritance can be put to
work.
Constructors in Multiply Inherited Objects
If Pegasus derives from both Horse and Bird, and each of the base classes has constructors that
take parameters, the Pegasus class initializes these constructors in turn. Listing 13.4 illustrates how
this is done.
Listing 13.4. Calling multiple constructors.
1:
2:
3:
4:
5:
;
6:
// Listing 13.4
// Calling multiple constructors
#include <iostream.h>
typedef int HANDS;
enum COLOR { Red, Green, Blue, Yellow, White, Black, Brown }
enum BOOL { FALSE, TRUE };7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
}
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
class Horse
{
public:
Horse(COLOR color, HANDS height);
virtual ~Horse() { cout << "Horse destructor...\n"; }
virtual void Whinny()const { cout << "Whinny!... "; }
virtual HANDS GetHeight() const { return itsHeight; }
virtual COLOR GetColor() const { return itsColor; }
private:
HANDS itsHeight;
COLOR itsColor;
};
Horse::Horse(COLOR color, HANDS height):
itsColor(color),itsHeight(height)
{
cout << "Horse constructor...\n";
}
class Bird
{
public:
Bird(COLOR color, BOOL migrates);
virtual ~Bird() {cout << "Bird destructor...\n"; }
virtual void Chirp()const { cout << "Chirp... "; }
virtual void Fly()const
{
cout << "I can fly! I can fly! I can fly! ";
}
virtual COLOR GetColor()const { return itsColor; }
virtual BOOL GetMigration() const { return itsMigration;
private:
COLOR itsColor;
BOOL itsMigration;
};
Bird::Bird(COLOR color, BOOL migrates):
itsColor(color), itsMigration(migrates)
{
cout << "Bird constructor...\n";
}
class Pegasus : public Horse, public Bird52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93: }
{
public:
void Chirp()const { Whinny(); }
Pegasus(COLOR, HANDS, BOOL,long);
~Pegasus() {cout << "Pegasus destructor...\n";}
virtual long GetNumberBelievers() const
{
return itsNumberBelievers;
}
private:
long itsNumberBelievers;
};
Pegasus::Pegasus(
COLOR aColor,
HANDS height,
BOOL migrates,
long NumBelieve):
Horse(aColor, height),
Bird(aColor, migrates),
itsNumberBelievers(NumBelieve)
{
cout << "Pegasus constructor...\n";
}
int main()
{
Pegasus *pPeg = new Pegasus(Red, 5, TRUE, 10);
pPeg->Fly();
pPeg->Whinny();
cout << "\nYour Pegasus is " << pPeg->GetHeight();
cout << " hands tall and ";
if (pPeg->GetMigration())
cout << "it does migrate.";
else
cout << "it does not migrate.";
cout << "\nA total of " << pPeg->GetNumberBelievers();
cout << " people believe it exists.\n";
delete pPeg;
return 0;
Output: Horse constructor...
Bird constructor...
Pegasus constructor...I can fly! I can fly! I can fly! Whinny!...
Your Pegasus is 5 hands tall and it does migrate.
A total of 10 people believe it exists.
Pegasus destructor...
Bird destructor...
Horse destructor...
Analysis: On lines 8-19, the Horse class is declared. The constructor takes two parameters, both
using enumerations declared on lines 5 and 6. The implementation of the constructor on lines 21-25
simply initializes the member variables and prints a message.
On lines 27-43, the Bird class is declared, and the implementation of its constructor is on lines 45-
49. Again, the Bird class takes two parameters. Interestingly, the Horse constructor takes color (so
that you can detect horses of different colors), and the Bird constructor takes the color of the feathers
(so those of one feather can stick together). This leads to a problem when you want to ask the
Pegasus for its color, which you'll see in the next example.
The Pegasus class itself is declared on lines 51-64, and its constructor is on lines 66-72. The
initialization of the Pegasus object includes three statements. First, the Horse constructor is
initialized with color and height. Then the Bird constructor is initialized with color and the Boolean.
Finally, the Pegasus member variable itsNumberBelievers is initialized. Once all that is
accomplished, the body of the Pegasus constructor is called.
In the main() function, a Pegasus pointer is created and used to access the member functions of
the base objects.
Ambiguity Resolution
In Listing 13.4, both the Horse class and the Bird class have a method GetColor(). You may
need to ask the Pegasus object to return its color, but you have a problem: the Pegasus class
inherits from both Bird and Horse. They both have a color, and their methods for getting that color
have the same names and signature. This creates an ambiguity for the compiler, which you must
resolve.
If you simply write
COLOR currentColor = pPeg->GetColor();
you will get a compiler error:
Member is ambiguous: `Horse::GetColor' and `Bird::GetColor'
You can resolve the ambiguity with an explicit call to the function you wish to invoke:
COLOR currentColor = pPeg->Horse::GetColor();Anytime you need to resolve which class a member function or member data inherits from, you can
fully qualify the call by prepending the class name to the base class data or function.
Note that if Pegasus were to override this function, the problem would be moved, as it should be,
into the Pegasus member function:
virtual COLOR GetColor()const { return Horse::itsColor; }
This hides the problem from clients of the Pegasus class, and encapsulates within Pegasus the
knowledge of which base class it wishes to inherit its color from. A client is still free to force the issue
by writing:
COLOR currentColor = pPeg->Bird::GetColor();
Inheriting from Shared Base Class
What happens if both Bird and Horse inherit from a common base class, such as Animal? Figure
13.2 illustrates what this looks like.
As you can see in Figure 13.2, two base class objects exist. When a function or data member is called
in the shared base class, another ambiguity exists. For example, if Animal declares itsAge as a
member variable and GetAge() as a member function, and you call pPeg->GetAge(), did you
mean to call the GetAge() function you inherit from Animal by way of Horse, or by way of
Bird? You must resolve this ambiguity as well, as illustrated in Listing 13.5.
Figure 13.2. Common base classes.
Listing 13.5. Common base classes.
1:
2:
3:
4:
5:
6:
;
7:
8:
9:
10:
11:
12:
13:
14:
// Listing 13.5
// Common base classes
#include <iostream.h>
typedef int HANDS;
enum COLOR { Red, Green, Blue, Yellow, White, Black, Brown }
enum BOOL { FALSE, TRUE };
class Animal
// common base to both horse and bird
{
public:
Animal(int);
virtual ~Animal() { cout << "Animal destructor...\n"; }
virtual int GetAge() const { return itsAge; }15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
}
56:
57:
58:
59:
virtual void SetAge(int age) { itsAge = age; }
private:
int itsAge;
};
Animal::Animal(int age):
itsAge(age)
{
cout << "Animal constructor...\n";
}
class Horse : public Animal
{
public:
Horse(COLOR color, HANDS height, int age);
virtual ~Horse() { cout << "Horse destructor...\n"; }
virtual void Whinny()const { cout << "Whinny!... "; }
virtual HANDS GetHeight() const { return itsHeight; }
virtual COLOR GetColor() const { return itsColor; }
protected:
HANDS itsHeight;
COLOR itsColor;
};
Horse::Horse(COLOR color, HANDS height, int age):
Animal(age),
itsColor(color),itsHeight(height)
{
cout << "Horse constructor...\n";
}
class Bird : public Animal
{
public:
Bird(COLOR color, BOOL migrates, int age);
virtual ~Bird() {cout << "Bird destructor...\n"; }
virtual void Chirp()const { cout << "Chirp... "; }
virtual void Fly()const
{ cout << "I can fly! I can fly! I can fly! "; }
virtual COLOR GetColor()const { return itsColor; }
virtual BOOL GetMigration() const { return itsMigration;
protected:
COLOR itsColor;
BOOL itsMigration;
};60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102: }
Bird::Bird(COLOR color, BOOL migrates, int age):
Animal(age),
itsColor(color), itsMigration(migrates)
{
cout << "Bird constructor...\n";
}
class Pegasus : public Horse, public Bird
{
public:
void Chirp()const { Whinny(); }
Pegasus(COLOR, HANDS, BOOL, long, int);
~Pegasus() {cout << "Pegasus destructor...\n";}
virtual long GetNumberBelievers() const
{ return itsNumberBelievers; }
virtual COLOR GetColor()const { return Horse::itsColor; }
virtual int GetAge() const { return Horse::GetAge(); }
private:
long itsNumberBelievers;
};
Pegasus::Pegasus(
COLOR aColor,
HANDS height,
BOOL migrates,
long NumBelieve,
int age):
Horse(aColor, height,age),
Bird(aColor, migrates,age),
itsNumberBelievers(NumBelieve)
{
cout << "Pegasus constructor...\n";
}
int main()
{
Pegasus *pPeg = new Pegasus(Red, 5, TRUE, 10, 2);
int age = pPeg->GetAge();
cout << "This pegasus is " << age << " years old.\n";
delete pPeg;
return 0;
Output: Animal constructor...
Horse constructor...Animal constructor...
Bird constructor...
Pegasus constructor...
This pegasus is 2 years old.
Pegasus destructor...
Bird destructor...
Animal destructor...
Horse destructor...
Animal destructor...
Analysis: There are a number of interesting features to this listing. The Animal class is declared on
lines 9-18. Animal adds one member variable, itsAge and an accessor, SetAge().
On line 26, the Horse class is declared to derive from Animal. The Horse constructor now has a
third parameter, age, which it passes to its base class, Animal. Note that the Horse class does not
override GetAge(), it simply inherits it.
On line 46, the Bird class is declared to derive from Animal. Its constructor also takes an age and
uses it to initialize its base class, Animal. It also inherits GetAge() without overriding it.
Pegasus inherits from both Bird and from Animal, and so has two Animal classes in its
inheritance chain. If you were to call GetAge() on a Pegasus object, you would have to
disambiguate, or fully qualify, the method you want if Pegasus did not override the method.
This is solved on line 76 when the Pegasus object overrides GetAge() to do nothing more than to
chain up--that is, to call the same method in a base class.
Chaining up is done for two reasons: either to disambiguate which base class to call, as in this case, or
to do some work and then let the function in the base class do some more work. At times, you may
want to do work and then chain up, or chain up and then do the work when the base class function
returns.
The Pegasus constructor takes five parameters: the creature's color, its height (in HANDS), whether
or not it migrates, how many believe in it, and its age. The constructor initializes the Horse part of
the Pegasus with the color, height, and age on line 88. It initializes the Bird part with color,
whether it migrates, and age on line 89. Finally, it initializes itsNumberBelievers on line 90.
The call to the Horse constructor on line 88 invokes the implementation shown on line 39. The
Horse constructor uses the age parameter to initialize the Animal part of the Horse part of the
Pegasus. It then goes on to initialize the two member variables of Horse--itsColor and
itsAge.
The call to the Bird constructor on line 89 invokes the implementation shown on line 46. Here too,
the age parameter is used to initialize the Animal part of the Bird.Note that the color parameter to the Pegasus is used to initialize member variables in each of
Bird and Horse. Note also that the age is used to initialize itsAge in the Horse's base Animal
and in the Bird's base Animal.
Virtual Inheritance
In Listing 13.5, the Pegasus class went to some lengths to disambiguate which of its Animal base
classes it meant to invoke. Most of the time, the decision as to which one to use is arbitrary--after all,
the Horse and the Bird have exactly the same base class.
It is possible to tell C++ that you do not want two copies of the shared base class, as shown in Figure
13.2, but rather to have a single shared base class, as shown in Figure 13.3.
You accomplish this by making Animal a virtual base class of both Horse and Bird. The Animal
class does not change at all. The Horse and Bird classes change only in their use of the term virtual
in their declarations. Pegasus, however, changes substantially.
Normally, a class's constructor initializes only its own variables and its base class. Virtually inherited
base classes are an exception, however. They are initialized by their most derived class. Thus,
Animal is initialized not by Horse and Bird, but by Pegasus. Horse and Bird have to
initialize Animal in their constructors, but these initializations will be ignored when a Pegasus
object is created.
Listing 13.6 rewrites Listing 13.5 to take advantage of virtual derivation.
Figure 13.3. A diamond inheritance.
Listing 13.6. Illustration of the use of virtual inheritance.
1:
2:
3:
4:
5:
6:
;
7:
8:
9:
10:
11:
12:
13:
14:
15:
// Listing 13.6
// Virtual inheritance
#include <iostream.h>
typedef int HANDS;
enum COLOR { Red, Green, Blue, Yellow, White, Black, Brown }
enum BOOL { FALSE, TRUE };
class Animal
// common base to both horse and bird
{
public:
Animal(int);
virtual ~Animal() { cout << "Animal destructor...\n"; }
virtual int GetAge() const { return itsAge; }
virtual void SetAge(int age) { itsAge = age; }16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
}
56:
57:
58:
59:
60:
private:
int itsAge;
};
Animal::Animal(int age):
itsAge(age)
{
cout << "Animal constructor...\n";
}
class Horse : virtual public Animal
{
public:
Horse(COLOR color, HANDS height, int age);
virtual ~Horse() { cout << "Horse destructor...\n"; }
virtual void Whinny()const { cout << "Whinny!... "; }
virtual HANDS GetHeight() const { return itsHeight; }
virtual COLOR GetColor() const { return itsColor; }
protected:
HANDS itsHeight;
COLOR itsColor;
};
Horse::Horse(COLOR color, HANDS height, int age):
Animal(age),
itsColor(color),itsHeight(height)
{
cout << "Horse constructor...\n";
}
class Bird : virtual public Animal
{
public:
Bird(COLOR color, BOOL migrates, int age);
virtual ~Bird() {cout << "Bird destructor...\n"; }
virtual void Chirp()const { cout << "Chirp... "; }
virtual void Fly()const
{ cout << "I can fly! I can fly! I can fly! "; }
virtual COLOR GetColor()const { return itsColor; }
virtual BOOL GetMigration() const { return itsMigration;
protected:
COLOR itsColor;
BOOL itsMigration;
};61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102: }
Bird::Bird(COLOR color, BOOL migrates, int age):
Animal(age),
itsColor(color), itsMigration(migrates)
{
cout << "Bird constructor...\n";
}
class Pegasus : public Horse, public Bird
{
public:
void Chirp()const { Whinny(); }
Pegasus(COLOR, HANDS, BOOL, long, int);
~Pegasus() {cout << "Pegasus destructor...\n";}
virtual long GetNumberBelievers() const
{ return itsNumberBelievers; }
virtual COLOR GetColor()const { return Horse::itsColor; }
private:
long itsNumberBelievers;
};
Pegasus::Pegasus(
COLOR aColor,
HANDS height,
BOOL migrates,
long NumBelieve,
int age):
Horse(aColor, height,age),
Bird(aColor, migrates,age),
Animal(age*2),
itsNumberBelievers(NumBelieve)
{
cout << "Pegasus constructor...\n";
}
int main()
{
Pegasus *pPeg = new Pegasus(Red, 5, TRUE, 10, 2);
int age = pPeg->GetAge();
cout << "This pegasus is " << age << " years old.\n";
delete pPeg;
return 0;
Output: Animal constructor...
Horse constructor...
Bird constructor...Pegasus constructor...
This pegasus is 4 years old.
Pegasus destructor...
Bird destructor...
Horse destructor...
Animal destructor...
Analysis: On line 26, Horse declares that it inherits virtually from Animal, and on line 46, Bird
makes the same declaration. Note that the constructors for both Bird and Animal still initialize the
Animal object.
Pegasus inherits from both Bird and Animal, and as the most derived object of Animal, it also
initializes Animal. It is Pegasus' initialization which is called, however, and the calls to Animal's
constructor in Bird and Horse are ignored. You can see this because the value 2 is passed in, and
Horse and Bird pass it along to Animal, but Pegasus doubles it. The result, 4, is reflected in the
printout on line 99 and as shown in the output.
Pegasus no longer has to disambiguate the call to GetAge(), and so is free to simply inherit this
function from Animal. Note that Pegasus must still disambiguate the call to GetColor(), as this
function is in both of its base classes and not in Animal.
Declaring Classes for Virtual Inheritance
To ensure that derived classes have only one instance of common base classes, declare the
intermediate classes to inherit virtually from the base class. Example 1:
class Horse : virtual public Animal
class Bird : virtual public Animal
class Pegasus : public Horse, public Bird
Example 2:
class Schnauzer : virtual public Dog
class Poodle : virtual public Dog
class Schnoodle : public Schnauzer, public Poodle
Problems with Multiple Inheritance
Although multiple inheritance offers a number of advantages over single inheritance, there are many
C++ programmers who are reluctant to use it. The problems they cite are that many compilers don't
support it yet, that it makes debugging harder, and that nearly everything that can be done with
multiple inheritance can be done without it.
These are valid concerns, and you will want to be on your guard against installing needlesscomplexity into your programs. Some debuggers have a hard time with multiple inheritance, and some
designs are needlessly made complex by using multiple inheritance when it is not needed.
DO use multiple inheritance when a new class needs functions and features from more
than one base class. DO use virtual inheritance when the most derived classes must
have only one instance of the shared base class. DO initialize the shared base class from
the most derived class when using virtual base classes. DON'T use multiple inheritance
when single inheritance will do.
Mixins and Capabilities Classes
One way to strike a middle ground between multiple inheritance and single inheritance is to use what
are called mixins. Thus, you might have your Horse class derive from Animal and from
Displayable. Displayable would just add a few methods for displaying any object onscreen.
New Term: A mixin , or capability class, is a class that adds functionality without adding
much or any data.
Capability classes are mixed into a derived class like any other class might be, by declaring the
derived class to inherit publicly from them. The only difference between a capability class and any
other class is that the capability class has little or no data. This is an arbitrary distinction, of course,
and is just a shorthand way of noting that at times all you want to do is mix in some additional
capabilities without complicating the derived class.
This will, for some debuggers, make it easier to work with mixins than with more complex multiply
inherited objects. There is also less likelihood of ambiguity in accessing the data in the other principal
base class.
For example, if Horse derives from Animal and from Displayable, Displayable would
have no data. Animal would be just as it always was, so all the data in Horse would derive from
Animal, but the functions in Horse would derive from both.
The term mixin comes from an ice-cream store in Sommerville, Massachusetts, where candies and
cakes were mixed into the basic ice-cream flavors. This seemed like a good metaphor to some of the
object-oriented programmers who used to take a summer break there, especially while working with
the object-oriented programming language SCOOPS.
Abstract Data Types
Often, you will create a hierarchy of classes together. For example, you might create a Shape class,
and derive from that Rectangle and Circle. From Rectangle, you might derive Square, as aspecial case of Rectangle.
Each of the derived classes will override the Draw() method, the GetArea() method, and so forth.
Listing 13.7 illustrates a bare-bones implementation of the Shape class and its derived Circle and
Rectangle classes.
Listing 13.7. Shape classes.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
//Listing 13.7. Shape classes.
#include <iostream.h>
enum BOOL { FALSE, TRUE };
class Shape
{
public:
Shape(){}
~Shape(){}
virtual long GetArea() { return -1; } // error
virtual long GetPerim() { return -1; }
virtual void Draw() {}
private:
};
class Circle : public Shape
{
public:
Circle(int radius):itsRadius(radius){}
~Circle(){}
long GetArea() { return 3 * itsRadius * itsRadius; }
long GetPerim() { return 9 * itsRadius; }
void Draw();
private:
int itsRadius;
int itsCircumference;
};
void Circle::Draw()
{
cout << "Circle drawing routine here!\n";
}
class Rectangle : public Shape38:
{
39:
public:
40:
Rectangle(int len, int width):
41:
itsLength(len), itsWidth(width){}
42:
~Rectangle(){}
43:
virtual long GetArea() { return itsLength * itsWidth;
}
44:
virtual long GetPerim() {return 2*itsLength +
2*itsWidth; }
45:
virtual int GetLength() { return itsLength; }
46:
virtual int GetWidth() { return itsWidth; }
47:
virtual void Draw();
48:
private:
49:
int itsWidth;
50:
int itsLength;
51:
};
52:
53:
void Rectangle::Draw()
54:
{
55:
for (int i = 0; i<itsLength; i++)
56:
{
57:
for (int j = 0; j<itsWidth; j++)
58:
cout << "x ";
59:
60:
cout << "\n";
61:
}
62:
}
63:
64:
class Square : public Rectangle
65:
{
66:
public:
67:
Square(int len);
68:
Square(int len, int width);
69:
~Square(){}
70:
long GetPerim() {return 4 * GetLength();}
71:
};
72:
73:
Square::Square(int len):
74:
Rectangle(len,len)
75:
{}
76:
77:
Square::Square(int len, int width):
78:
Rectangle(len,width)
79:
80:
{
81:
if (GetLength() != GetWidth())82:
cout << "Error, not a square... a Rectangle??\n";
83:
}
84:
85:
int main()
86:
{
87:
int choice;
88:
BOOL fQuit = FALSE;
89:
Shape * sp;
90:
91:
while (1)
92:
{
93:
cout << "(1)Circle (2)Rectangle (3)Square (0)Quit: ";
94:
cin >> choice;
95:
96:
switch (choice)
97:
{
98:
case 1: sp = new Circle(5);
99:
break;
100:
case 2: sp = new Rectangle(4,6);
101:
break;
102:
case 3: sp = new Square(5);
103:
break;
104:
default: fQuit = TRUE;
105:
break;
106:
}
107:
if (fQuit)
108:
break;
109:
110:
sp->Draw();
111:
cout << "\n";
112:
}
113:
return 0;
114: }
Output:
x x x x
x x x x
x x x x
x x x x
(1)Circle (2)Rectangle (3)Square (0)Quit: 2
x x
x x
x x
x x
(1)Circle (2)Rectangle (3)Square (0)Quit:3
x x x x x
x x x x x
x x x x x
x x x x x
x x x x x(1)Circle (2)Rectangle (3)Square (0)Quit:0
Analysis: On lines 7-16, the Shape class is declared. The GetArea() and GetPerim() methods
return an error value, and Draw() takes no action. After all, what does it mean to draw a Shape?
Only types of shapes (circles, rectangle, and so on) can be drawn, Shapes as an abstraction cannot be
drawn.
Circle derives from Shape and overrides the three virtual methods. Note that there is no reason to
add the word "virtual," as that is part of their inheritance. But there is no harm in doing so either, as
shown in the Rectangle class on lines 43, 44, and 47. It is a good idea to include the term virtual as
a reminder, a form of documentation.
Square derives from Rectangle, and it too overrides the GetPerim() method, inheriting the
rest of the methods defined in Rectangle.
It is troubling, though, that a client might try to instantiate a Shape object, and it might be desirable
to make that impossible. The Shape class exists only to provide an interface for the classes derived
from it; as such it is an Abstract Data Type, or ADT.
New Term: An Abstract Data Type represents a concept (like shape) rather than an object (like
circle). In C++, an ADT is always the base class to other classes, and it is not valid to make an
instance of an ADT.
Pure Virtual Functions
C++ supports the creation of abstract data types with pure virtual functions. A virtual function ismade
pure by initializing it with zero, as in
virtual void Draw() = 0;
Any class with one or more pure virtual functions is an ADT, and it is illegal to instantiate an object of
a class that is an ADT. Trying to do so will cause a compile-time error. Putting a pure virtual function
in your class signals two things to clients of your class:
&&" Don't make an object of this class, derive from it.
&"' Make sure you override the pure virtual function.
Any class that derives from an ADT inherits the pure virtual function as pure, and so must override
every pure virtual function if it wants to instantiate objects. Thus, if Rectangle inherits from
Shape, and Shape has three pure virtual functions, Rectangle must override all three or it too
will be an ADT. Listing 13.8 rewrites the Shape class to be an abstract data type. To save space, therest of Listing 13.7 is not reproduced here. Replace the declaration of Shape in Listing 13.7, lines 7-
16, with the declaration of Shape in Listing 13.8 and run the program again.
Listing 13.8. Abstract Data Types.
1:
2:
3:
4:
5:
6:
7:
8:
9:
class Shape
{
public:
Shape(){}
~Shape(){}
virtual long GetArea() = 0; // error
virtual long GetPerim()= 0;
virtual void Draw() = 0;
private:
10: };
Output:
x x x x
x x x x
x x x x
x x x x
(1)Circle (2)Rectangle (3)Square (0)Quit: 2
x x
x x
x x
x x
(1)Circle (2)Rectangle (3)Square (0)Quit: 3
x x x x x
x x x x x
x x x x x
x x x x x
x x x x x
(1)Circle (2)Rectangle (3)Square (0)Quit: 0
Analysis: As you can see, the workings of the program are totally unaffected. The only difference is
that it would now be impossible to make an object of class Shape.
Abstract Data Types
Declare a class to be an abstract data type by including one or more pure virtual functions in the class
declaration. Declare a pure virtual function by writing = 0 after the function declaration. Example:
class Shape
{
virtual void Draw() = 0;
};
// pure virtualImplementing Pure Virtual Functions
Typically, the pure virtual functions in an abstract base class are never implemented. Because no
objects of that type are ever created, there is no reason to provide implementations, and the ADT
works purely as the definition of an interface to objects which derive from it.
It is possible, however, to provide an implementation to a pure virtual function. The function can then
be called by objects derived from the ADT, perhaps to provide common functionality to all the
overridden functions. Listing 13.9 reproduces Listing 13.7, this time with Shape as an ADT and with
an implementation for the pure virtual function Draw(). The Circle class overrides Draw(), as it
must, but it then chains up to the base class function for additional functionality.
In this example, the additional functionality is simply an additional message printed, but one can
imagine that the base class provides a shared drawing mechanism, perhaps setting up a window that
all derived classes will use.
Listing 13.9. Implementing pure virtual functions.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
//Implementing pure virtual functions
#include <iostream.h>
enum BOOL { FALSE, TRUE };
class Shape
{
public:
Shape(){}
~Shape(){}
virtual long GetArea() = 0; // error
virtual long GetPerim()= 0;
virtual void Draw() = 0;
private:
};
void Shape::Draw()
{
cout << "Abstract drawing mechanism!\n";
}
class Circle : public Shape
{
public:
Circle(int radius):itsRadius(radius){}
~Circle(){}28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
long GetArea() { return 3 * itsRadius * itsRadius; }
long GetPerim() { return 9 * itsRadius; }
void Draw();
private:
int itsRadius;
int itsCircumference;
};
void Circle::Draw()
{
cout << "Circle drawing routine here!\n";
Shape::Draw();
}
class Rectangle : public Shape
{
public:
Rectangle(int len, int width):
itsLength(len), itsWidth(width){}
~Rectangle(){}
long GetArea() { return itsLength * itsWidth; }
long GetPerim() {return 2*itsLength + 2*itsWidth; }
virtual int GetLength() { return itsLength; }
virtual int GetWidth() { return itsWidth; }
void Draw();
private:
int itsWidth;
int itsLength;
};
void Rectangle::Draw()
{
for (int i = 0; i<itsLength; i++)
{
for (int j = 0; j<itsWidth; j++)
cout << "x ";
cout << "\n";
}
Shape::Draw();
}
class Square : public Rectangle
{74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
public:
Square(int len);
Square(int len, int width);
~Square(){}
long GetPerim() {return 4 * GetLength();}
};
Square::Square(int len):
Rectangle(len,len)
{}
Square::Square(int len, int width):
Rectangle(len,width)
{
if (GetLength() != GetWidth())
cout << "Error, not a square... a Rectangle??\n";
}
int main()
{
int choice;
BOOL fQuit = FALSE;
Shape * sp;
while (1)
{
cout << "(1)Circle (2)Rectangle (3)Square (0)Quit: ";
cin >> choice;
switch (choice)
{
case 1: sp = new
break;
case 2: sp = new
break;
case 3: sp = new
break;
default: fQuit =
break;
}
if (fQuit)
break;
sp->Draw();
cout << "\n";
Circle(5);
Rectangle(4,6);
Square (5);
TRUE;120:
121:
122: }
}
return 0;
Output: (1)Circle (2)Rectangle (3)Square (0)Quit: 2
x x x x x x
x x x x x x
x x x x x x
x x x x x x
Abstract drawing mechanism!
(1)Circle (2)Rectangle (3)Square (0)Quit: 3
x x x x x
x x x x x
x x x x x
x x x x x
x x x x x
Abstract drawing mechanism!
(1)Circle (2)Rectangle (3)Square (0)Quit: 0
Analysis: On lines 7-16, the abstract data type Shape is declared, with all three of its accessor
methods declared to be pure virtual. Note that this is not necessary. If any one were declared pure
virtual, the class would have been an ADT.
The GetArea() and GetPerim() methods are not implemented, but Draw() is. Circle and
Rectangle both override Draw(), and both chain up to the base method, taking advantage of
shared functionality in the base class.
Complex Hierarchies of Abstraction
At times, you will derive ADTs from other ADTs. It may be that you will want to make some of the
derived pure virtual functions non-pure, and leave others pure.
If you create the Animal class, you may make Eat(), Sleep(), Move(), and Reproduce()
all be pure virtual functions. Perhaps from Animal you derive Mammal and Fish.
On examination, you decide that every Mammal will reproduce in the same way, and so you make
Mammal::Reproduce() be non-pure, but you leave Eat(), Sleep(), and Move() as pure
virtual functions.
From Mammal you derive Dog, and Dog must override and implement the three remaining pure
virtual functions so that you can make objects of type Dog.
What you've said, as class designer, is that no Animals or Mammals can be instantiated, but that all
Mammals may inherit the provided Reproduce() method without overriding it.Listing 13.10 illustrates this technique with a bare-bones implementation of these classes.
Listing 13.10. Deriving ADTs from other ADTs.
1:
2:
3:
4:
5:
;
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
// Listing 13.10
// Deriving ADTs from other ADTs
#include <iostream.h>
enum COLOR { Red, Green, Blue, Yellow, White, Black, Brown }
enum BOOL { FALSE, TRUE };
class Animal
// common base to both horse and bird
{
public:
Animal(int);
virtual ~Animal() { cout << "Animal destructor...\n"; }
virtual int GetAge() const { return itsAge; }
virtual void SetAge(int age) { itsAge = age; }
virtual void Sleep() const = 0;
virtual void Eat() const = 0;
virtual void Reproduce() const = 0;
virtual void Move() const = 0;
virtual void Speak() const = 0;
private:
int itsAge;
};
Animal::Animal(int age):
itsAge(age)
{
cout << "Animal constructor...\n";
}
class Mammal : public Animal
{
public:
Mammal(int age):Animal(age)
{ cout << "Mammal constructor...\n";}
~Mammal() { cout << "Mammal destructor...\n";}
virtual void Reproduce() const
{ cout << "Mammal reproduction depicted...\n"; }
};40:
class Fish : public Animal
41:
{
42:
public:
43:
Fish(int age):Animal(age)
44:
{ cout << "Fish constructor...\n";}
45:
virtual ~Fish() {cout << "Fish destructor...\n"; }
46:
virtual void Sleep() const { cout << "fish snoring...\n";
}
47:
virtual void Eat() const { cout << "fish feeding...\n"; }
48:
virtual void Reproduce() const
49:
{ cout << "fish laying eggs...\n"; }
50:
virtual void Move() const
51:
{ cout << "fish swimming...\n";
}
52:
virtual void Speak() const { }
53:
};
54:
55:
class Horse : public Mammal
56:
{
57:
public:
58:
Horse(int age, COLOR color ):
59:
Mammal(age), itsColor(color)
60:
{ cout << "Horse constructor...\n"; }
61:
virtual ~Horse() { cout << "Horse destructor...\n"; }
62:
virtual void Speak()const { cout << "Whinny!... \n"; }
63:
virtual COLOR GetItsColor() const { return itsColor; }
64:
virtual void Sleep() const
65:
{ cout << "Horse snoring...\n"; }
66:
virtual void Eat() const { cout << "Horse feeding...\n";
}
67:
virtual void Move() const { cout << "Horse
running...\n";}
68:
69:
protected:
70:
COLOR itsColor;
71:
};
72:
73:
class Dog : public Mammal
74:
{
75:
public:
76:
Dog(int age, COLOR color ):
77:
Mammal(age), itsColor(color)
78:
{ cout << "Dog constructor...\n"; }
79:
virtual ~Dog() { cout << "Dog destructor...\n"; }
80:
virtual void Speak()const { cout << "Whoof!... \n"; }
81:
virtual void Sleep() const { cout << "Dog snoring...\n";
}82:
83:
}
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125: }
virtual void Eat() const { cout << "Dog eating...\n"; }
virtual void Move() const { cout << "Dog running...\n";
virtual void Reproduce() const
{ cout << "Dogs reproducing...\n"; }
protected:
COLOR itsColor;
};
int main()
{
Animal *pAnimal=0;
int choice;
BOOL fQuit = FALSE;
while (1)
{
cout << "(1)Dog (2)Horse (3)Fish (0)Quit: ";
cin >> choice;
switch (choice)
{
case 1: pAnimal = new Dog(5,Brown);
break;
case 2: pAnimal = new Horse(4,Black);
break;
case 3: pAnimal = new Fish (5);
break;
default: fQuit = TRUE;
break;
}
if (fQuit)
break;
pAnimal->Speak();
pAnimal->Eat();
pAnimal->Reproduce();
pAnimal->Move();
pAnimal->Sleep();
delete pAnimal;
cout << "\n";
}
return 0Output: (1)Dog (2)Horse (3)Bird (0)Quit: 1
Animal constructor...
Mammal constructor...
Dog constructor...
Whoof!...
Dog eating...
Dog reproducing....
Dog running...
Dog snoring...
Dog destructor...
Mammal destructor...
Animal destructor...
(1)Dog (2)Horse (3)Bird (0)Quit: 0
Analysis: On lines 8-22, the abstract data type Animal is declared. Animal has non-pure virtual
accessors for itsAge, which are shared by all Animal objects. It has five pure virtual functions,
Sleep(), Eat(), Reproduce(), Move(), and Speak().
Mammal is derived from Animal, is declared on lines 30-38, and adds no data. It overrides
Reproduce(), however, providing a common form of reproduction for all mammals. Fish must
override Reproduce(), because Fish derives directly from Animal and cannot take advantage of
Mammalian reproduction (and a good thing, too!).
Mammal classes no longer have to override the Reproduce() function, but they are free to do so if
they choose, as Dog does on line 84. Fish, Horse, and Dog all override the remaining pure virtual
functions, so that objects of their type can be instantiated.
In the body of the program, an Animal pointer is used to point to the various derived objects in turn.
The virtual methods are invoked, and based on the runtime binding of the pointer, the correct method
is called in the derived class.
It would be a compile-time error to try to instantiate an Animal or a Mammal, as both are abstract
data types.
Which Types Are Abstract?
In one program, the class Animal is abstract, in another it is not. What determines whether to make a
class abstract or not?
The answer to this question is decided not by any real-world intrinsic factor, but by what makes sense
in your program. If you are writing a program that depicts a farm or a zoo, you may want Animal to
be an abstract data type, but Dog to be a class from which you can instantiate objects.
On the other hand, if you are making an animated kennel, you may want to keep Dog as an abstractdata type, and only instantiate types of dogs: retrievers, terriers, and so fort. The level of abstraction is
a function of how finely you need to distinguish your types.
DO use abstract data types to provide common functionality for a number of related
classes. DO override all pure virtual functions. DO make pure virtual any function that
must be overridden. DON'T try to instantiate an object of an abstract data type.
The Observer Pattern
A very hot trend in C++ is the creation and dissemination of design patterns. These are well-
documented solutions to common problems encountered by C++ programmers. As an example, the
observer pattern solves a common problem in inheritance.
Imagine you develop a timer class which knows how to count elapsed seconds. Such a class might
have a class member itsSeconds which is an integer, and it would have methods to set, get, and
increment itsSeconds.
Now let's further assume that your program wants to be informed every time the timer's
itsSeconds member is incremented. One obvious solution would be to put a notification method
into the timer. However, notification is not an intrinsic part of timing, and the complex code for
registering those classes which need to be informed when the clock increments doesn't really belong
in your timer class.
More importantly, once you work out the logic of registering those who are interested in these
changes, and then notifying them, you'd like to abstract this out into a class of its own and be able to
reuse it with other classes which might be "observed" in this way.
Therefore, a better solution is to create an observer class. Make this observer an Abstract Data Type
with a pure virtual function Update().
Now create a second abstract data type, called Subject. Subject keeps an array of Observer
objects and also provides two methods: register() (which adds observers to its list) and
Notify(), which is called when there is something to report.
Those classes which wish to be notified of your timer's changes inherit from Observer. The timer
itself inherits from Subject. The Observer class registers itself with the Subject class. The
Subject class calls Notify when it changes (in this case when the timer updates).
Finally, we note that not every client of timer wants to be observable, and thus we create a new class
called ObservedTimer, which inherits both from timer and from Subject. This gives the
ObservedTimer the timer characteristics and the ability to be observed.
A Word About Multiple Inheritance, Abstract Data Types, and JavaMany C++ programmers are aware that Java was based in large part on C++, and yet the creators of
Java chose to leave out multiple inheritance. It was their opinion that multiple inheritance introduced
complexity that worked against the ease of use of Java. They felt they could meet 90% of the multiple
inheritance functionality using what are called interfaces.
New Term: An interface is much like an Abstract Data Type in that it defines a set of
functions that can only be implemented in a derived class. However, with interfaces, you don't
directly derive from the interface, you derive from another class and implement the interface,
much like multiple inheritance. Thus, this marriage of an abstract data type and multiple
inheritance gives you something akin to a capability class without the complexity or overhead
of multiple inheritance. In addition, because interfaces cannot have implementations nor data
members, the need for virtual inheritance is eliminated.
Whether this is a bug or a feature is in the eyes of the beholder. In either case, if you understand
multiple inheritance and Abstract Data Types in C++ you will be in a good position to move on to
using some of the more advanced features of Java should you decide to learn that language as well.
The observer pattern and how it is implemented both in Java and C++ is covered in detail in Robert
Martin's article "C++ and Java: A Critical Comparison," in the January 1997 issue of C++ Report.
Summary
Today you learned how to overcome some of the limitations in single inheritance. You learned about
the danger of percolating interfaces up the inheritance hierarchy, and the risks in casting down the
inheritance hierarchy. You also learned how to use multiple inheritance, what problems multiple
inheritance can create and how to solve them using virtual inheritance.
You also learned what Abstract Data Types are and how to create Abstract classes using pure virtual
functions. You learned how to implement pure virtual functions and when and why you might do so.
Finally, you saw how to implement the Observer Pattern using multiple inheritance and Abstract Data
types.
Q&A
Q. What does percolating functionality upwards mean?
A. This refers to the idea of moving shared functionality upwards into a common base class. If
more than one class shares a function, it is desirable to find a common base class in which that
function can be stored.
Q. Is percolating upwards always a good thing?A. Yes, if you are percolating shared functionality upwards. No, if all you are moving is
interface. That is, if all the derived classes can't use the method, it is a mistake to move it up
into a common base class. If you do, you'll have to switch on the runtime type of the object
before deciding if you can invoke the function.
Q. Why is switching on the runtime type of an object bad?
A. With large programs, the switch statements become big and hard to maintain. The point
of virtual functions is to let the virtual table, rather than the programmer, determine the runtime
type of the object.
Q. Why is casting bad?
A. Casting isn't bad if it is done in a way that is type-safe. If a function is called that knows that
the object must be of a particular type, casting to that type is fine. Casting can be used to
undermine the strong type checking in C++, and that is what you want to avoid. If you are
switching on the runtime type of the object and then casting a pointer, that may be a warning
sign that something is wrong with your design.
Q. Why not make all functions virtual?
A. Virtual functions are supported by a virtual function table, which incurs runtime overhead,
both in the size of the program and in the performance of the program. If you have very small
classes that you don't expect to subclass, you may not want to make any of the functions
virtual.
Q. When should the destructor be made virtual?
A. Anytime you think the class will be subclassed, and a pointer to the base class will be used
to access an object of the subclass. As a general rule of thumb, if you've made any functions in
your class virtual, be sure to make the destructor virtual as well.
Q. Why bother making an Abstract Data Type--why not just make it non-abstract and
avoid creating any objects of that type?
A. The purpose of many of the conventions in C++ is to enlist the compiler in finding bugs, so
as to avoid runtime bugs in code that you give your customers. Making a class abstract, that is,
giving it pure virtual functions, causes the compiler to flag any objects created of that abstract
type as errors.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material
covered, and exercises to provide you with experience in using what you've learned. Try to answer the
quiz and exercise questions before checking the answers in Appendix D, and make sure you
understand the answers before continuing to the next chapter.Quiz
1. What is a down cast?
2. What is the v-ptr?
3. If a round-rectangle has straight edges and rounded corners, and your RoundRect class
inherits both from Rectangle and from Circle, and they in turn both inherit from Shape,
how many Shapes are created when you create a RoundRect?
4. If Horse and Bird inherit from Animal using public virtual inheritance, do their
constructors initialize the Animal constructor? If Pegasus inherits from both Horse and
Bird, how does it initialize Animal's constructor?
5. Declare a class vehicle, and make it an abstract data type.
6. If a base class is an ADT, and it has three pure virtual functions, how many of these must be
overridden in its derived classes?
Exercises
1. Show the declaration for a class JetPlane, which inherits from Rocket and Airplane.
2. Show the declaration for 747, which inherits from the JetPlane class described in
Exercise 1.
3. Write a program that derives Car and Bus from the class Vehicle. Make Vehicle be an
ADT with two pure virtual functions. Make Car and Bus not be ADTs.
4. Modify the program in Exercise 3 so that Car is an ADT, and derive SportsCar, Wagon,
and Coupe from Car. In the Car class, provide an implementation for one of the pure virtual
functions in Vehicle and make it non-pure.
Day 14
How to work with arrays of pointers to functions.
Static Member Data
Until now, you have probably thought of the data in each object as unique to that object and not
shared among objects in a class. For example, if you have five Cat objects, each has its own age,
weight, and other data. The age of one does not affect the age of another.
There are times, however, when you'll want to keep track of a pool of data. For example, you might
want to know how many objects for a specific class have been created in your program, and how
many are still in existence. Static member variables are shared among all instances of a class. They
are a compromise between global data, which is available to all parts of your program, and member
data, which is usually available only to each object.
You can think of a static member as belonging to the class rather than to the object. Normal member
data is one per object, but static members are one per class. Listing 14.1 declares a Cat object with a
static data member, HowManyCats. This variable keeps track of how many Cat objects have been
created. This is done by incrementing the static variable, HowManyCats, with each construction and
decrementing it with each destruction.
Listing 14.1. Static member data.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
//Listing 14.1 static data members
#include <iostream.h>
class Cat
{
public:
Cat(int
virtual
virtual
virtual
age):itsAge(age){HowManyCats++; }
~Cat() { HowManyCats--; }
int GetAge() { return itsAge; }
void SetAge(int age) { itsAge = age; }12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40: }
static int HowManyCats;
private:
int itsAge;
};
int Cat::HowManyCats = 0;
int main()
{
const int MaxCats = 5; int i;
Cat *CatHouse[MaxCats];
for (i = 0; i<MaxCats; i++)
CatHouse[i] = new Cat(i);
for (i = 0; i<MaxCats; i++)
{
cout << "There are ";
cout << Cat::HowManyCats;
cout << " cats left!\n";
cout << "Deleting the one which is ";
cout << CatHouse[i]->GetAge();
cout << " years old\n";
delete CatHouse[i];
CatHouse[i] = 0;
}
return 0;
Output: There are 5 cats left!
Deleting the one which is 0 years
There are 4 cats left!
Deleting the one which is 1 years
There are 3 cats left!
Deleting the one which is 2 years
There are 2 cats left!
Deleting the one which is 3 years
There are 1 cats left!
Deleting the one which is 4 years
old
old
old
old
old
Analysis: On lines 5 to 17 the simplified class Cat is declared. On line 12, HowManyCats is
declared to be a static member variable of type int.
The declaration of HowManyCats does not define an integer; no storage space is set aside. Unlike
the non-static member variables, no storage space is set aside by instantiating a Cat object, becausethe HowManyCats member variable is not in the object. Thus, on line 19 the variable is defined and
initialized.
It is a common mistake to forget to define the static member variables of classes. Don't let this happen
to you! Of course, if it does, the linker will catch it with a pithy error message such as the following:
undefined symbol Cat::HowManyCats
You don't need to do this for itsAge, because it is a non-static member variable and is defined each
time you make a Cat object, which you do here on line 26.
The constructor for Cat increments the static member variable on line 8. The destructor decrements it
on line 9. Thus, at any moment, HowManyCats has an accurate measure of how many Cat objects
were created but not yet destroyed.
The driver program on lines 21-40 instantiates five Cats and puts them in an array. This calls five
Cat constructors, and thus HowManyCats is incremented five times from its initial value of 0.
The program then loops through each of the five positions in the array and prints out the value of
HowManyCats before deleting the current Cat pointer. The printout reflects that the starting value is
5 (after all, 5 are constructed), and that each time the loop is run, one fewer Cat remains.
Note that HowManyCats is public and is accessed directly by main(). There is no reason to expose
this member variable in this way. It is preferable to make it private along with the other member
variables and provide a public accessor method, as long as you will always access the data through an
instance of Cat. On the other hand, if you'd like to access this data directly without necessarily
having a Cat object available, you have two options: keep it public, as shown in Listing 14.2, or
provide a static member function, as discussed later in this chapter.
Listing 14.2. Accessing static members without an object.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
//Listing 14.2 static data members
#include <iostream.h>
class Cat
{
public:
Cat(int age):itsAge(age){HowManyCats++; }
virtual ~Cat() { HowManyCats--; }
virtual int GetAge() { return itsAge; }
virtual void SetAge(int age) { itsAge = age; }
static int HowManyCats;
private:15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45: }
int itsAge;
};
int Cat::HowManyCats = 0;
void TelepathicFunction();
int main()
{
const int MaxCats = 5; int i;
Cat *CatHouse[MaxCats];
for (i = 0; i<MaxCats; i++)
{
CatHouse[i] = new Cat(i);
TelepathicFunction();
}
for ( i = 0; i<MaxCats; i++)
{
delete CatHouse[i];
TelepathicFunction();
}
return 0;
}
void TelepathicFunction()
{
cout << "There are ";
cout << Cat::HowManyCats << " cats alive!\n";
Output: There are 1 cats alive!
There are 2 cats alive!
There are 3 cats alive!
There are 4 cats alive!
There are 5 cats alive!
There are 4 cats alive!
There are 3 cats alive!
There are 2 cats alive!
There are 1 cats alive!
There are 0 cats alive!
Analysis: Listing 14.2 is much like Listing 14.1 except for the addition of a new function,
TelepathicFunction(). This function does not create a Cat object, nor does it take a Cat
object as a parameter, yet it can access the HowManyCats member variable. Again, it is worthreemphasizing that this member variable is not in any particular object; it is in the class as a whole,
and, if public, can be accessed by any function in the program.
The alternative to making this member variable public is to make it private. If you do, you can access
it through a member function, but then you must have an object of that class available. Listing 14.3
shows this approach. The alternative, static member functions, is discussed immediately after the
analysis of Listing 14.3.
Listing 14.3. Accessing static members using non-static member functions.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
//Listing 14.3 private static data members
#include <iostream.h>
class Cat
{
public:
Cat(int
virtual
virtual
virtual
virtual
age):itsAge(age){HowManyCats++; }
~Cat() { HowManyCats--; }
int GetAge() { return itsAge; }
void SetAge(int age) { itsAge = age; }
int GetHowMany() { return HowManyCats; }
private:
int itsAge;
static int HowManyCats;
};
int Cat::HowManyCats = 0;
int main()
{
const int MaxCats = 5; int i;
Cat *CatHouse[MaxCats];
for (i = 0; i<MaxCats; i++)
CatHouse[i] = new Cat(i);
for (i = 0; i<MaxCats; i++)
{
cout << "There are ";
cout << CatHouse[i]->GetHowMany();
cout << " cats left!\n";
cout << "Deleting the one which is ";
cout << CatHouse[i]->GetAge()+2;36:
37:
38:
39:
40:
41: }
cout << " years old\n";
delete CatHouse[i];
CatHouse[i] = 0;
}
return 0;
Output: There are 5 cats left!
Deleting the one which is 2 years
There are 4 cats left!
Deleting the one which is 3 years
There are 3 cats left!
Deleting the one which is 4 years
There are 2 cats left!
Deleting the one which is 5 years
There are 1 cats left!
Deleting the one which is 6 years
old
old
old
old
old
Analysis: On line 17, the static member variable HowManyCats is declared to have private access.
Now you cannot access this variable from non-member functions, such as TelepathicFunction
from the previous listing.
Even though HowManyCats is static, it is still within the scope of the class. Any class function, such
as GetHowMany(), can access it, just as member functions can access any member data. However,
for a function to call GetHowMany(), it must have an object on which to call the function.
DO use static member variables to share data among all instances of a class. DO make
static member variables protected or private if you wish to restrict access to them.
DON'T use static member variables to store data for one object. Static member data is
shared among all objects of its class.
Static Member Functions
Static member functions are like static member variables: they exist not in an object but in the scope
of the class. Thus, they can be called without having an object of that class, as illustrated in Listing
14.4.
Listing 14.4. Static member functions.
1:
2:
3:
4:
//Listing 14.4 static data members
#include <iostream.h>5:
class Cat
6:
{
7:
public:
8:
Cat(int age):itsAge(age){HowManyCats++; }
9:
virtual ~Cat() { HowManyCats--; }
10:
virtual int GetAge() { return itsAge; }
11:
virtual void SetAge(int age) { itsAge = age; }
12:
static int GetHowMany() { return HowManyCats; }
13:
private:
14:
int itsAge;
15:
static int HowManyCats;
16:
};
17:
18:
int Cat::HowManyCats = 0;
19:
20:
void TelepathicFunction();
21:
22:
int main()
23:
{
24:
const int MaxCats = 5;
25:
Cat *CatHouse[MaxCats]; int i;
26:
for (i = 0; i<MaxCats; i++)
27:
{
28:
CatHouse[i] = new Cat(i);
29:
TelepathicFunction();
30:
}
31:
32:
for ( i = 0; i<MaxCats; i++)
33:
{
34:
delete CatHouse[i];
35:
TelepathicFunction();
36:
}
37:
return 0;
38:
}
39:
40:
void TelepathicFunction()
41:
{
42:
cout << "There are " << Cat::GetHowMany() << " cats
alive!\n";
43: }
Output: There are 1 cats alive!
There are 2 cats alive!
There are 3 cats alive!
There are 4 cats alive!
There are 5 cats alive!There
There
There
There
There
are
are
are
are
are
4
3
2
1
0
cats
cats
cats
cats
cats
alive!
alive!
alive!
alive!
alive!
Analysis: The static member variable HowManyCats is declared to have private access on line 15 of
the Cat declaration. The public accessor function, GetHowMany(), is declared to be both public
and static on line 12.
Since GetHowMany() is public, it can be accessed by any function, and since it is static there is no
need to have an object of type Cat on which to call it. Thus, on line 42, the function
TelepathicFunction() is able to access the public static accessor, even though it has no access
to a Cat object. Of course, you could have called GetHowMany() on the Cat objects available in
main(), just as with any other accessor functions.
NOTE: Static member functions do not have a this pointer. Therefore, they cannot be
declared const. Also, because member data variables are accessed in member
functions using the this pointer, static member functions cannot access any non-static
member variables!
Static Member Functions
You can access static member functions by calling them on an object of the class just as you do any
other member function, or you can call them without an object by fully qualifying the class and object
name. Example
class Cat
{
public:
static int GetHowMany() { return HowManyCats; }
private:
static int HowManyCats;
};
int Cat::HowManyCats = 0;
int main()
{
int howMany;
Cat theCat;
// define a cat
howMany = theCat.GetHowMany();
// access through an object
howMany = Cat::GetHowMany();
// access without an object
}Pointers to Functions
Just as an array name is a constant pointer to the first element of the array, a function name is a
constant pointer to the function. It is possible to declare a pointer variable that points to a function,
and to invoke the function by using that pointer. This can be very useful; it allows you to create
programs that decide which functions to invoke based on user input.
The only tricky part about function pointers is understanding the type of the object being pointed to. A
pointer to int points to an integer variable, and a pointer to a function must point to a function of the
appropriate return type and signature.
In the declaration
long (* funcPtr) (int);
funcPtr is declared to be a pointer (note the * in front of the name) that points to a function that
takes an integer parameter and returns a long. The parentheses around * funcPtr are necessary
because the parentheses around int bind more tightly, that is they have higher precedence than the
indirection operator (*). Without the first parentheses this would declare a function that takes an
integer and returns a pointer to a long. (Remember that spaces are meaningless here.)
Examine these two declarations:
long * Function (int);
long (* funcPtr) (int);
The first, Function (), is a function taking an integer and returning a pointer to a variable of type
long. The second, funcPtr, is a pointer to a function taking an integer and returning a variable of
type long.
The declaration of a function pointer will always include the return type and the parentheses
indicating the type of the parameters, if any. Listing 14.5 illustrates the declaration and use of function
pointers.
Listing 14.5. Pointers to functions.
1:
2:
3:
4:
5:
6:
7:
8:
// Listing 14.5 Using function pointers
#include <iostream.h>
void
void
void
void
Square (int&,int&);
Cube (int&, int&);
Swap (int&, int &);
GetVals(int&, int&);9:
void PrintVals(int, int);
10:
enum BOOL { FALSE, TRUE };
11:
12:
int main()
13:
{
14:
void (* pFunc) (int &, int &);
15:
BOOL fQuit = FALSE;
16:
17:
int valOne=1, valTwo=2;
18:
int choice;
19:
while (fQuit == FALSE)
20:
{
21:
cout << "(0)Quit (1)Change Values (2)Square (3)Cube
(4)Swap: ";
22:
cin >> choice;
23:
switch (choice)
24:
{
25:
case 1: pFunc = GetVals; break;
26:
case 2: pFunc = Square; break;
27:
case 3: pFunc = Cube; break;
28:
case 4: pFunc = Swap; break;
29:
default : fQuit = TRUE; break;
30:
}
31:
32:
if (fQuit)
33:
break;
34:
35:
PrintVals(valOne, valTwo);
36:
pFunc(valOne, valTwo);
37:
PrintVals(valOne, valTwo);
38:
}
39:
return 0;
40:
}
41:
42:
void PrintVals(int x, int y)
43:
{
44:
cout << "x: " << x << " y: " << y << endl;
45:
}
46:
47:
void Square (int & rX, int & rY)
48:
{
49:
rX *= rX;
50:
rY *= rY;
51:
}
52:
53:
void Cube (int & rX, int & rY)54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80: }
{
int tmp;
tmp = rX;
rX *= rX;
rX = rX * tmp;
tmp = rY;
rY *= rY;
rY = rY * tmp;
}
void Swap(int & rX, int & rY)
{
int temp;
temp = rX;
rX = rY;
rY = temp;
}
void GetVals (int & rValOne, int & rValTwo)
{
cout << "New value for ValOne: ";
cin >> rValOne;
cout << "New value for ValTwo: ";
cin >> rValTwo;
Output: (0)Quit (1)Change Values (2)Square
x: 1 y: 2
New value for ValOne: 2
New value for ValTwo: 3
x: 2 y: 3
(0)Quit (1)Change Values (2)Square (3)Cube
x: 2 y: 3
x: 8 y: 27
(0)Quit (1)Change Values (2)Square (3)Cube
x: 8 y: 27
x: 64 y: 729
(0)Quit (1)Change Values (2)Square (3)Cube
x: 64 y: 729
x: 729 y: 64
(0)Quit (1)Change Values (2)Square (3)Cube
(3)Cube (4)Swap: 1
(4)Swap: 3
(4)Swap: 2
(4)Swap: 4
(4)Swap: 0
Analysis: On lines 5-8, four functions are declared, each with the same return type and signature,
returning void and taking two references to integers.On line 14, pFunc is declared to be a pointer to a function that returns void and takes two integer
reference parameters. Any of the previous functions can be pointed to by pFunc. The user is
repeatedly offered the choice of which functions to invoke, and pFunc is assigned accordingly. On
lines 35-36, the current value of the two integers is printed, the currently assigned function is invoked,
and then the values are printed again.
Pointer to Function
A pointer to function is invoked exactly like the functions it points to, except that the function pointer
name is used instead of the function name. Assign a pointer to function to a specific function by
assigning to the function name without the parentheses. The function name is a constant pointer to the
function itself. Use the pointer to function just as you would the function name. The pointer to
function must agree in return value and signature with the function to which you assign it. Example
long (*pFuncOne) (int, int);
long SomeFunction (int, int);
pFuncOne = SomeFunction;
pFuncOne(5,7);
Why Use Function Pointers?
You certainly could write the program in Listing 14.5 without function pointers, but the use of these
pointers makes the intent and use of the program explicit: pick a function from a list, and then invoke
it.
Listing 14.6 uses the function prototypes and definitions from Listing 14.5, but the body of the
program does not use a function pointer. Examine the differences between these two listings.
NOTE: To compile this program, place lines 41-80 from Listing 14.5 immediately after
line 56.
Listing 14.6. Rewriting Listing 14.5 without the pointer to function.
1:
2:
3:
4:
5:
6:
7:
8:
9:
// Listing 14.6 Without function pointers
#include <iostream.h>
void
void
void
void
void
Square (int&,int&);
Cube (int&, int&);
Swap (int&, int &);
GetVals(int&, int&);
PrintVals(int, int);10:
enum BOOL { FALSE, TRUE };
11:
12:
int main()
13:
{
14:
BOOL fQuit = FALSE;
15:
int valOne=1, valTwo=2;
16:
int choice;
17:
while (fQuit == FALSE)
18:
{
19:
cout << "(0)Quit (1)Change Values (2)Square (3)Cube
(4)Swap: ";
20:
cin >> choice;
21:
switch (choice)
22:
{
23:
case 1:
24:
PrintVals(valOne, valTwo);
25:
GetVals(valOne, valTwo);
26:
PrintVals(valOne, valTwo);
27:
break;
28:
29:
case 2:
30:
PrintVals(valOne, valTwo);
31:
Square(valOne,valTwo);
32:
PrintVals(valOne, valTwo);
33:
break;
34:
35:
case 3:
36:
PrintVals(valOne, valTwo);
37:
Cube(valOne, valTwo);
38:
PrintVals(valOne, valTwo);
39:
break;
40:
41:
case 4:
42:
PrintVals(valOne, valTwo);
43:
Swap(valOne, valTwo);
44:
PrintVals(valOne, valTwo);
45:
break;
46:
47:
default :
48:
fQuit = TRUE;
49:
break;
50:
}
51:
52:
if (fQuit)
53:
break;
54:
}55:
56: }
return 0;
Output: (0)Quit (1)Change Values (2)Square
x: 1 y: 2
New value for ValOne: 2
New value for ValTwo: 3
(0)Quit (1)Change Values (2)Square (3)Cube
x: 2 y: 3
x: 8 y: 27
(0)Quit (1)Change Values (2)Square (3)Cube
x: 8 y: 27
x: 64 y: 729
(0)Quit (1)Change Values (2)Square (3)Cube
x: 64 y: 729
x: 729 y: 64
(0)Quit (1)Change Values (2)Square (3)Cube
(3)Cube (4)Swap: 1
(4)Swap: 3
(4)Swap: 2
(4)Swap: 4
(4)Swap: 0
Analysis: The implementation of the functions has been left out, because it is identical to that
provided in Listing 14.5. As you can see, the output is unchanged, but the body of the program has
expanded from 27 lines to 38. The calls to PrintVals() must be repeated for each case.
It was tempting to put PrintVals() at the top of the while loop and again at the bottom, rather
than in each case statement. This would have called PrintVals() even for the exit case, however,
and that was not part of the specification.
Setting aside the increased size of the code and the repeated calls to do the same thing, the overall
clarity is somewhat diminished. This is an artificial case, however, created to show how pointers to
functions work. In real-world conditions the advantages are even clearer: pointers to functions can
eliminate duplicate code, clarify your program, and allow you to make tables of functions to call
based on runtime conditions.
Shorthand Invocation
The pointer to function does not need to be dereferenced, though you are free to do so. Therefore, if
pFunc is a pointer to a function taking an integer and returning a variable of type long, and you
assign pFunc to a matching function, you can invoke that function with either
pFunc(x);
or
(*pFunc)(x);
The two forms are identical. The former is just a shorthand version of the latter.Arrays of Pointers to Functions
Just as you can declare an array of pointers to integers, you can declare an array of pointers to
functions returning a specific value type and with a specific signature. Listing 14.7 again rewrites
Listing 14.5, this time using an array to invoke all the choices at once.
NOTE: To compile this program, place lines 41-80 of Listing 14.5 immediately after
line 39.
Listing 14.7. Demonstrates use of an array of pointers to functions.
1:
// Listing 14.7 demonstrates use of an array of pointers to
functions
2:
3:
#include <iostream.h>
4:
5:
void Square (int&,int&);
6:
void Cube (int&, int&);
7:
void Swap (int&, int &);
8:
void GetVals(int&, int&);
9:
void PrintVals(int, int);
10:
enum BOOL { FALSE, TRUE };
11:
12:
int main()
13:
{
14:
int valOne=1, valTwo=2;
15:
int choice, i;
16:
const MaxArray = 5;
17:
void (*pFuncArray[MaxArray])(int&, int&);
18:
19:
for (i=0;i<MaxArray;i++)
20:
{
21:
cout << "(1)Change Values (2)Square (3)Cube (4)Swap:
";
22:
cin >> choice;
23:
switch (choice)
24:
{
25:
case 1:pFuncArray[i] = GetVals; break;
26:
case 2:pFuncArray[i] = Square; break;
27:
case 3:pFuncArray[i] = Cube; break;
28:
case 4:pFuncArray[i] = Swap; break;
29:
default:pFuncArray[i] = 0;30:
31:
32:
33:
34:
35:
36:
37:
38:
39: }
}
}
for (i=0;i<MaxArray; i++)
{
pFuncArray[i](valOne,valTwo);
PrintVals(valOne,valTwo);
}
return 0;
Output: (1)Change Values (2)Square
(1)Change Values (2)Square (3)Cube
(1)Change Values (2)Square (3)Cube
(1)Change Values (2)Square (3)Cube
(1)Change Values (2)Square (3)Cube
New Value for ValOne: 2
New Value for ValTwo: 3
x: 2 y: 3
x: 4 y: 9
x: 64 y: 729
x: 729 y: 64
x: 7153 y:4096
(3)Cube (4)Swap: 1
(4)Swap: 2
(4)Swap: 3
(4)Swap: 4
(4)Swap: 2
Analysis: Once again the implementation of the functions has been left out to save space, but it is the
same as in Listing 14.5. On line 17, the array pFuncArray is de- clared to be an array of 5 pointers
to functions that return void and that take two integer references.
On lines 19-31, the user is asked to pick the functions to invoke, and each member of the array is
assigned the address of the appropriate function. On lines 33-37, each function is invoked in turn. The
result is printed after each invocation.
Passing Pointers to Functions to Other Functions
The pointers to functions (and arrays of pointers to functions, for that matter) can be passed to other
functions, which may take action and then call the right function using the pointer.
For example, you might improve Listing 14.5 by passing the chosen function pointer to another
function (outside of main()), which prints the values, invokes the function, and then prints the
values again. Listing 14.8 illustrates this variation.
WARNING: To compile this program, place lines 46-80 of Listing 14.5 immediately
after line 45.Listing 14.8. Passing pointers to functions as function arguments.
1:
// Listing 14.8 Without function pointers
2:
3:
#include <iostream.h>
4:
5:
void Square (int&,int&);
6:
void Cube (int&, int&);
7:
void Swap (int&, int &);
8:
void GetVals(int&, int&);
9:
void PrintVals(void (*)(int&, int&),int&, int&);
10:
enum BOOL { FALSE, TRUE };
11:
12:
int main()
13:
{
14:
int valOne=1, valTwo=2;
15:
int choice;
16:
BOOL fQuit = FALSE;
17:
18:
void (*pFunc)(int&, int&);
19:
20:
while (fQuit == FALSE)
21:
{
22:
cout << "(0)Quit (1)Change Values (2)Square (3)Cube
(4)Swap: ";
23:
cin >> choice;
24:
switch (choice)
25:
{
26:
case 1:pFunc = GetVals; break;
27:
case 2:pFunc = Square; break;
28:
case 3:pFunc = Cube; break;
29:
case 4:pFunc = Swap; break;
30:
default:fQuit = TRUE; break;
31:
}
32:
if (fQuit == TRUE)
33:
break;
34:
PrintVals ( pFunc, valOne, valTwo);
35:
}
36:
37:
return 0;
38:
}
39:
40:
void PrintVals( void (*pFunc)(int&, int&),int& x, int& y)
41:
{
42:
cout << "x: " << x << " y: " << y << endl;43:
44:
45: }
pFunc(x,y);
cout << "x: " << x << " y: " << y << endl;
Output: (0)Quit (1)Change Values (2)Square
x: 1 y: 2
New value for ValOne: 2
New value for ValTwo: 3
x: 2 y: 3
(0)Quit (1)Change Values (2)Square (3)Cube
x: 2 y: 3
x: 8 y: 27
(0)Quit (1)Change Values (2)Square (3)Cube
x: 8 y: 27
x: 64 y: 729
(0)Quit (1)Change Values (2)Square (3)Cube
x: 64 y: 729
x: 729 y:64
(0)Quit (1)Change Values (2)Square (3)Cube
(3)Cube (4)Swap: 1
(4)Swap: 3
(4)Swap: 2
(4)Swap: 4
(4)Swap: 0
Analysis: On line 18, pFunc is declared to be a pointer to a function returning void and taking two
parameters, both integer references. On line 9, PrintVals is declared to be a function taking three
parameters. The first is a pointer to a function that returns void but takes two integer reference
parameters, and the second and third arguments to PrintVals are integer references. The user is
again prompted for which functions to call, and then on line 34 PrintVals is called.
Go find a C++ programmer and ask him what this declaration means:
void PrintVals(void (*)(int&, int&),int&, int&);
This is the kind of declaration that you use infrequently and probably look up in the book each time
you need it, but it will save your program on those rare occasions when it is exactly the required
construct.
Using typedef with Pointers to Functions
The construct void (*)(int&, int&) is cumbersome, at best. You can use typedef to
simplify this, by declaring a type VPF as a pointer to a function returning void and taking two integer
references. Listing 14.9 rewrites Listing 14.8 using this typedef statement.
NOTE: To compile this program, place lines 46-80 of Listing 14.5 immediately after
line 45.Listing 14.9. Using typedef to make pointers to functions more readable.
1:
more
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
";
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
// Listing 14.9. Using typedef to make pointers to functions
_readable
#include <iostream.h>
void Square (int&,int&);
void Cube (int&, int&);
void Swap (int&, int &);
void GetVals(int&, int&);
typedef void (*VPF) (int&, int&) ;
void PrintVals(VPF,int&, int&);
enum BOOL { FALSE, TRUE };
int main()
{
int valOne=1, valTwo=2;
int choice;
BOOL fQuit = FALSE;
VPF pFunc;
while (fQuit == FALSE)
{
cout << "(0)Quit (1)Change Values (2)Square (3)Cube (4)Swap:
cin >> choice;
switch (choice)
{
case 1:pFunc = GetVals; break;
case 2:pFunc = Square; break;
case 3:pFunc = Cube; break;
case 4:pFunc = Swap; break;
default:fQuit = TRUE; break;
}
if (fQuit == TRUE)
break;
PrintVals ( pFunc, valOne, valTwo);
}
return 0;
}
void PrintVals( VPF pFunc,int& x, int& y)
{
cout << "x: " << x << " y: " << y << endl;43:
pFunc(x,y);
44:
cout << "x: " << x << " y: " << y << endl;
45: }
Output: (0)Quit (1)Change Values (2)Square
x: 1 y: 2
New value for ValOne: 2
New value for ValTwo: 3
x: 2 y: 3
(0)Quit (1)Change Values (2)Square (3)Cube
x: 2 y: 3
x: 8 y: 27
(0)Quit (1)Change Values (2)Square (3)Cube
x: 8 y: 27
x: 64 y: 729
(0)Quit (1)Change Values (2)Square (3)Cube
x: 64 y: 729
x: 729 y: 64
(0)Quit (1)Change Values (2)Square (3)Cube
(3)Cube (4)Swap: 1
(4)Swap: 3
(4)Swap: 2
(4)Swap: 4
(4)Swap: 0
Analysis: On line 9, typedef is used to declare VPF to be of the type "function that returns void
and takes two parameters, both integer references."
On line 10, the function PrintVals() is declared to take three parameters: a VPF and two integer
references. On line 19, pFunc is now declared to be of type VPF.
Once the type VPF is defined, all subsequent uses to declare pFunc and PrintVals() are much
cleaner. As you can see, the output is identical.
Pointers to Member Functions
Up until this point, all of the function pointers you've created have been for general, non-class
functions. It is also possible to create pointers to functions that are members of classes.
To create a pointer to member function, use the same syntax as with a pointer to function, but include
the class name and the scoping operator (::). Thus, if pFunc points to a member function of the
class Shape, which takes two integers and returns void, the declaration for pFunc is the following:
void (Shape::*pFunc) (int, int);
Pointers to member functions are used in exactly the same way as pointers to functions, except that
they require an object of the correct class on which to invoke them. Listing 14.10 illustrates the use of
pointers to member functions.
Listing 14.10. Pointers to member functions.1:
//Listing 14.10 Pointers to member functions using virtual
methods
2:
3:
#include <iostream.h>
4:
5:
enum BOOL {FALSE, TRUE};
6:
class Mammal
7:
{
8:
public:
9:
Mammal():itsAge(1) { }
10:
~Mammal() { }
11:
virtual void Speak() const = 0;
12:
virtual void Move() const = 0;
13:
protected:
14:
int itsAge;
15:
};
16:
17:
class Dog : public Mammal
18:
{
19:
public:
20:
void Speak()const { cout << "Woof!\n"; }
21:
void Move() const { cout << "Walking to heel...\n"; }
22:
};
23:
24:
25:
class Cat : public Mammal
26:
{
27:
public:
28:
void Speak()const { cout << "Meow!\n"; }
29:
void Move() const { cout << "slinking...\n"; }
30:
};
31:
32:
33:
class Horse : public Mammal
34:
{
35:
public:
36:
void Speak()const { cout << "Winnie!\n"; }
37:
void Move() const { cout << "Galloping...\n"; }
38:
};
39:
40:
41:
int main()
42:
{
43:
void (Mammal::*pFunc)() const =0;
44:
Mammal* ptr =0;45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75: }
int Animal;
int Method;
BOOL fQuit = FALSE;
while (fQuit == FALSE)
{
cout << "(0)Quit (1)dog (2)cat (3)horse: ";
cin >> Animal;
switch (Animal)
{
case 1: ptr = new Dog; break;
case 2: ptr = new Cat; break;
case 3: ptr = new Horse; break;
default: fQuit = TRUE; break;
}
if (fQuit)
break;
cout << "(1)Speak (2)Move: ";
cin >> Method;
switch (Method)
{
case 1: pFunc = Mammal::Speak; break;
default: pFunc = Mammal::Move; break;
}
(ptr->*pFunc)();
delete ptr;
}
return 0;
Output: (0)Quit (1)dog (2)cat (3)horse: 1
(1)Speak (2)Move: 1
Woof!
(0)Quit (1)dog (2)cat (3)horse: 2
(1)Speak (2)Move: 1
Meow!
(0)Quit (1)dog (2)cat (3)horse: 3
(1)Speak (2)Move: 2
Galloping
(0)Quit (1)dog (2)cat (3)horse: 0
Analysis: On lines 6-15, the abstract data type Mammal is declared with two pure virtual methods,
Speak() and Move(). Mammal is subclassed into Dog, Cat, and Horse, each of which overrides
Speak() and Move().The driver program in main() asks the user to choose which type of animal to create, and then a new
subclass of Animal is created on the free store and assigned to ptr on lines 55-57.
The user is then prompted for which method to invoke, and that method is assigned to the pointer
pFunc. On line 71, the method chosen is invoked by the object created, by using the pointer ptr to
access the object and pFunc to access the function.
Finally, on line 72, delete is called on the pointer ptr to return the memory set aside for the object
to the free store. Note that there is no reason to call delete on pFunc because this is a pointer to
code, not to an object on the free store. In fact, attempting to do so will generate a compile-time error.
Arrays of Pointers to Member Functions
As with pointers to functions, pointers to member functions can be stored in an array. The array can
be initialized with the addresses of various member functions, and these can be invoked by offsets
into the array. Listing 14.11 illustrates this technique.
Listing 14.11. Array of pointers to member functions.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
Little
17:
18:
19:
20:
21:
22:
23:
24:
//Listing 14.11 Array of pointers to member functions
#include <iostream.h>
enum BOOL {FALSE, TRUE};
class Dog
{
public:
void Speak()const { cout << "Woof!\n"; }
void Move() const { cout << "Walking to heel...\n"; }
void Eat() const { cout << "Gobbling food...\n"; }
void Growl() const { cout << "Grrrrr\n"; }
void Whimper() const { cout << "Whining noises...\n"; }
void RollOver() const { cout << "Rolling over...\n"; }
void PlayDead() const { cout << "Is this the end of
Caeser?\n"; }
};
typedef void (Dog::*PDF)()const ;
int main()
{
const int MaxFuncs = 7;
PDF DogFunctions[MaxFuncs] =
{ Dog::Speak,25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54: }
Dog::Move,
Dog::Eat,
Dog::Growl,
Dog::Whimper,
Dog::RollOver,
Dog::PlayDead };
Dog* pDog =0;
int Method;
BOOL fQuit = FALSE;
while (!fQuit)
{
cout <<
"(0)Quit (1)Speak (2)Move (3)Eat (4)Growl";
cout << " (5)Whimper (6)Roll Over (7)Play Dead: ";
cin >> Method;
if (Method == 0)
{
fQuit = TRUE;
break;
}
else
{
pDog = new Dog;
(pDog->*DogFunctions[Method-1])();
delete pDog;
}
}
return 0;
Output: (0)Quit (1)Speak (2)Move (3)Eat (4)Growl (5)Whimper
(6)Roll Over (7)Play Dead: 1
Woof!
(0)Quit (1)Speak (2)Move (3)Eat (4)Growl (5)Whimper (6)Roll Over
(7)Play Dead: 4
Grrr
(0)Quit (1)Speak (2)Move (3)Eat (4)Growl (5)Whimper (6)Roll Over
(7)Play Dead: 7
Is this the end of Little Caeser?
(0)Quit (1)Speak (2)Move (3)Eat (4)Growl (5)Whimper (6)Roll Over
(7)Play Dead: 0
Analysis: On lines 7-17, the class Dog is created, with 7 member functions all sharing the same return
type and signature. On line 19, a typedef declares PDF to be a pointer to a member function of Dog
that takes no parameters and returns no values, and that is const: the signature of the 7 memberfunctions of Dog.
On lines 23-30, the array DogFunctions is declared to hold 7 such member functions, and it is
initialized with the addresses of these functions.
On lines 38 and 39, the user is prompted to pick a method. Unless they pick Quit, a new Dog is
created on the heap, and then the correct method is invoked on the array on line 49. Here's another
good line to show to the hotshot C++ programmers in your company; ask them what this does:
(pDog->*DogFunctions[Method-1])();
Once again, this is a bit esoteric, but when you need a table built from member functions, it can make
your program far easier to read and understand.
DO invoke pointers to member functions on a specific object of a class. DO use
typedef to make pointer to member function declarations easier to read. DON'T use
pointer to member functions when there are simpler solutions.
Summary
Today you learned how to create static member variables in your class. Each class, rather than each
object, has one instance of the static member variable. It is possible to access this member variable
without an object of the class type by fully qualifying the name, assuming you've declared the static
member to have public access.
Static member variables can be used as counters across instances of the class. Because they are not
part of the object, the declaration of static member variables does not allocate memory, and static
member variables must be defined and initialized outside the declaration of the class.
Static member functions are part of the class in the same way that static member variables are. They
can be accessed without a particular object of the class, and can be used to access static member data.
Static member functions cannot be used to access non-static member data because they do not have a
this pointer.
Because static member functions do not have a this pointer, they also cannot be made const.
const in a member function indicates that the this pointer is const.
You also learned how to declare and use pointers to functions and pointers to member functions. You
saw how to create arrays of these pointers and how to pass them to functions.
Pointers to functions and pointers to member functions can be used to create tables of functions that
can be selected from at runtime. This can give your program flexibility that is not easily achievedwithout these pointers.
Q&A
Q. Why use static data when you can use global data?
A. Static data is scoped to the class. In this manner, static data are available only through an
object of the class, through an explicit call using the class name if they are public, or by using a
static member function. Static data are typed to the class type, however, and the restricted
access and strong typing makes static data safer than global data.
Q. Why use static member functions when you can use global functions?
A. Static member functions are scoped to the class, and can be called only by using an object
of the class or an explicit full specification (such as ClassName::FunctionName()).
Q. Is it common to use many pointers to functions and pointers to member functions?
A. No, these have their special uses, but are not common constructs. Many complex and
powerful programs have neither.
Workshop
The Workshop contains quiz questions to help solidify your understanding of the material covered and
exercises to provide you with experience in using what you've learned. Try to answer the quiz and
exercise questions before checking the answers in Appendix D, and make sure you understand the
answers before going to the next chapter.
Quiz
1. Can static member variables be private?
2. Show the declaration for a static member variable.
3. Show the declaration for a static function pointer.
4. Show the declaration for a pointer to function returning long and taking an integer
parameter.
5. Modify the pointer in Question 4 so it's a pointer to member function of class Car.
6. Show the declaration for an array of 10 pointers as defined in Question 5.
Exercises
1. Write a short program declaring a class with one member variable and one static membervariable. Have the constructor initialize the member variable and increment the static member
variable. Have the destructor decrement the member variable.
2. Using the program from Exercise 1, write a short driver program that makes three objects
and then displays their member variables and the static member variable. Then
destroy each object and show the effect on the static member variable.
3. Modify the program from Exercise 2 to use a static member function to access the static
member variable. Make the static member variable private.
4. Write a pointer to member function to access the non-static member data in the program in
Exercise 3, and use that pointer to print the value of that data.
5. Add two more member variables to the class from the previous questions. Add accessor
functions that get the value of these values, and give all the member functions the same return
values and signatures. Use the pointer to member function to access these functions.In Review
The Week in Review program for Week 2 brings together many of the skills you've acquired over the
past fortnight and produces a powerful program.
This demonstration of linked lists utilizes virtual functions, pure virtual functions, function overriding,
polymorphism, public inheritance, function overloading, forever loops, pointers, references, and more.
The goal of this program is to create a linked list. The nodes on the list are designed to hold parts, as
might be used in a factory. While this is not the final form of this program, it does make a good
demonstration of a fairly advanced data structure. The code list is 311 lines. Try to analyze the code
on your own before reading the analysis that follows the output.
Listing R2.1. Week 2 in Review listing.
0:
// **************************************************
1:
//
2:
// Title:
Week 2 in Review
3:
//
4:
// File:
Week2
5:
//
6:
// Description:
Provide a linked list demonstration
program
7:
//
8:
// Classes:
PART - holds part numbers and potentially
other
9:
//
information about parts
10:
//
11:
//
PartNode - acts as a node in a PartsList
12:
//
13:
//
PartsList - provides the mechanisms for a
linked list
."of parts
14:
//
15:
// Author:
Jesse Liberty (jl)
16:
//
17:
// Developed:
486/66 32mb RAM MVC 1.5
18:
//
19:
// Target:
Platform independent
20:
//21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
// Rev History: 9/94 - First release (jl)
//
// **************************************************
#include <iostream.h>
typedef unsigned long ULONG;
typedef unsigned short USHORT;
// **************** Part ************
// Abstract base class of parts
class Part
{
public:
Part():itsPartNumber(1) {}
Part(ULONG PartNumber):itsPartNumber(PartNumber){}
virtual ~Part(){};
ULONG GetPartNumber() const { return itsPartNumber; }
virtual void Display() const =0; // must be overridden
private:
ULONG itsPartNumber;
};
// implementation of pure virtual function so that
// derived classes can chain up
void Part::Display() const
{
cout << "\nPart Number: " << itsPartNumber << endl;
}
// **************** Car Part ************
class CarPart : public Part
{
public:
CarPart():itsModelYear(94){}
CarPart(USHORT year, ULONG partNumber);
virtual void Display() const
{
Part::Display(); cout << "Model Year: ";
cout << itsModelYear << endl;
}
private:
USHORT itsModelYear;67:
};
68:
69:
CarPart::CarPart(USHORT year, ULONG partNumber):
70:
itsModelYear(year),
71:
Part(partNumber)
72:
{}
73:
74:
75:
// **************** AirPlane Part ************
76:
77:
class AirPlanePart : public Part
78:
{
79:
public:
80:
AirPlanePart():itsEngineNumber(1){};
81:
AirPlanePart(USHORT EngineNumber, ULONG PartNumber);
82:
virtual void Display() const
83:
{
84:
Part::Display(); cout << "Engine No.: ";
85:
cout << itsEngineNumber << endl;
86:
}
87:
private:
88:
USHORT itsEngineNumber;
89:
};
90:
91:
AirPlanePart::AirPlanePart(USHORT EngineNumber, ULONG
PartNumber):
92:
itsEngineNumber(EngineNumber),
93:
Part(PartNumber)
94:
{}
95:
96:
// **************** Part Node ************
97:
class PartNode
98:
{
99:
public:
100:
PartNode (Part*);
101:
~PartNode();
102:
void SetNext(PartNode * node) { itsNext = node; }
103:
PartNode * GetNext() const;
104:
Part * GetPart() const;
105:
private:
106:
Part *itsPart;
107:
PartNode * itsNext;
108:
};
109:
110:
// PartNode Implementations...
111:112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
const;
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
PartNode::PartNode(Part* pPart):
itsPart(pPart),
itsNext(0)
{}
PartNode::~PartNode()
{
delete itsPart;
itsPart = 0;
delete itsNext;
itsNext = 0;
}
// Returns NULL if no next PartNode
PartNode * PartNode::GetNext() const
{
return itsNext;
}
Part * PartNode::GetPart() const
{
if (itsPart)
return itsPart;
else
return NULL; //error
}
// **************** Part List ************
class PartsList
{
public:
PartsList();
~PartsList();
// needs copy constructor and operator equals!
Part*
Find(ULONG & position, ULONG PartNumber)
ULONG
Part*
static
GetCount() const { return itsCount; }
GetFirst() const;
PartsList& GetGlobalPartsList()
{
return
GlobalPartsList;
}
void
void
Part*
private:
Insert(Part *);
Iterate(void (Part::*f)()const) const;
operator[](ULONG) const;157:
PartNode * pHead;
158:
ULONG itsCount;
159:
static PartsList GlobalPartsList;
160:
};
161:
162:
PartsList PartsList::GlobalPartsList;
163:
164:
// Implementations for Lists...
165:
166:
PartsList::PartsList():
167:
pHead(0),
168:
itsCount(0)
169:
{}
170:
171:
PartsList::~PartsList()
172:
{
173:
delete pHead;
174:
}
175:
176:
Part*
PartsList::GetFirst() const
177:
{
178:
if (pHead)
179:
return pHead->GetPart();
180:
else
181:
return NULL; // error catch here
182:
}
183:
184:
Part * PartsList::operator[](ULONG offSet) const
185:
{
186:
PartNode* pNode = pHead;
187:
188:
if (!pHead)
189:
return NULL; // error catch here
190:
191:
if (offSet > itsCount)
192:
return NULL; // error
193:
194:
for (ULONG i=0;i<offSet; i++)
195:
pNode = pNode->GetNext();
196:
197:
return
pNode->GetPart();
198:
}
199:
200:
Part*
PartsList::Find(ULONG & position, ULONG
PartNumber) const
201:
{202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
PartNode * pNode = 0;
for (pNode = pHead, position = 0;
pNode!=NULL;
pNode = pNode->GetNext(), position++)
{
if (pNode->GetPart()->GetPartNumber() == PartNumber)
break;
}
if (pNode == NULL)
return NULL;
else
return pNode->GetPart();
}
void PartsList::Iterate(void (Part::*func)()const) const
{
if (!pHead)
return;
PartNode* pNode = pHead;
do
(pNode->GetPart()->*func)();
while (pNode = pNode->GetNext());
}
void PartsList::Insert(Part* pPart)
{
PartNode * pNode = new PartNode(pPart);
PartNode * pCurrent = pHead;
PartNode * pNext = 0;
ULONG New = pPart->GetPartNumber();
ULONG Next = 0;
itsCount++;
if (!pHead)
{
pHead = pNode;
return;
}
// if this one is smaller than head
// this one is the new head
if (pHead->GetPart()->GetPartNumber() > New)
{
pNode->SetNext(pHead);
pHead = pNode;248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
return;
}
for (;;)
{
// if there is no next, append this new one
if (!pCurrent->GetNext())
{
pCurrent->SetNext(pNode);
return;
}
// if this goes after this one and before the next
// then insert it here, otherwise get the next
pNext = pCurrent->GetNext();
Next = pNext->GetPart()->GetPartNumber();
if (Next > New)
{
pCurrent->SetNext(pNode);
pNode->SetNext(pNext);
return;
}
pCurrent = pNext;
}
}
int main()
{
PartsList pl = PartsList::GetGlobalPartsList();
Part * pPart = 0;
ULONG PartNumber;
USHORT value;
ULONG choice;
while (1)
{
cout << "(0)Quit (1)Car (2)Plane: ";
cin >> choice;
if (!choice)
break;
cout << "New PartNumber?: ";
cin >> PartNumber;
if (choice == 1)294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311: }
{
cout << "Model Year?: ";
cin >> value;
pPart = new CarPart(value,PartNumber);
}
else
{
cout << "Engine Number?: ";
cin >> value;
pPart = new AirPlanePart(value,PartNumber);
}
pl.Insert(pPart);
}
void (Part::*pFunc)()const = Part::Display;
pl.Iterate(pFunc);
return 0;
Output: (0)Quit (1)Car (2)Plane: 1
New PartNumber?: 2837
Model Year? 90
(0)Quit (1)Car (2)Plane: 2
New PartNumber?: 378
Engine Number?: 4938
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 4499
Model Year? 94
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 3000
Model Year? 93
(0)Quit (1)Car (2)Plane: 0
Part Number: 378
Engine No.: 4938
Part Number: 2837
Model Year: 90
Part Number: 3000
Model Year: 93
Part Number: 4499
Model Year: 94
Analysis: The Week 2 in Review listing provides a linked list implementation for Part objects. A
linked list is a dynamic data structure; that is, it is like an array but it is sized to fit as objects areadded and deleted.
This particular linked list is designed to hold objects of class Part, where Part is an abstract data
type serving as a base class to any objects with a part number. In this example, Part has been
subclassed into CarPart and AirPlanePart.
Class Part is declared on lines 34-44, and consists of a part number and some accessors. Presumably
this class could be fleshed out to hold other important information about the parts, such as what
components they are used in, how many are in stock, and so forth. Part is an abstract data type,
enforced by the pure virtual function Display().
Note that Display() does have an implementation, on lines 48-51. It is the designer's intention that
derived classes will be forced to create their own Display() method, but may chain up to this
method as well.
Two simple derived classes, CarPart and AirPlanePart, are provided on lines 55-67 and 77-89,
respectively. Each provides an overridden Display() method, which does in fact chain up to the
base class Display() method.
The class PartNode serves as the interface between the Part class and the PartList class. It
contains a pointer to a part and a pointer to the next node in the list. Its only methods are to get and set
the next node in the list and to return the Part to which it points.
The intelligence of the list is, appropriately, in the class PartsList, whose declaration is on lines
140-160. PartsList keeps a pointer to the first element in the list (pHead) and uses that to access
all other methods by walking the list. Walking the list means asking each node in the list for the next
node, until you reach a node whose next pointer is NULL.
This is only a partial implementation; a fully developed list would provide either greater access to its
first and last nodes, or would provide an iterator object, which allows clients to easily walk the list.
PartsList nonetheless provides a number of interesting methods, which are listed in alphabetical
order. This is often a good idea, as it makes finding the functions easier.
Find() takes a PartNumber and a ULONG. If the part corresponding to PartNumber is found, it
returns a pointer to the Part and fills the ULONG with the position of that part in the list. If
PartNumber is not found, it returns NULL, and the position is meaningless.
GetCount() returns the number of elements in the list. PartsList keeps this number as a
member variable, itsCount, though it could, of course, compute this number by walking the list.
GetFirst() returns a pointer to the first Part in the list, or returns NULL if the list is empty.
GetGlobalPartsList() returns a reference to the static member variable GlobalPartsList.
This is a static instance of this class; every program with a PartsList also has one
GlobalPartsList, though, of course, it is free to make other PartsLists as well. A fullimplementation of this idea would modify the constructor of Part to ensure that every part is created
on the GlobalPartsList.
Insert takes a pointer to a Part, creates a PartNode for it, and adds the Part to the list, ordered
by PartNumber.
Iterate takes a pointer to a member function of Part, which takes no parameters, returns void,
and is const. It calls that function for every Part object in the list. In the example program this is
called on Display(), which is a virtual function, so the appropriate Display() method will be
called based on the runtime type of the Part object called.
Operator[] allows direct access to the Part at the offset provided. Rudimentary bounds checking
is provided; if the list is NULL or if the offset requested is greater than the size of the list, NULL is
returned as an error condition.
Note that in a real program these comments on the functions would be written into the class
declaration.
The driver program is on lines 274-311. A pointer to PartsList is declared on line 266 and
initialized with GlobalPartsList. Note that GlobalPartsList is initialized on line 162. This
is necessary as the declaration of a static member variable does not define it; definition must be done
outside the declaration of the class.
On lines 282-307, the user is repeatedly prompted to choose whether to enter a car part or an airplane
part. Depending on the choice the right value is requested, and the appropriate part is created. Once
created, the part is inserted into the list on line 306.
The implementation for the Insert() method of PartsList is on lines 226-272. When the first
part number is entered, 2837, a CarPart with that part number and the model year 90 is created
and passed in to LinkedList::Insert().
On line 228, a new PartNode is created with that part, and the variable New is initialized with the
part number. The PartsList's itsCount member variable is incremented on line 234.
On line 236, the test that pHead is NULL will evaluate TRUE. Since this is the first node, it is true
that the PartsList's pHead pointer has zero. Thus, on line 238, pHead is set to point to the new
node and this function returns.
The user is prompted to enter a second part, and this time an AirPlane part with part number 378
and engine number 4938 is entered. Once again PartsList::Insert() is called, and once
again pNode is initialized with the new node. The static member variable itsCount is incremented
to 2, and pHead is tested. Since pHead was assigned last time, it is no longer null and the test fails.
On line 244, the part number held by pHead, 2837, is compared against the current part number,
378. Since the new one is smaller than the one held by pHead, the new one must become the newhead pointer, and the test on line 244 is true.
On line 246, the new node is set to point to the node currently pointed to by pHead. Note that this
does not point the new node to pHead, but rather to the node that pHead was pointing to! On line
247, pHead is set to point to the new node.
The third time through the loop, the user enters the part number 4499 for a Car with model year 94.
The counter is incremented and the number this time is not less than the number pointed to by
pHead, so the for loop that begins on line 251 is entered.
The value pointed to by pHead is 378. The value pointed to by the second node is 2837. The
current value is 4499. The pointer pCurrent points to the same node as pHead and so has a next
value; pCurrent points to the second node, and so the test on line 254 fails.
The pointer pCurrent is set to point to the next node and the loop repeats. This time the test on line
254 succeeds. There is no next item, so the current node is told to point to the new node on line 256,
and the insert is finished.
The fourth time through, the part number 3000 is entered. This proceeds just like the previous
iteration, but this time when the current node is pointing to 2837 and the next node has 4499, the
test on line 264 returns TRUE and the new node is inserted into position.
When the user finally presses 0, the test on line 287 evaluates true and the while(1) loop breaks.
On line 308, the member function Display() is assigned to the pointer to member function pFunc.
In a real program this would be assigned dynamically, based on the user's choice of method.
The pointer to member function is passed to the PartsList Iterate() method. On line 216, the
Iterate() method ensures that the list is not empty. Then, on lines 221-223, each Part on the list
is called using the pointer to member function. This calls the appropriate Display() method for the
Part, as shown in the output
Containment
As you have seen in previous examples, it is possible for the member data of a class to include objects
of another class. C++ programmers say that the outer class contains the inner class. Thus, an
Employee class might contain string objects (for the name of the employee), as well as integers (for
the employee's salary and so forth).
Listing 15.1 describes an incomplete, but still useful, String class. This listing does not produce any
output. Instead Listing 15.1 will be used with later listings.
Listing 15.1. The String class.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
#include <iostream.h>
#include <string.h>
class String
{
public:
// constructors
String();
String(const char *const);
String(const String &);
~String();
// overloaded operators
char & operator[](int offset);
char operator[](int offset) const;
String operator+(const String&);
void operator+=(const String&);
String & operator= (const String &);
// General accessors
int GetLen()const { return itsLen; }22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
const char * GetString() const { return itsString; }
// static int ConstructorCount;
private:
String (int);
// private constructor
char * itsString;
unsigned short itsLen;
};
// default constructor creates string of 0 bytes
String::String()
{
itsString = new char[1];
itsString[0] = `\0';
itsLen=0;
// cout << "\tDefault string constructor\n";
// ConstructorCount++;
}
// private (helper) constructor, used only by
// class methods for creating a new string of
// required size. Null filled.
String::String(int len)
{
itsString = new char[len+1];
for (int i = 0; i<=len; i++)
itsString[i] = `\0';
itsLen=len;
// cout << "\tString(int) constructor\n";
// ConstructorCount++;
}
// Converts a character array to a String
String::String(const char * const cString)
{
itsLen = strlen(cString);
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen; i++)
itsString[i] = cString[i];
itsString[itsLen]='\0';
// cout << "\tString(char*) constructor\n";
// ConstructorCount++;
}
// copy constructor68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
String::String (const String & rhs)
{
itsLen=rhs.GetLen();
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen;i++)
itsString[i] = rhs[i];
itsString[itsLen] = `\0';
// cout << "\tString(String&) constructor\n";
// ConstructorCount++;
}
// destructor, frees allocated memory
String::~String ()
{
delete [] itsString;
itsLen = 0;
// cout << "\tString destructor\n";
}
// operator equals, frees existing memory
// then copies string and size
String& String::operator=(const String & rhs)
{
if (this == &rhs)
return *this;
delete [] itsString;
itsLen=rhs.GetLen();
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen;i++)
itsString[i] = rhs[i];
itsString[itsLen] = `\0';
return *this;
// cout << "\tString operator=\n";
}
//non constant offset operator, returns
// reference to character so it can be
// changed!
char & String::operator[](int offset)
{
if (offset > itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
}114:
// constant offset operator for use
115:
// on const objects (see copy constructor!)
116:
char String::operator[](int offset) const
117:
{
118:
if (offset > itsLen)
119:
return itsString[itsLen-1];
120:
else
121:
return itsString[offset];
122:
}
123:
124:
// creates a new string by adding current
125:
// string to rhs
126:
String String::operator+(const String& rhs)
127:
{
128:
int totalLen = itsLen + rhs.GetLen();
129:
String temp(totalLen);
130:
int i, j;
131:
for (i = 0; i<itsLen; i++)
132:
temp[i] = itsString[i];
133:
for (j = 0; j<rhs.GetLen(); j++, i++)
134:
temp[i] = rhs[j];
135:
temp[totalLen]='\0';
136:
return temp;
137:
}
138:
139:
// changes current string, returns nothing
140:
void String::operator+=(const String& rhs)
141:
{
142:
unsigned short rhsLen = rhs.GetLen();
143:
unsigned short totalLen = itsLen + rhsLen;
144:
String temp(totalLen);
145:
for (int i = 0; i<itsLen; i++)
146:
temp[i] = itsString[i];
147:
for (int j = 0; j<rhs.GetLen(); j++, i++)
148:
temp[i] = rhs[i-itsLen];
149:
temp[totalLen]='\0';
150:
*this = temp;
151:
}
152:
153: // int String::ConstructorCount = 0;
Output: None.
Analysis: Listing 15.1 provides a String class much like the one used in Listing 11.14 of Day 11,
"Arrays." The significant difference here is that the constructors and a few other functions in Listing11.14 have print statements to show their use, which are currently commented out in Listing 15.1.
These functions will be used in later examples.
On line 23, the static member variable ConstructorCount is declared, and on line 153 it is
initialized. This variable is incremented in each string constructor. All of this is currently commented
out; it will be used in a later listing.
Listing 15.2 describes an Employee class that contains three string objects. Note that a number of
statements are commented out; they will be used in later listings.
Listing 15.2. The Employee class and driver program.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
}
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
class Employee
{
public:
Employee();
Employee(char *, char *, char *, long);
~Employee();
Employee(const Employee&);
Employee & operator= (const Employee &);
const String & GetFirstName() const
{ return itsFirstName; }
const String & GetLastName() const { return itsLastName;
const String & GetAddress() const { return itsAddress; }
long GetSalary() const { return itsSalary; }
void SetFirstName(const String & fName)
{ itsFirstName = fName; }
void SetLastName(const String & lName)
{ itsLastName = lName; }
void SetAddress(const String & address)
{ itsAddress = address; }
void SetSalary(long salary) { itsSalary = salary; }
private:
String
itsFirstName;
String
itsLastName;
String
itsAddress;
long
itsSalary;
};
Employee::Employee():
itsFirstName(""),33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
itsLastName(""),
itsAddress(""),
itsSalary(0)
{}
Employee::Employee(char * firstName, char * lastName,
char * address, long salary):
itsFirstName(firstName),
itsLastName(lastName),
itsAddress(address),
itsSalary(salary)
{}
Employee::Employee(const Employee & rhs):
itsFirstName(rhs.GetFirstName()),
itsLastName(rhs.GetLastName()),
itsAddress(rhs.GetAddress()),
itsSalary(rhs.GetSalary())
{}
Employee::~Employee() {}
Employee & Employee::operator= (const Employee & rhs)
{
if (this == &rhs)
return *this;
itsFirstName = rhs.GetFirstName();
itsLastName = rhs.GetLastName();
itsAddress = rhs.GetAddress();
itsSalary = rhs.GetSalary();
return *this;
}
int main()
{
Employee Edie("Jane","Doe","1461 Shore Parkway", 20000);
Edie.SetSalary(50000);
String LastName("Levine");
Edie.SetLastName(LastName);
Edie.SetFirstName("Edythe");
cout << "Name: ";
cout << Edie.GetFirstName().GetString();
cout << " " << Edie.GetLastName().GetString();79:
80:
81:
82:
83:
84: }
cout
cout
cout
cout
return
<<
<<
<<
<<
0;
".\nAddress: ";
Edie.GetAddress().GetString();
".\nSalary: " ;
Edie.GetSalary();
NOTE: Put the code from Listing 15.1 into a file called STRING.HPP. Then any time
you need the String class you can include Listing 15.1 by using #include. For
example, at the top of Listing 15.2 add the line #include String.hpp. This will
add the String class to your program.
Output: Name: Edythe Levine.
Address: 1461 Shore Parkway.
Salary: 50000
Analysis: Listing 15.2 shows the Employee class, which contains three string objects:
itsFirstName, itsLastName, and itsAddress.
On line 70, an Employee object is created, and four values are passed in to initialize the Employee
object. On line 71, the Employee access function SetSalary() is called, with the constant value
50000. Note that in a real program this would either be a dynamic value (set at runtime) or a
constant.
On line 72, a string is created and initialized using a C++ string constant. This string object is then
used as an argument to SetLastName() on line 73.
On line 74, the Employee function SetFirstName() is called with yet another string constant.
However, if you are paying close attention, you will notice that Employee does not have a function
SetFirstName() that takes a character string as its argument; SetFirstName() requires a
constant string reference.
The compiler resolves this because it knows how to make a string from a constant character string. It
knows this because you told it how to do so on line 9 of Listing 15.1.
Accessing Members of the Contained Class
Employee objects do not have special access to the member variables of String. If the
Employee object Edie tried to access the member variable itsLen of its own itsFirstName
member variable, it would get a compile-time error. This is not much of a burden, however. The
accessor functions provide an interface for the String class, and the Employee class need not
worry about the implementation details, any more than it worries about how the integer variable,
itsSalary, stores its information.Filtering Access to Contained Members
Note that the String class provides the operator+. The designer of the Employee class has
blocked access to the operator+ being called on Employee objects by declaring that all the string
accessors, such as GetFirstName(), return a constant reference. Because operator+ is not (and
can't be) a const function (it changes the object it is called on), attempting to write the following
will cause a compile-time error:
String buffer = Edie.GetFirstName() + Edie.GetLastName();
GetFirstName() returns a constant String, and you can't call operator+ on a constant
object.
To fix this, overload GetFirstName() to be non-const:
const String & GetFirstName() const { return itsFirstName; }
String & GetFirstName() { return itsFirstName; }
Note that the return value is no longer const and that the member function itself is no longer
const. Changing the return value is not sufficient to overload the function name; you must change
the constancy of the function itself.
Cost of Containment
It is important to note that the user of an Employee class pays the price of each of those string
objects each time one is constructed, or a copy of the Employee is made.
Uncommenting the cout statements in Listing 15.1, lines 38, 51, 63, 75, 84, and 100, reveals how
often these are called. Listing 15.3 rewrites the driver program to add print statements indicating
where in the program objects are being created:
NOTE: To compile this listing, follow these steps: 1. Uncomment lines 38, 51, 63, 75,
84, and 100 in Listing 15.1. 2. Edit Listing 15.2. Remove lines 64-80 and substitute
Listing 15.3. 3. Add #include string.hpp as previously noted.
Listing 15.3. Contained class constructors.
1:
2:
3:
4:
5:
int main()
{
cout << "Creating Edie...\n";
Employee Edie("Jane","Doe","1461 Shore Parkway", 20000);
Edie.SetSalary(20000);6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21: }
cout << "Calling SetFirstName with char *...\n";
Edie.SetFirstName("Edythe");
cout << "Creating temporary string LastName...\n";
String LastName("Levine");
Edie.SetLastName(LastName);
cout
cout
cout
cout
cout
cout
cout
cout
return
<<
<<
<<
<<
<<
<<
<<
<<
0;
"Name: ";
Edie.GetFirstName().GetString();
" " << Edie.GetLastName().GetString();
"\nAddress: ";
Edie.GetAddress().GetString();
"\nSalary: " ;
Edie.GetSalary();
endl;
Output: 1:
Creating Edie...
2:
String(char*) constructor
3:
String(char*) constructor
4:
String(char*) constructor
5:
Calling SetFirstName with char *...
6:
String(char*) constructor
7:
String destructor
8:
Creating temporary string LstName...
9:
String(char*) constructor
10: Name: Edythe Levine
11: Address: 1461 Shore Parkway
12: Salary: 20000
13:
String destructor
14:
String destructor
15:
String destructor
16:
String destructor
Analysis: Listing 15.3 uses the same class declarations as Listings 15.1 and 15.2. However, the cout
statements have been uncommented. The output from Listing 15.3 has been numbered to make
analysis easier.
On line 3 of Listing 15.3, the statement Creating Edie... is printed, as reflected on line 1 of the
output. On line 4 an Employee object, Edie, is created with four parameters. The output reflects the
constructor for String being called three times, as expected.
Line 6 prints an information statement, and then on line 7 is the statement
Edie.SetFirstName("Edythe"). This statement causes a temporary string to be created from
the character string "Edythe", as reflected on lines 6 and 7 of the output. Note that the temporary is
destroyed immediately after it is used in the assignment statement.On line 9, a String object is created in the body of the program. Here the programmer is doing
explicitly what the compiler did implicitly on the previous statement. This time you see the
constructor on line 9 of the output, but no destructor. This object will not be destroyed until it goes out
of scope at the end of the function.
On lines 13-19, the strings in the employee object are destroyed as the Employee object falls out of
scope, and the string LastName, created on line 9, is destroyed as well when it falls out of scope.
Copying by Value
Listing 15.3 illustrates how the creation of one Employee object caused five string constructor calls.
Listing 15.4 again rewrites the driver program. This time the print statements are not used, but the
string static member variable ConstructorCount is uncommented and used.
Examination of Listing 15.1 shows that ConstructorCount is incremented each time a string
constructor is called. The driver program in 15.4 calls the print functions, passing in the
Employee object, first by reference and then by value. ConstructorCount keeps track of how
many string objects are created when the employee is passed as a parameter.
NOTE: To compile this listing: 1. Uncomment lines 23, 39, 52, 64, 76, and 152 in
Listing 15.1. 2. Edit Listing 15.2. Remove lines 68-84 and substitute Listing 15.4. 3.
Add #include string.hpp as previously noted.
Listing 15.4. Passing by value
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
void PrintFunc(Employee);
void rPrintFunc(const Employee&);
int main()
{
Employee Edie("Jane","Doe","1461 Shore Parkway", 20000);
Edie.SetSalary(20000);
Edie.SetFirstName("Edythe");
String LastName("Levine");
Edie.SetLastName(LastName);
cout << "Constructor count: " ;
cout << String::ConstructorCount << endl;
rPrintFunc(Edie);
cout << "Constructor count: ";
cout << String::ConstructorCount << endl;
PrintFunc(Edie);18:
cout << "Constructor count: ";
19:
cout << String::ConstructorCount << endl;
20:
return 0;
21:
}
22:
void PrintFunc (Employee Edie)
23:
{
24:
25:
cout << "Name: ";
26:
cout << Edie.GetFirstName().GetString();
27:
cout << " " << Edie.GetLastName().GetString();
28:
cout << ".\nAddress: ";
29:
cout << Edie.GetAddress().GetString();
30:
cout << ".\nSalary: " ;
31:
cout << Edie.GetSalary();
32:
cout << endl;
33:
34:
}
35:
36:
void rPrintFunc (const Employee& Edie)
37:
{
38:
cout << "Name: ";
39:
cout << Edie.GetFirstName().GetString();
40:
cout << " " << Edie.GetLastName().GetString();
41:
cout << "\nAddress: ";
42:
cout << Edie.GetAddress().GetString();
43:
cout << "\nSalary: " ;
44:
cout << Edie.GetSalary();
45:
cout << endl;
46: }
Output: String(char*) constructor
String(char*) constructor
String(char*) constructor
String(char*) constructor
String destructor
String(char*) constructor
Constructor count: 5
Name: Edythe Levine
Address: 1461 Shore Parkway
Salary: 20000
Constructor count: 5
String(String&) constructor
String(String&) constructor
String(String&) constructor
Name: Edythe Levine.
Address: 1461 Shore Parkway.
Salary: 20000String destructor
String destructor
String destructor
Constructor count: 8
String destructor
String destructor
String destructor
String destructor
Analysis: The output shows that five string objects were created as part of creating one Employee
object. When the Employee object is passed to rPrintFunc() by reference, no additional
Employee objects are created, and so no additional String objects are created. (They too are
passed by reference.)
When, on line 14, the Employee object is passed to PrintFunc() by value, a copy of the
Employee is created, and three more string objects are created (by calls to the copy constructor).
Implementation in Terms of Inheritance/Containment Versus Delegation
At times, one class wants to draw on some of the attributes of another class. For example, let's say you
need to create a PartsCatalog class. The specification you've been given defines a
PartsCatalog as a collection of parts; each part has a unique part number. The PartsCatalog
does not allow duplicate entries, and does allow access by part number.
The listing for the Week in Review for Week 2 provides a LinkedList class. This LinkedList
is well-tested and understood, and you'd like to build on that technology when making your
PartsCatalog, rather than inventing it from scratch.
You could create a new PartsCatalog class and have it contain a LinkedList. The
PartsCatalog could delegate management of the linked list to its contained LinkedList object.
An alternative would be to make the PartsCatalog derive from LinkedList and thereby inherit
the properties of a LinkedList. Remembering, however, that public inheritance provides an is-a
relationship, you should question whether a PartsCatalog really is a type of LinkedList.
One way to answer the question of whether PartsCatalog is a LinkedList is to assume that
LinkedList is the base and PartsCatalog is the derived class, and then to ask these other
questions:
1. Is there anything in the base class that should not be in the derived? For example, does the
LinkedList base class have functions that are inappropriate for the PartsCatalog
class? If so, you probably don't want public inheritance.
2. Might the class you are creating have more than one of the base? For example, might a
PartsCatalog need two LinkedLists in each object? If it might, you almost certainlywant to use containment.
3. Do you need to inherit from the base class so that you can take advantage of virtual
functions or access protected members? If so, you must use inheritance, public or private.
Based on the answers to these questions, you must chose between public inheritance (the is-a
relationship) and either private inheritance or containment.
New Term:
Contained --An object declared as a member of another class contained by that class.
Delegation --Using the attributes of a contained class to accomplish functions not otherwise
available to the containing class.
Implemented in terms of --Building one class on the capabilities of another without using
public inheritance.
Delegation
Why not derive PartsCatalog from LinkedList? The PartsCatalog isn't a LinkedList
because LinkedLists are ordered collections and each member of the collection can repeat. The
PartsCatalog has unique entries that are not ordered. The fifth member of the PartsCatalog
is not part number 5.
Certainly it would have been possible to inherit publicly from PartsList and then override
Insert() and the offset operators ([]) to do the right thing, but then you would have changed the
essence of the PartsList class. Instead you'll build a PartsCatalog that has no offset operator,
does not allow duplicates, and defines the operator+ to combine two sets.
The first way to accomplish this is with containment. The PartsCatalog will delegate list
management to a contained LinkedList. Listing 15.5 illustrates this approach.
Listing 15.5. Delegating to a contained LinkedList.
0:
1:
2:
3:
4:
5:
6:
7:
#include <iostream.h>
typedef unsigned long ULONG;
typedef unsigned short USHORT;
// **************** Part ************8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
// Abstract base class of parts
class Part
{
public:
Part():itsPartNumber(1) {}
Part(ULONG PartNumber):
itsPartNumber(PartNumber){}
virtual ~Part(){}
ULONG GetPartNumber() const
{ return itsPartNumber; }
virtual void Display() const =0;
private:
ULONG itsPartNumber;
};
// implementation of pure virtual function so that
// derived classes can chain up
void Part::Display() const
{
cout << "\nPart Number: " << itsPartNumber << endl;
}
// **************** Car Part ************
class CarPart : public Part
{
public:
CarPart():itsModelYear(94){}
CarPart(USHORT year, ULONG partNumber);
virtual void Display() const
{
Part::Display();
cout << "Model Year: ";
cout << itsModelYear << endl;
}
private:
USHORT itsModelYear;
};
CarPart::CarPart(USHORT year, ULONG partNumber):
itsModelYear(year),
Part(partNumber)
{}
// **************** AirPlane Part ************54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
class AirPlanePart : public Part
{
public:
AirPlanePart():itsEngineNumber(1){};
AirPlanePart
(USHORT EngineNumber, ULONG PartNumber);
virtual void Display() const
{
Part::Display();
cout << "Engine No.: ";
cout << itsEngineNumber << endl;
}
private:
USHORT itsEngineNumber;
};
AirPlanePart::AirPlanePart
(USHORT EngineNumber, ULONG PartNumber):
itsEngineNumber(EngineNumber),
Part(PartNumber)
{}
// **************** Part Node ************
class PartNode
{
public:
PartNode (Part*);
~PartNode();
void SetNext(PartNode * node)
{ itsNext = node; }
PartNode * GetNext() const;
Part * GetPart() const;
private:
Part *itsPart;
PartNode * itsNext;
};
// PartNode Implementations...
PartNode::PartNode(Part* pPart):
itsPart(pPart),
itsNext(0)
{}
PartNode::~PartNode()
{100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
const;
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
delete itsPart;
itsPart = 0;
delete itsNext;
itsNext = 0;
}
// Returns NULL if no next PartNode
PartNode * PartNode::GetNext() const
{
return itsNext;
}
Part * PartNode::GetPart() const
{
if (itsPart)
return itsPart;
else
return NULL; //error
}
// **************** Part List ************
class PartsList
{
public:
PartsList();
~PartsList();
// needs copy constructor and operator equals!
void
Iterate(void (Part::*f)()const) const;
Part*
Find(ULONG & position, ULONG PartNumber)
Part*
GetFirst() const;
void
Insert(Part *);
Part*
operator[](ULONG) const;
ULONG
GetCount() const { return itsCount; }
static
PartsList& GetGlobalPartsList()
{
return GlobalPartsList;
}
private:
PartNode * pHead;
ULONG itsCount;
static PartsList GlobalPartsList;
};145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
PartsList PartsList::GlobalPartsList;
PartsList::PartsList():
pHead(0),
itsCount(0)
{}
PartsList::~PartsList()
{
delete pHead;
}
Part*
PartsList::GetFirst() const
{
if (pHead)
return pHead->GetPart();
else
return NULL; // error catch here
}
Part * PartsList::operator[](ULONG offSet) const
{
PartNode* pNode = pHead;
if (!pHead)
return NULL; // error catch here
if (offSet > itsCount)
return NULL; // error
for (ULONG i=0;i<offSet; i++)
pNode = pNode->GetNext();
return
pNode->GetPart();
}
Part*
PartsList::Find(
ULONG & position,
ULONG PartNumber) const
{
PartNode * pNode = 0;
for (pNode = pHead, position = 0;
pNode!=NULL;
pNode = pNode->GetNext(), position++)
{191:
if (pNode->GetPart()->GetPartNumber() ==
PartNumber)
192:
break;
193:
}
194:
if (pNode == NULL)
195:
return NULL;
196:
else
197:
return pNode->GetPart();
198:
}
199:
200:
void PartsList::Iterate(void (Part::*func)()const) const
201:
{
202:
if (!pHead)
203:
return;
204:
PartNode* pNode = pHead;
205:
do
206:
(pNode->GetPart()->*func)();
207:
while (pNode = pNode->GetNext());
208:
}
209:
210:
void PartsList::Insert(Part* pPart)
211:
{
212:
PartNode * pNode = new PartNode(pPart);
213:
PartNode * pCurrent = pHead;
214:
PartNode * pNext = 0;
215:
216:
ULONG New = pPart->GetPartNumber();
217:
ULONG Next = 0;
218:
itsCount++;
219:
220:
if (!pHead)
221:
{
222:
pHead = pNode;
223:
return;
224:
}
225:
226:
// if this one is smaller than head
227:
// this one is the new head
228:
if (pHead->GetPart()->GetPartNumber() > New)
229:
{
230:
pNode->SetNext(pHead);
231:
pHead = pNode;
232:
return;
233:
}
234:
235:
for (;;)236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
}
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
{
// if there is no next, append this new one
if (!pCurrent->GetNext())
{
pCurrent->SetNext(pNode);
return;
}
// if this goes after this one and before the next
// then insert it here, otherwise get the next
pNext = pCurrent->GetNext();
Next = pNext->GetPart()->GetPartNumber();
if (Next > New)
{
pCurrent->SetNext(pNode);
pNode->SetNext(pNext);
return;
}
pCurrent = pNext;
}
}
class PartsCatalog
{
public:
void Insert(Part *);
ULONG Exists(ULONG PartNumber);
Part * Get(int PartNumber);
operator+(const PartsCatalog &);
void ShowAll() { thePartsList.Iterate(Part::Display);
private:
PartsList thePartsList;
};
void PartsCatalog::Insert(Part * newPart)
{
ULONG partNumber = newPart->GetPartNumber();
ULONG offset;
if (!thePartsList.Find(offset, partNumber))
thePartsList.Insert(newPart);
else281:
{
282:
cout << partNumber << " was the ";
283:
switch (offset)
284:
{
285:
case 0: cout << "first "; break;
286:
case 1: cout << "second "; break;
287:
case 2: cout << "third "; break;
288:
default: cout << offset+1 << "th ";
289:
}
290:
cout << "entry. Rejected!\n";
291:
}
292:
}
293:
294:
ULONG PartsCatalog::Exists(ULONG PartNumber)
295:
{
296:
ULONG offset;
297:
thePartsList.Find(offset,PartNumber);
298:
return offset;
299:
}
300:
301:
Part * PartsCatalog::Get(int PartNumber)
302:
{
303:
ULONG offset;
304:
Part * thePart = thePartsList.Find(offset,
PartNumber);
305:
return thePart;
306:
}
307:
308:
309:
int main()
310:
{
311:
PartsCatalog pc;
312:
Part * pPart = 0;
313:
ULONG PartNumber;
314:
USHORT value;
315:
ULONG choice;
316:
317:
while (1)
318:
{
319:
cout << "(0)Quit (1)Car (2)Plane: ";
320:
cin >> choice;
321:
322:
if (!choice)
323:
break;
324:
325:
cout << "New PartNumber?: ";326:
344: }
cin >>
PartNumber;
if (choice == 1)
{
cout << "Model Year?: ";
cin >> value;
pPart = new CarPart(value,PartNumber);
}
else
{
cout << "Engine Number?: ";
cin >> value;
pPart = new AirPlanePart(value,PartNumber);
}
pc.Insert(pPart);
}
pc.ShowAll();
return 0;
Output: (0)Quit (1)Car (2)Plane: 1
New PartNumber?: 1234
Model Year?: 94
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 4434
Model Year?: 93
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 1234
Model Year?: 94
1234 was the first entry. Rejected!
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 2345
Model Year?: 93
(0)Quit (1)Car (2)Plane: 0
Part Number: 1234
Model Year: 94
Part Number: 2345
Model Year: 93
Part Number: 4434
Model Year: 93
Analysis: Listing 15.7 reproduces the interface to the Part, PartNode, and PartList classes
from Week 2 in Review, but to save room it does not reproduce the implementation of their methods.A new class, PartsCatalog, is declared on lines 260-270. PartsCatalog has a PartsList as
its data member, to which it delegates list management. Another way to say this is that the
PartsCatalog is implemented in terms of this PartsList.
Note that clients of the PartsCatalog do not have access to the PartsList directly. The
interface is through the PartsCatalog, and as such the behavior of the PartsList is
dramatically changed. For example, the PartsCatalog::Insert() method does not allow
duplicate entries into the PartsList.
The implementation of PartsCatalog::Insert() starts on line 272. The Part that is passed in
as a parameter is asked for the value of its itsPartNumber member variable. This value is fed to
the PartsList's Find() method, and if no match is found the number is inserted; otherwise an
informative error message is printed.
Note that PartsCatalog does the actual insert by calling Insert() on its member variable, pl,
which is a PartsList. The mechanics of the actual insertion and the maintenance of the linked list,
as well as searching and retrieving from the linked list, are maintained in the contained PartsList
member of PartsCatalog. There is no reason for PartsCatalog to reproduce this code; it can
take full advantage of the well-defined interface.
This is the essence of reusability within C++: PartsCatalog can reuse the PartsList code, and
the designer of PartsCatalog is free to ignore the implementation details of PartsList. The
interface to PartsList (that is, the class declaration) provides all the information needed by the
designer of the PartsCatalog class.
Private Inheritance
If PartsCatalog needed access to the protected members of LinkedList (in this case there are
none), or needed to override any of the LinkedList methods, then PartsCatalog would be
forced to inherit from PartsList.
Since a PartsCatalog is not a PartsList object, and since you don't want to expose the entire
set of functionality of PartsList to clients of PartsCatalog, you need to use private
inheritance.
The first thing to know about private inheritance is that all of the base member variables and functions
are treated as if they were declared to be private, regardless of their actual access level in the base.
Thus, to any function that is not a member function of PartsCatalog, every function inherited
from PartsList is inaccessible. This is critical: private inheritance does not involve inheriting
interface, just implementation.
To clients of the PartsCatalog class, the PartsList class is invisible. None of its interface is
available: you can't call any of its methods. You can call PartsCatalog methods, however, and
they can access all of LinkedLists, because they are derived from LinkedLists.The important thing here is that the PartsCatalog isn't a PartsList, as would have been
implied by public inheritance. It is implemented in terms of a PartsList, just as would have been
the case with containment. The private inheritance is just a convenience.
Listing 15.6 demonstrates the use of private inheritance by rewriting the PartsCatalog class as
privately derived from PartsList.
NOTE: To compile this program, replace lines 260-344 of Listing 15.5 with Listing
15.6 and recompile.
Listing 15.6. Private inheritance.
1: //listing 15.6 demonstrates private inheritance
2:
3: //rewrites PartsCatalog from listing 15.5
4:
5: //see attached notes on compiling
6:
7:
class PartsCatalog : private PartsList
8:
{
9:
public:
10:
void Insert(Part *);
11:
ULONG Exists(ULONG PartNumber);
12:
Part * Get(int PartNumber);
13:
operator+(const PartsCatalog &);
14:
void ShowAll() { Iterate(Part::Display); }
15:
private:
16:
};
17:
18:
void PartsCatalog::Insert(Part * newPart)
19:
{
20:
ULONG partNumber = newPart->GetPartNumber();
21:
ULONG offset;
22:
23:
if (!Find(offset, partNumber))
24:
PartsList::Insert(newPart);
25:
else
26:
{
27:
cout << partNumber << " was the ";
28:
switch (offset)
29:
{
30:
case 0: cout << "first "; break;
31:
case 1: cout << "second "; break;32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
case 2: cout << "third "; break;
default: cout << offset+1 << "th ";
}
cout << "entry. Rejected!\n";
}
}
ULONG PartsCatalog::Exists(ULONG PartNumber)
{
ULONG offset;
Find(offset,PartNumber);
return offset;
}
Part * PartsCatalog::Get(int PartNumber)
{
ULONG offset;
return (Find(offset, PartNumber));
}
int main()
{
PartsCatalog pc;
Part * pPart = 0;
ULONG PartNumber;
USHORT value;
ULONG choice;
while (1)
{
cout << "(0)Quit (1)Car (2)Plane: ";
cin >> choice;
if (!choice)
break;
cout << "New PartNumber?: ";
cin >> PartNumber;
if (choice == 1)
{
cout << "Model Year?: ";
cin >> value;
pPart = new CarPart(value,PartNumber);
}78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88: }
else
{
cout << "Engine Number?: ";
cin >> value;
pPart = new AirPlanePart(value,PartNumber);
}
pc.Insert(pPart);
}
pc.ShowAll();
return 0;
Output: (0)Quit (1)Car (2)Plane: 1
New PartNumber?: 1234
Model Year?: 94
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 4434
Model Year?: 93
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 1234
Model Year?: 94
1234 was the first entry. Rejected!
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 2345
Model Year?: 93
(0)Quit (1)Car (2)Plane: 0
Part Number: 1234
Model Year: 94
Part Number: 2345
Model Year: 93
Part Number: 4434
Model Year: 93
Analysis: Listing 15.6 shows only the changed interface to PartsCatalog and the rewritten driver
program. The interfaces to the other classes are unchanged from Listing 15.5.
On line 7 of Listing 15.6, PartsCatalog is declared to derive privately from PartsList. The
interface to PartsCatalog doesn't change from Listing 15.5, though of course it no longer needs
an object of type PartsList as member data.
The PartsCatalog ShowAll() function calls PartsList Iterate() with the appropriate
pointer to member function of class Part. ShowAll() acts as a public interface to Iterate(),
providing the correct information but preventing client classes from calling Iterate() dir-ectly.Although PartsList might allow other functions to be passed to Iterate(), PartsCatalog
does not.
The Insert() function has changed as well. Note, on line 23, that Find() is now called directly,
because it is inherited from the base class. The call on line 24 to Insert() must be fully qualified,
of course, or it would endlessly recurse into itself.
In short, when methods of PartsCatalog want to call PartsList methods, they may do so
directly. The only exception is when PartsCatalog has overridden the method and the
PartsList version is needed, in which case the function name must be qualified fully.
Private inheritance allows the PartsCatalog to inherit what it can use, but still provide mediated
access to Insert and other methods to which client classes should not have direct access.
DO inherit publicly when the derived object is a kind of the base class. DO use
containment when you want to delegate functionality to another class, but you don't
need access to its protected members. DO use private inheritance when you need to
implement one class in terms of another, and you need access to the base class's
protected members. DON'T use private inheritance when you need to use more than
one of the base class. You must use containment. For example, if PartsCatalog
needed two PartsLists, you could not have used private inheritance. DON'T use
public inheritance when members of the base class should not be available to clients of
the derived class.
Friend Classes
Sometimes you will create classes together, as a set. For example, PartNode and PartsList were
tightly coupled, and it would have been convenient if PartsList could have read PartNode's
Part pointer, itsPart, directly.
You wouldn't want to make itsPart public, or even protected, because this is an implementation
detail of PartNode and you want to keep it private. You do want to expose it to PartsList,
however.
If you want to expose your private member data or functions to another class, you must declare that
class to be a friend. This extends the interface of your class to include the friend class.
Once PartsNode declares PartsList to be a friend, all of PartsNode's member data and
functions are public as far as PartsList is concerned.
It is important to note that friendship cannot be transferred. Just because you are my friend and Joe is
your friend doesn't mean Joe is my friend. Friendship is not inherited either. Again, just because you
are my friend and I'm willing to share my secrets with you doesn't mean I'm willing to share mysecrets with your children.
Finally, friendship is not commutative. Assigning Class One to be a friend of Class Two does
not make Class Two a friend of Class One. Just because you are willing to tell me your secrets
doesn't mean I am willing to tell you mine.
Listing 15.7 illustrates friendship by rewriting the example from Listing 15.6, making PartsList a
friend of PartNode. Note that this does not make PartNode a friend of PartsList.
Listing 15.7. Friend class illustrated.
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
#include <iostream.h>
typedef unsigned long ULONG;
typedef unsigned short USHORT;
// **************** Part ************
// Abstract base class of parts
class Part
{
public:
Part():itsPartNumber(1) {}
Part(ULONG PartNumber):
itsPartNumber(PartNumber){}
virtual ~Part(){}
ULONG GetPartNumber() const
{ return itsPartNumber; }
virtual void Display() const =0;
private:
ULONG itsPartNumber;
};
// implementation of pure virtual function so that
// derived classes can chain up
void Part::Display() const
{
cout << "\nPart Number: ";
cout << itsPartNumber << endl;
}
// **************** Car Part ************
class CarPart : public Part34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
{
public:
CarPart():itsModelYear(94){}
CarPart(USHORT year, ULONG partNumber);
virtual void Display() const
{
Part::Display();
cout << "Model Year: ";
cout << itsModelYear << endl;
}
private:
USHORT itsModelYear;
};
CarPart::CarPart(USHORT year, ULONG partNumber):
itsModelYear(year),
Part(partNumber)
{}
// **************** AirPlane Part ************
class AirPlanePart : public Part
{
public:
AirPlanePart():itsEngineNumber(1){};
AirPlanePart
(USHORT EngineNumber, ULONG PartNumber);
virtual void Display() const
{
Part::Display();
cout << "Engine No.: ";
cout << itsEngineNumber << endl;
}
private:
USHORT itsEngineNumber;
};
AirPlanePart::AirPlanePart
(USHORT EngineNumber, ULONG PartNumber):
itsEngineNumber(EngineNumber),
Part(PartNumber)
{}
// **************** Part Node ************
class PartNode80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
{
public:
friend class PartsList;
PartNode (Part*);
~PartNode();
void SetNext(PartNode * node)
{ itsNext = node; }
PartNode * GetNext() const;
Part * GetPart() const;
private:
Part *itsPart;
PartNode * itsNext;
};
PartNode::PartNode(Part* pPart):
itsPart(pPart),
itsNext(0)
{}
PartNode::~PartNode()
{
delete itsPart;
itsPart = 0;
delete itsNext;
itsNext = 0;
}
// Returns NULL if no next PartNode
PartNode * PartNode::GetNext() const
{
return itsNext;
}
Part * PartNode::GetPart() const
{
if (itsPart)
return itsPart;
else
return NULL; //error
}
// **************** Part List ************
class PartsList
{126:
127:
128:
129:
130:
131:
const;
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
public:
PartsList();
~PartsList();
// needs copy constructor and operator equals!
void
Iterate(void (Part::*f)()const) const;
Part*
Find(ULONG & position, ULONG PartNumber)
Part*
void
Part*
ULONG
static
GetFirst() const;
Insert(Part *);
operator[](ULONG) const;
GetCount() const { return itsCount; }
PartsList& GetGlobalPartsList()
{
return
GlobalPartsList;
}
private:
PartNode * pHead;
ULONG itsCount;
static PartsList GlobalPartsList;
};
PartsList PartsList::GlobalPartsList;
// Implementations for Lists...
PartsList::PartsList():
pHead(0),
itsCount(0)
{}
PartsList::~PartsList()
{
delete pHead;
}
Part*
PartsList::GetFirst() const
{
if (pHead)
return pHead->itsPart;
else
return NULL; // error catch here
}
Part * PartsList::operator[](ULONG offSet) const
{
PartNode* pNode = pHead;171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
const
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
if (!pHead)
return NULL; // error catch here
if (offSet > itsCount)
return NULL; // error
for (ULONG i=0;i<offSet; i++)
pNode = pNode->itsNext;
return
pNode->itsPart;
}
Part* PartsList::Find(ULONG & position, ULONG PartNumber)
{
PartNode * pNode = 0;
for (pNode = pHead, position = 0;
pNode!=NULL;
pNode = pNode->itsNext, position++)
{
if (pNode->itsPart->GetPartNumber() == PartNumber)
break;
}
if (pNode == NULL)
return NULL;
else
return pNode->itsPart;
}
void PartsList::Iterate(void (Part::*func)()const) const
{
if (!pHead)
return;
PartNode* pNode = pHead;
do
(pNode->itsPart->*func)();
while (pNode = pNode->itsNext);
}
void PartsList::Insert(Part* pPart)
{
PartNode * pNode = new PartNode(pPart);
PartNode * pCurrent = pHead;
PartNode * pNext = 0;216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
ULONG New = pPart->GetPartNumber();
ULONG Next = 0;
itsCount++;
if (!pHead)
{
pHead = pNode;
return;
}
// if this one is smaller than head
// this one is the new head
if (pHead->itsPart->GetPartNumber() > New)
{
pNode->itsNext = pHead;
pHead = pNode;
return;
}
for (;;)
{
// if there is no next, append this new one
if (!pCurrent->itsNext)
{
pCurrent->itsNext = pNode;
return;
}
// if this goes after this one and before the next
// then insert it here, otherwise get the next
pNext = pCurrent->itsNext;
Next = pNext->itsPart->GetPartNumber();
if (Next > New)
{
pCurrent->itsNext = pNode;
pNode->itsNext = pNext;
return;
}
pCurrent = pNext;
}
}
class PartsCatalog : private PartsList
{
public:
void Insert(Part *);262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
ULONG Exists(ULONG PartNumber);
Part * Get(int PartNumber);
operator+(const PartsCatalog &);
void ShowAll() { Iterate(Part::Display); }
private:
};
void PartsCatalog::Insert(Part * newPart)
{
ULONG partNumber = newPart->GetPartNumber();
ULONG offset;
if (!Find(offset, partNumber))
PartsList::Insert(newPart);
else
{
cout << partNumber << " was the ";
switch (offset)
{
case 0: cout << "first "; break;
case 1: cout << "second "; break;
case 2: cout << "third "; break;
default: cout << offset+1 << "th ";
}
cout << "entry. Rejected!\n";
}
}
ULONG PartsCatalog::Exists(ULONG PartNumber)
{
ULONG offset;
Find(offset,PartNumber);
return offset;
}
Part * PartsCatalog::Get(int PartNumber)
{
ULONG offset;
return (Find(offset, PartNumber));
}
int main()
{
PartsCatalog pc;
Part * pPart = 0;308:
339: }
ULONG PartNumber;
USHORT value;
ULONG choice;
while (1)
{
cout << "(0)Quit (1)Car (2)Plane: ";
cin >> choice;
if (!choice)
break;
cout << "New PartNumber?: ";
cin >> PartNumber;
if (choice == 1)
{
cout << "Model Year?: ";
cin >> value;
pPart = new CarPart(value,PartNumber);
}
else
{
cout << "Engine Number?: ";
cin >> value;
pPart = new AirPlanePart(value,PartNumber);
}
pc.Insert(pPart);
}
pc.ShowAll();
return 0;
Output: (0)Quit (1)Car (2)Plane: 1
New PartNumber?: 1234
Model Year?: 94
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 4434
Model Year?: 93
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 1234
Model Year?: 94
1234 was the first entry. Rejected!
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 2345
Model Year?: 93(0)Quit (1)Car (2)Plane:
0
Part Number: 1234
Model Year: 94
Part Number: 2345
Model Year: 93
Part Number: 4434
Model Year: 93
Analysis: On line 82, the class PartsList is declared to be a friend to the PartNode class.
Because PartsList has not yet been declared, the compiler would complain that this type is not
known.
This listing places the friend declaration in the public section, but this is not required; it can be put
anywhere in the class declaration without changing the meaning of the statement. Because of this
statement, all the private member data and functions are available to any member function of class
PartsList.
On line 160, the implementation of the member function GetFirst() reflects this change. Rather
than returning pHead->GetPart, this function can now return the otherwise private member data
by writing pHead->itsPart. Similarly, the Insert() function can now write pNode-
>itsNext = pHead, rather than writing pNode->SetNext(pHead).
Admittedly these are trivial changes, and there is not a good enough reason to make PartsList a
friend of PartNode, but they do serve to illustrate how the keyword friend works.
Declarations of friend classes should be used with extreme caution. If two classes are inextricably
entwined, and one must frequently access data in the other, there may be good reason to use this
declaration. But use it sparingly; it is often just as easy to use the public accessor methods, and doing
so allows you to change one class without having to recompile the other.
NOTE: You will often hear novice C++ programmers complain that friend declarations
"undermine" the encapsulation so important to object-oriented programming. This is,
frankly, errant nonsense. The friend declaration makes the declared friend part of the
class interface, and is no more an undermining of encapsulation than is public
derivation.
Friend Class
Declare one class to be a friend of another by putting the word friend into the class granting the
access rights. That is, I can declare you to be my friend, but you can't declare yourself to be my friend.Example:
class PartNode{
public:
friend class PartList;
PartNode
};
// declares PartList to be a friend of
Friend Functions
At times you will want to grant this level of access not to an entire class, but only to one or two
functions of that class. You can do this by declaring the member functions of the other class to be
friends, rather than declaring the entire class to be a friend. In fact, you can declare any function,
whether or not it is a member function of another class, to be a friend function.
Friend Functions and Operator Overloading
Listing 15.1 provided a String class that overrode the operator+. It also provided a constructor
that took a constant character pointer, so that string objects could be created from C-style strings. This
allowed you to create a string and add to it with a C-style string.
NOTE: C-style strings are null-terminated character arrays, such as char
myString[] = "Hello World."
What you could not do, however, was create a C-style string (a character string) and add to it using a
string object, as shown in this example:
char cString[] = {"Hello"};
String sString(" World");
String sStringTwo = cString + sString;
//error!
C-style strings don't have an overloaded operator+. As discussed on Day 10, "Advanced
Functions," when you say cString + sString; what you are really calling is
cString.operator+(sString). Since you can't call operator+() on a C-style string, this
causes a compile-time error.
You can solve this problem by declaring a friend function in String, which overloads operator+
but takes two string objects. The C-style string will be converted to a string object by the appropriate
constructor, and then operator+ will be called using the two string objects.
NOTE: To compile this listing, copy lines 33-123 from Listing 15.1 after line 33 ofListing 15.8.
Listing 15.8. Friendly operator+.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
//Listing 15.8 - friendly operators
#include <iostream.h>
#include <string.h>
// Rudimentary string class
class String
{
public:
// constructors
String();
String(const char *const);
String(const String &);
~String();
// overloaded operators
char & operator[](int offset);
char operator[](int offset) const;
String operator+(const String&);
friend String operator+(const String&, const String&);
void operator+=(const String&);
String & operator= (const String &);
// General accessors
int GetLen()const { return itsLen; }
const char * GetString() const { return itsString; }
private:
String (int);
// private constructor
char * itsString;
unsigned short itsLen;
};
// creates a new string by adding current
// string to rhs
String String::operator+(const String& rhs)
{
int totalLen = itsLen + rhs.GetLen();
String temp(totalLen);
for (int i = 0; i<itsLen; i++)
temp[i] = itsString[i];42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81: }
for (int j = 0; j<rhs.GetLen(); j++, i++)
temp[i] = rhs[j];
temp[totalLen]='\0';
return temp;
}
// creates a new string by adding
// one string to another
String operator+(const String& lhs, const String& rhs)
{
int totalLen = lhs.GetLen() + rhs.GetLen();
String temp(totalLen);
for (int i = 0; i<lhs.GetLen(); i++)
temp[i] = lhs[i];
for (int j = 0; j<rhs.GetLen(); j++, i++)
temp[i] = rhs[j];
temp[totalLen]='\0';
return temp;
}
int main()
{
String s1("String One ");
String s2("String Two ");
char *c1 = { "C-String One " } ;
String s3;
String s4;
String s5;
cout
cout
cout
s3 =
cout
s4 =
cout
s5 =
cout
return
<<
<<
<<
s1
<<
s1
<<
c1
<<
0;
"s1: "
"s2: "
"c1: "
+ s2;
"s3: "
+ c1;
"s4: "
+ s1;
"s5: "
<< s1.GetString() << endl;
<< s2.GetString() << endl;
<< c1 << endl;
<< s3.GetString() << endl;
<< s4.GetString() << endl;
<< s5.GetString() << endl;
Output: s1: String One
s2: String Two
c1: C-String One
s3: String One String Two
s4: String One C-String Ones5: C-String One String Two
Analysis: The implementation of all of the string methods except operator+ are unchanged from
Listing 15.1, and so are left out of this listing. On line 20, a new operator+ is overloaded to take
two constant string references and to return a string, and this function is declared to be a friend.
Note that this operator+ is not a member function of this or any other class. It is declared within
the declaration of the String class only so that it can be made a friend, but because it is declared no
other function prototype is needed.
The implementation of this operator+ is on lines 50-60. Note that it is similar to the earlier
operator+, except that it takes two strings and accesses them both through their public accessor
methods.
The driver program demonstrates the use of this function on line 78, where operator+ is now
called on a C-style string!
Friend Functions
Declare a function to be a friend by using the keyword friend and then the full specification of the
function. Declaring a function to be a friend does not give the friend function access to your this
pointer, but it does provide full access to all private and protected member data and functions.
Example
class PartNode
{
// make another class's member function a
friend void PartsList::Insert(Part *);
// make a global function a friend };
friend int SomeFunction();
_friend
Overloading the Insertion Operator
You are finally ready to give your String class the ability to use cout like any other type. Until
now, when you've wanted to print a string, you've been forced to write the following:
cout << theString.GetString();
What you would like to do is write this:
cout << theString;
To accomplish this, you must override operator<<(). Day 16, "Streams," presents the ins and outs
(cins and couts?) of working with iostreams; for now Listing 15.9 illustrates howoperator<< can be overloaded using a friend function.
NOTE: To compile this listing, copy lines 33-153 from Listing 15.1 after line 31 of
Listing 15.9.
Listing 15.9. Overloading operator<<().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
#include <iostream.h>
#include <string.h>
class String
{
public:
// constructors
String();
String(const char *const);
String(const String &);
~String();
// overloaded operators
char & operator[](int offset);
char operator[](int offset) const;
String operator+(const String&);
void operator+=(const String&);
String & operator= (const String &);
friend ostream& operator<<
( ostream& theStream,String& theString);
// General accessors
int GetLen()const { return itsLen; }
const char * GetString() const { return itsString; }
// static int ConstructorCount;
private:
String (int);
// private constructor
char * itsString;
unsigned short itsLen;
};
ostream& operator<<
( ostream& theStream,String& theString)
{
theStream << theString.GetString();
return theStream;
}
int main()38:
{
39:
String theString("Hello world.");
40:
cout << theString;
41:
return 0;
42: }
Output: Hello world.
Analysis: To save space, the implementation of all of String's methods is left out, as they are
unchanged from the previous examples.
On line 19, operator<< is declared to be a friend function that takes an ostream reference and a
String reference and then returns an ostream reference. Note that this is not a member function
of String. It returns a reference to an ostream so that you can concatenate calls to operator<<,
such as this:
cout << "myAge: " << itsAge << " years.";
The implementation of this friend function is on lines 32-35. All this really does is hide the
implementation details of feeding the string to the ostream, and that is just as it should be. You'll
see more about overloading this operator and operator>> on Day 16.
Summary
Today you saw how to delegate functionality to a contained object. You also saw how to implement
one class in terms of another by using either containment or private inheritance. Containment is
restricted in that the new class does not have access to the protected members of the contained class,
and it cannot override the member functions of the contained object. Containment is simpler to use
than private inheritance, and should be used when possible.
You also saw how to declare both friend functions and friend classes. Using a friend function, you
saw how to overload the extraction operator, to allow your new classes to use cout just as the built-
in classes do.
Remember that public inheritance expresses is-a, containment expresses has-a, and private inheritance
expresses implemented in terms of. The relationship delegates to can be expressed using either
containment or private inheritance, though containment is more common.
Q&A
Q. Why is it so important to distinguish between is-a, has-a, and implemented in terms
of?
A. The point of C++ is to implement well-designed, object-oriented programs. Keeping these
relationships straight helps to ensure that your design corresponds to the reality of what you aremodeling. Furthermore, a well-understood design will more likely be reflected in well-
designed code.
Q. Why is containment preferred over private inheritance?
A. The challenge in modern programming is to cope with complexity. The more you can use
objects as black boxes, the fewer details you have to worry about and the more complexity you
can manage. Contained classes hide their details; private inheritance exposes the
implementation details.
Q. Why not make all classes friends of all the classes they use?
A. Making one class a friend of another exposes the implementation details and reduces
encapsulation. The ideal is to keep as many of the details of each class hidden from all other
classes as possible.
Q. If a function is overloaded, do you need to declare each form of the function to be a
friend?
A. Yes, if you overload a function and declare it to be a friend of another class, you must
declare friend for each form that you wish to grant this access to.
Workshop
The Workshop contains quiz questions to help solidify your understanding of the material covered and
exercises to provide you with experience in using what you've learned. Try to answer the quiz and
exercise questions before checking the answers in Appendix D, and make sure you understand the
answers before going to the next chapter.
Quiz
1. How do you establish an is-a relationship?
2. How do you establish a has-a relationship?
3. What is the difference between containment and delegation?
4. What is the difference between delegation and implemented in terms of?
5. What is a friend function?
6. What is a friend class?
7. If Dog is a friend of Boy, is Boy a friend of Dog?
8. If Dog is a friend of Boy, and Terrier derives from Dog, is Terrier a friend of Boy?
9. If Dog is a friend of Boy and Boy is a friend of House, is Dog a friend of House?10. Where must the declaration of a friend function appear?
Exercises
1. Show the declaration of a class, Animal, that contains a datamember that is a string object.
2. Show the declaration of a class, BoundedArray, that is an array.
3. Show the declaration of a class, Set, that is declared in terms of an array.
4. Modify Listing 15.1 to provide the String class with an extraction operator
(>>).
5. BUG BUSTERS: What is wrong with this program?
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
#include <iostream.h>
class Animal;
void setValue(Animal& , int);
class Animal
{
public:
int GetWeight()const { return itsWeight; }
int GetAge() const { return itsAge; }
private:
int itsWeight;
int itsAge;
};
void setValue(Animal& theAnimal, int theWeight)
{
friend class Animal;
theAnimal.itsWeight = theWeight;
}
int main()
{
Animal peppy;
setValue(peppy,5);28:
}
6. Fix the listing in Exercise 5 so it compiles.
7. BUG BUSTERS: What is wrong with this code?1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
#include <iostream.h>
class Animal;
void setValue(Animal& , int);
void setValue(Animal& ,int,int);
class Animal
{
friend void setValue(Animal& ,int);11:
int itsWeight;
int itsAge;
};
private:
void setValue(Animal& theAnimal, int theWeight)
{
theAnimal.itsWeight = theWeight;
}
void setValue(Animal& theAnimal, int theWeight, int theAge)
{
theAnimal.itsWeight = theWeight;
theAnimal.itsAge = theAge;
}
int main()
{
Animal peppy;
setValue(peppy,5);
setValue(peppy,7,9);
}
8. Fix Exercise 7 so it compiles.
Binary Versus Text Files
Listing 16.18. Writing a class to a file.
Command-Line Processing
Listing 16.19. Using command-line arguments.
Listing 16.20. Using command-line arguments.
Summary
Q&A
Workshop
C++ does not, as part of the language, define how data is written to the screen or to a file, nor how
data is read into a program. These are clearly essential parts of working with C++, however, and the
standard C++ library now includes the iostream library, which facilitates input and output (I/O).
The advantage of having the input and output kept apart from the language and handled in libraries is
that it is easier to make the language "platform-independent." That is, you can write C++ programs on
a PC and then recompile them and run them on a Sun Workstation. The compiler manufacturer just
supplies the right library, and everything works. At least that's the theory.
NOTE: A library is a collection of OBJ files that can be linked to your program to
provide additional functionality. This is the most basic form of code reuse, and has been
around since ancient programmers chiseled 1s and 0s into the walls of caves.
Encapsulation
The iostream classes view the flow of data from your program to the screen as being a stream of
data, one byte following another. If the destination of the stream is a file or the screen, the source is
usually some part of your program. If the stream is reversed, the data can come from the keyboard or a
disk file and be "poured" into your data variables.
One principal goal of streams is to encapsulate the problems of getting the data to and from the disk or
the screen. Once a stream is created, your program works with the stream and the stream sweats the
details. Figure 16.1 illustrates this fundamental idea.
Figure 16.1. Encapsulation through streams.
Buffering
Writing to the disk (and to a lesser extent the screen) is very "expensive." It takes a long time
(relatively speaking) to write data to the disk or to read data from the disk, and execution of the
program is generally blocked by disk writes and reads. To solve this problem, streams provide
"buffering." Data is written into the stream, but it is not written back out to the disk immediately.
Instead, the stream's buffer fills and fills, and when it is full it writes to the disk all at once.
Picture water trickling into the top of a tank, and the tank filling and filling, but no water running out
of the bottom. Figure 16.2 illustrates this idea.
When the water (data) reaches the top, the valve opens and all the water flows out in a rush. Figure
16.3 illustrates this.
Once the buffer is empty, the bottom valve closes, the top valve opens, and more water flows into thebuffer tank. Figure 16.4 illustrates this.
Every once in a while you need to get the water out of the tank even before it is full. This is called
"flushing the buffer." Figure 16.5 illustrates this idea.
Figure 16.2. Filling the buffer.
Figure 16.3. Emptying the buffer.
Figure 16.4. Refilling the buffer.
Figure 16.5. Flushing the buffer.
Streams and Buffers
As you might expect, C++ takes an object-oriented view toward implementing streams and buffers.
!(-
$!.
/(.
'(#
&*"
The streambuf class manages the buffer, and its member functions provide the capability to
fill, empty, flush, and otherwise manipulate the buffer.
The ios class is the base class to the input and output stream classes. The ios class has a
streambuf object as a member variable.
The istream and ostream classes derive from the ios class and specialize input and
output stream behavior, respectively.
The iostream class is derived from both the istream and the ostream classes and
provides input and output methods for writing to the screen.
The fstream classes provide input and output from files.
Standard I/O Objects
When a C++ program that includes the iostream classes starts, four objects are created and
initialized:
NOTE: The iostream class library is added automatically to your program by the
compiler. All you need to do to use these functions is to put the appropriate include
statement at the top of your program listing.
/("
cin (pronounced "see-in") handles input from the standard input, the keyboard.-!'
&,$
$%*
cou (pronounced "see-out") handles output to the standard output, the screen.
cer (pronounced "see-err") handles unbuffered output to the standard error device, the screen.
Because this is unbuffered, everything sent to cerr is written to the standard error device
immediately, without waiting for the buffer to fill or for a flush command to be received.
clo (pronounced "see-log") handles buffered error messages that are output to the standard
error device, the screen. It is common for this to be "redirected" to a log file, as described in the
following section.
Redirection
Each of the standard devices, input, output, and error, can be redirected to other devices. Standard
error is often redirected to a file, and standard input and output can be piped to files using operating
system commands.
New Term: Redirecting refers to sending output (or input) to a place different than the default.
The redirection operators for DOS and UNIX are (<) redirect input and (>) redirect output.
Piping refers to using the output of one program as the input of another.
DOS provides rudimentary redirection commands, such as redirect output (>) and (>)redirect input
(<). UNIX provides more advanced redirection capabilities, but the general idea is the same: Take the
output intended for the screen and write it to a file, or pipe it into another program. Alternatively, the
input for a program can be extracted from a file rather than from the keyboard.
Redirection is more a function of the operating system than of the iostream libraries. C++ just
provides access to the four standard devices; it is up to the user to redirect the devices to whatever
alternatives are needed.
Input Using cin
The global object cin is responsible for input and is made available to your program when you
include iostream.h. In previous examples, you used the overloaded extraction operator (>>) to put
data into your program's variables. How does this work? The syntax, as you may remember, is the
following:
int someVariable;
cout << "Enter a number: ";
cin >> someVariable;
The global object cout is discussed later today; for now, focus on the third line, cin >>someVariable;. What can you guess about cin?
Clearly it must be a global object, because you didn't define it in your own code. You know from
previous operator experience that cin has overloaded the extraction operator (>>) and that the effect
is to write whatever data cin has in its buffer into your local variable, someVariable.
What may not be immediately obvious is that cin has overloaded the extraction operator for a great
variety of parameters, among them int&, short&, long&, double&, float&, char&, char*,
and so forth. When you write cin >> someVariable;, the type of someVariable is assessed.
In the example above, someVariable is an integer, so the following function is called:
istream & operator>> (int &)
Note that because the parameter is passed by reference, the extraction operator is able to act on the
original variable. Listing 16.1 illustrates the use of cin.
Listing 16.1. cin handles different data types.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
//Listing 16.1 -- character strings and cin
#include <iostream.h>
int main()
{
int myInt;
long myLong;
double myDouble;
float myFloat;
unsigned int myUnsigned;
cout << "int: ";
cin >> myInt;
cout << "Long: ";
cin >> myLong;
cout << "Double: ";
cin >> myDouble;
cout << "Float: ";
cin >> myFloat;
cout << "Unsigned: ";
cin >> myUnsigned;
cout
cout
cout
cout
<<
<<
<<
<<
"\n\nInt:\t" << myInt << endl;
"Long:\t" << myLong << endl;
"Double:\t" << myDouble << endl;
"Float:\t" << myFloat << endl;28:
29:
30: }
cout << "Unsigned:\t" << myUnsigned << endl;
return 0;
Output: int: 2
Long: 70000
Double: 987654321
Float: 3.33
Unsigned: 25
Int:
2
Long:
70000
Double: 9.87654e+08
Float: 3.33
Unsigned:
25
Analysis: On lines 7-11, variables of various types are declared. On lines 13-22, the user is prompted
to enter values for these variables, and the results are printed (using cout) on lines 24-28.
The output reflects that the variables were put into the right "kinds" of variables, and the program
works as you might expect.
Strings
cin can also handle character pointer (char*) arguments; thus, you can create a character buffer and
use cin to fill it. For example, you can write this:
char YourName[50]
cout << "Enter your name: ";
cin >> YourName;
If you enter Jesse, the variable YourName will be filled with the characters J, e, s, s, e,
\0. The last character is a null; cin automatically ends the string with a null character, and you must
have enough room in the buffer to allow for the entire string plus the null. The null signals "end of
string" to the standard library functions discussed on Day 21, "What's Next."
String Problems
After all this success with cin, you might be surprised when you try to enter a full name into a string.
cin believes that white space is a separator. When it sees a space or a new line, it assumes the input
for the parameter is complete, and in the case of strings it adds a null character right then and there.
Listing 16.2 illustrates this problem.
Listing 16.2. Trying to write more than one word to cin.1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15: }
//Listing 16.2 -- character strings and cin
#include <iostream.h>
int main()
{
char YourName[50];
cout << "Your first name: ";
cin >> YourName;
cout << "Here it is: " << YourName << endl;
cout << "Your entire name: ";
cin >> YourName;
cout << "Here it is: " << YourName << endl;
return 0;
Output: Your first name: Jesse
Here it is: Jesse
Your entire name: Jesse Liberty
Here it is: Jesse
Analysis: On line 7, a character array is created to hold the user's input. On line 8, the user is
prompted to enter one name, and that name is stored properly, as shown in the output.
On line 11, the user is again prompted, this time for a full name. cin reads the input, and when it sees
the space between the names, it puts a null character after the first word and terminates input. This is
not exactly what was intended.
To understand why this works this way, examine Listing 16.3, which shows input for a number of
fields.
Listing 16.3. Multiple input.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
//Listing 16.3 - character strings and cin
#include <iostream.h>
int main()
{
int myInt;
long myLong;
double myDouble;
float myFloat;
unsigned int myUnsigned;
char myWord[50];14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46: }
cout << "int: ";
cin >> myInt;
cout << "Long: ";
cin >> myLong;
cout << "Double: ";
cin >> myDouble;
cout << "Float: ";
cin >> myFloat;
cout << "Word: ";
cin >> myWord;
cout << "Unsigned: ";
cin >> myUnsigned;
cout
cout
cout
cout
cout
cout
<<
<<
<<
<<
<<
<<
"\n\nInt:\t" << myInt << endl;
"Long:\t" << myLong << endl;
"Double:\t" << myDouble << endl;
"Float:\t" << myFloat << endl;
"Word: \t" << myWord << endl;
"Unsigned:\t" << myUnsigned << endl;
cout << "\n\nInt, Long, Double, Float, Word, Unsigned: ";
cin >> myInt >> myLong >> myDouble;
cin >> myFloat >> myWord >> myUnsigned;
cout << "\n\nInt:\t" << myInt << endl;
cout << "Long:\t" << myLong << endl;
cout << "Double:\t" << myDouble << endl;
cout << "Float:\t" << myFloat << endl;
cout << "Word: \t" << myWord << endl;
cout << "Unsigned:\t" << myUnsigned << endl;
return 0;
Output: Int: 2
Long: 30303
Double: 393939397834
Float: 3.33
Word: Hello
Unsigned: 85
Int:
Long:
Double:
Float:
Word:
2
30303
3.93939e+11
3.33
HelloUnsigned:
85
Int, Long, Double, Float, Word, Unsigned: 3 304938 393847473 6.66
bye -2
Int:
Long:
Double:
Float:
Word:
3
304938
3.93847e+08
6.66
bye
Unsigned:
65534
Analysis: Once again, a number of variables are created, this time including a char array. The user is
prompted for input and the output is faithfully printed.
On line 34, the user is prompted for all the input at once, and then each "word" of input is assigned to
the appropriate variable. It is in order to facilitate this kind of multiple assignment that cin must
consider each word in the input to be the full input for each variable. If cin was to consider the entire
input to be part of one variable's input, this kind of concatenated input would be impossible.
Note that on line 35 the last object requested was an unsigned integer, but the user entered -2.
Because cin believes it is writing to an unsigned integer, the bit pattern of -2 was evaluated as an
unsigned integer, and when written out by cout, the value 65534 was displayed. The unsigned
value 65534 has the exact bit pattern of the signed value -2.
Later in this chapter you will see how to enter an entire string into a buffer, including multiple words.
For now, the question arises, "How does the extraction operator manage this trick of concatenation?"
operator>> Returns a Reference to an istream Object
The return value of cin is a reference to an istream object. Because cin itself is an istream
object, the return value of one extraction operation can be the input to the next extraction.
int VarOne, varTwo, varThree;
cout << "Enter three numbers: "
cin >> VarOne >> varTwo >> varThree;
When you write cin >> VarOne >> varTwo >> varThree;, the first extraction is evaluated
(cin >> VarOne). The return value from this is another istream object, and that object's
extraction operator gets the variable varTwo. It is as if you had written this:
((cin >> varOne) >> varTwo) >> varThree;
You'll see this technique repeated later when cout is discussed.Other Member Functions of cin
In addition to overloading operator>>, cin has a number of other member functions. These are
used when finer control over the input is required.
Single Character Input
operator>> taking a character reference can be used to get a single character from the standard
input. The member function get() can also be used to obtain a single character, and can do so in two
ways. get() can be used with no parameters, in which case the return value is used, or it can be used
with a reference to a character. Using get() with No Parameters The first form of get() is without
parameters. This returns the value of the character found, and will return EOF (end of file) if the end of
the file is reached. get() with no parameters is not often used. It is not possible to concatenate this
use of get() for multiple input, because the return value is not an iostream object. Thus, the
following won't work:
cin.get() >>myVarOne >> myVarTwo; //
illegal
The return value of (cin.get() >> myVarOne) is an integer, not an iostream object.
A common use of get() with no parameters is illustrated in Listing 16.4.
Listing 16.4. Using get() with no parameters.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13: }
// Listing 16.4 - Using get() with no parameters
#include <iostream.h>
int main()
{
char ch;
while ( (ch = cin.get()) != EOF)
{
cout << "ch: " << ch << endl;
}
cout << "\nDone!\n";
return 0;
NOTE: To exit this program, you must send end of file from the keyboard. On DOS
computers use Ctrl+Z; on UNIX units use Ctrl+D.
Output: Helloch:
ch:
ch:
ch:
ch:
ch:
H
e
l
l
o
World
ch: W
ch: o
ch: r
ch: l
ch: d
ch:
(ctrl-z)
Done!
Analysis: On line 6, a local character variable is declared. The while loop assigns the input received
from cin.get() to ch, and if it is not EOF the string is printed out. This output is buffered until an
end of line is read, however. Once EOF is encountered (by pressing Ctrl+Z on a DOS machine, or
Ctrl+D on a UNIX machine), the loop exits.
Note that not every implementation of istream supports this version of get(). Using get() with a
Character Reference Parameter When a character is passed as input to get(), that character is filled
with the next character in the input stream. The return value is an iostream object, and so this form
of get() can be concatenated, as illustrated in Listing 16.5.
Listing 16.5 Using get() with parameters.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
endl;
13:
14: }
// Listing 16.5 - Using get() with parameters
#include <iostream.h>
int main()
{
char a, b, c;
cout << "Enter three letters: ";
cin.get(a).get(b).get(c);
cout << "a: " << a << "\nb: " << b << "\nc: " << c <<
return 0;Output: Enter three letters: one
a: o
b: n
c: e
Analysis: On line 6, three character variables are created. On line 10, cin.get() is called three
times, concatenated. First cin.get(a) is called. This puts the first letter into a and returns cin so
that when it is done, cin.get(b) is called, putting the next letter into b. The end result of this is
that cin.get(c) is called and the third letter is put in c.
Because cin.get(a) evaluates to cin, you could have written this:
cin.get(a) >> b;
In this form, cin.get(a) evaluates to cin, so the second phrase is cin >> b;.
DO use the extraction operator (>>) when you need to skip over white space. DO use
get() with a character parameter when you need to examine every character,
including white space. DON'T use get() with no parameters at all; it is more or less
obsolete.
Getting Strings from Standard Input
The extraction operator (>>) can be used to fill a character array, as can the member functions get()
and getline().
The final form of get() takes three parameters. The first parameter is a pointer to a character array,
the second parameter is the maximum number of characters to read plus one, and the third parameter is
the termination character.
If you enter 20 as the second parameter, get() will read 19 characters and then will null-terminate
the string, which it will store in the first parameter. The third parameter, the termination character,
defaults to newline (`\n'). If a termination character is reached before the maximum number of
characters is read, a null is written and the termination character is left in the buffer.
Listing 16.6 illustrates the use of this form of get().
Listing 16.6. Using get() with a character array.
1:
2:
3:
4:
// Listing 16.6 - Using get() with a character array
#include <iostream.h>
int main()5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17: }
{
char stringOne[256];
char stringTwo[256];
cout << "Enter string one: ";
cin.get(stringOne,256);
cout << "stringOne: " << stringOne << endl;
cout << "Enter string two: ";
cin >> stringTwo;
cout << "StringTwo: " << stringTwo << endl;
return 0;
Output: Enter string one: Now is the time
stringOne: Now is the time
Enter string two: For all good
StringTwo: For
Analysis: On lines 6 and 7, two character arrays are created. On line 9, the user is prompted to enter a
string, and cin.get() is called on line 10. The first parameter is the buffer to fill, and the second is
one more than the maximum number for get() to accept (the extra position being given to the null
character, (`\0')). The defaulted third parameter is a newline.
The user enters Now is the time. Because the user ends the phrase with a newline, that phrase is
put into stringOne, followed by a terminating null.
The user is prompted for another string on line 13, and this time the extraction operator is used.
Because the extraction operator takes everything up to the first white space, the string For, with a
terminating null character, is stored in the second string, which of course is not what was intended.
Another way to solve this problem is to use getline(), as illustrated in Listing 16.7.
Listing 16.7. Using getline().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
// Listing 16.7 - Using getline()
#include <iostream.h>
int main()
{
char stringOne[256];
char stringTwo[256];
char stringThree[256];
cout << "Enter string one: ";11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22: }
cin.getline(stringOne,256);
cout << "stringOne: " << stringOne << endl;
cout << "Enter string two: ";
cin >> stringTwo;
cout << "stringTwo: " << stringTwo << endl;
cout << "Enter string three: ";
cin.getline(stringThree,256);
cout << "stringThree: " << stringThree << endl;
return 0;
Output: Enter string one: one two three
stringOne: one two three
Enter string two: four five six
stringTwo: four
Enter string three: stringThree: five six
Analysis: This example warrants careful examination; there are some potential surprises. On lines 6-8,
three character arrays are declared.
On line 10, the user is prompted to enter a string, and that string is read by getline(). Like get(),
getline() takes a buffer and a maximum number of characters. Unlike get(), however, the
terminating newline is read and thrown away. With get() the terminating newline is not thrown
away. It is left in the input buffer.
On line 14, the user is prompted again, and this time the extraction operator is used. The user enters
four five six, and the first word, four, is put in stringTwo. The string Enter string
three is then displayed, and getline() is called again. Because five six is still in the input
buffer, it is immediately read up to the newline; getline() terminates and the string in
stringThree is printed on line 20.
The user has no chance to enter string three, because the second getline() call is fulfilled by the
string remaining in the input buffer after the call to the extraction operator on line 15.
The extraction operator (>>) reads up to the first white space and puts the word into the character
array.
The member function get() is overloaded. In one version, it takes no parameters and returns the
value of the character it receives. In the second version, it takes a single character reference and
returns the istream object by reference.
In the third and final version, get() takes a character array, a number of characters to get, and a
termination character (which defaults to newline). This version of get() reads characters into the
array until it gets to one fewer than its maximum number of characters or it encounters the terminationcharacter, whichever comes first. If get() encounters the termination character, it leaves that
character in the input buffer and stops reading characters.
The member function getline() also takes three parameters: the buffer to fill, one more than the
maximum number of characters to get, and the termination character. getline()functions exactly
like get() does with these parameters, except getline() throws away the terminating character.
Using cin.ignore()
At times you want to ignore the remaining characters on a line until you hit either end of line (EOL) or
end of file (EOF). The member function ignore() serves this purpose. ignore() takes two
parameters, the maximum number of characters to ignore and the termination character. If you write
ignore(80,'\n'), up to 80 characters will be thrown away until a newline character is found. The
newline is then thrown away and the ignore() statement ends. Listing 16.8 illustrates the use of
ignore().
Listing 16.8. Using ignore().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
// Listing 16.8 - Using ignore()
#include <iostream.h>
int main()
{
char stringOne[255];
char stringTwo[255];
cout << "Enter string one:";
cin.get(stringOne,255);
cout << "String one" << stringOne << endl;
cout << "Enter string two: ";
cin.getline(stringTwo,255);
cout << "String two: " << stringTwo << endl;
cout << "\n\nNow try again...\n";
cout << "Enter string one: ";
cin.get(stringOne,255);
cout << "String one: " << stringOne<< endl;
cin.ignore(255,'\n');
cout << "Enter string two: ";
cin.getline(stringTwo,255);
cout << "String Two: " << stringTwo<< endl;28:
29: }
return 0;
Output: Enter string one:once upon a time
String oneonce upon a time
Enter string two: String two:
Now try again...
Enter string one: once upon a time
String one: once upon a time
Enter string two: there was a
String Two: there was a
Analysis: On lines 6 and 7, two character arrays are created. On line 9, the user is prompted for input
and types once upon a time, followed by Enter. On line 10, get() is used to read this string.
get() fills stringOne and terminates on the newline, but leaves the newline character in the input
buffer.
On line 13, the user is prompted again, but the getline() on line 14 reads the newline that is
already in the buffer and terminates immediately, before the user can enter any input.
On line 19, the user is prompted again and puts in the same first line of input. This time, however, on
line 23, ignore() is used to "eat" the newline character. Thus, when the getline() call on line
26 is reached, the input buffer is empty, and the user can input the next line of the story.
peek() and putback()
The input object cin has two additional methods that can come in rather handy: peek(), which
looks at but does not extract the next character, and putback(), which inserts a character into the
input stream. Listing 16.9 illustrates how these might be used.
Listing 16.9. Using peek() and putback().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
// Listing 16.9 - Using peek() and putback()
#include <iostream.h>
int main()
{
char ch;
cout << "enter a phrase: ";
while ( cin.get(ch) )
{
if (ch == `!')
cin.putback(`$');
else13:
14:
15:
16:
17:
18: }
cout << ch;
while (cin.peek() == `#')
cin.ignore(1,'#');
}
return 0;
Output: enter a phrase: Now!is#the!time#for!fun#!
Now$isthe$timefor$fun$
Analysis: On line 6, a character variable, ch, is declared, and on line 7, the user is prompted to enter a
phrase. The purpose of this program is to turn any exclamation marks (!) into dollar signs ($) and to
remove any pound symbols (#).
The program loops as long as it is getting characters other than the end of file (remember that
cin.get() returns 0 for end of file). If the current character is an exclamation point, it is thrown
away and the $ symbol is put back into the input buffer; it will be read the next time through. If the
current item is not an exclamation point, it is printed. The next character is "peeked" at, and when
pound symbols are found, they are removed.
This is not the most efficient way to do either of these things (and it won't find a pound symbol if it is
the first character), but it does illustrate how these methods work. They are relatively obscure, so don't
spend a lot of time worrying about when you might really use them. Put them into your bag of tricks;
they'll come in handy sooner or later.
TIP: peek() and putback() are typically used for parsing strings and other data,
such as when writing a compiler.
Output with cout
You have used cout along with the overloaded insertion operator (<<) to write strings, integers, and
other numeric data to the screen. It is also possible to format the data, aligning columns and writing
the numeric data in decimal and hexadecimal. This section will show you how.
Flushing the Output
You've already seen that using endl will flush the output buffer. endl calls cout's member function
flush(), which writes all of the data it is buffering. You can call the flush() method directly,
either by calling the flush() member method or by writing the following:
cout << flush
This can be convenient when you need to ensure that the output buffer is emptied and that the contentsare written to the screen.
Related Functions
Just as the extraction operator can be supplemented with get() and getline(), the insertion
operator can be supplemented with put() and write().
The function put() is used to write a single character to the output device. Because put() returns
an ostream reference, and because cout is an ostream object, you can concatenate put() just
as you do the insertion operator. Listing 16.10 illustrates this idea.
Listing 16.10. Using put().
1:
// Listing 16.10 - Using put()
2:
#include <iostream.h>
3:
4:
int main()
5:
{
6:
cout.put(`H').put(`e').put(`l').put(`l').put(`o').put(`\n');
7:
return 0;
8: }
Output: Hello
Analysis: Line 6 is evaluated like this: cout.put(`H') writes the letter H to the screen and returns
the cout object. This leaves the following:
cout.put(`e').put(`l').put(`l').put(`o').put(`\n');
The letter e is written, leaving cout.put(`l'). This process repeats, each letter being written and
the cout object returned until the final character (`\n') is written and the function returns.
The function write() works just like the insertion operator (<<), except that it takes a parameter
that tells the function the maximum number of characters to write. Listing 16.11 illustrates its use.
Listing 16.11. Using write().
1:
2:
3:
4:
5:
6:
7:
// Listing 16.11 - Using write()
#include <iostream.h>
#include <string.h>
int main()
{
char One[] = "One if by land";8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19: }
int fullLength = strlen(One);
int tooShort = fullLength -4;
int tooLong = fullLength + 6;
cout.write(One,fullLength) << "\n";
cout.write(One,tooShort) << "\n";
cout.write(One,tooLong) << "\n";
return 0;
Output: One if by land
One if by
One if by land i?!
NOTE: The last line of output may look different on your computer.
Analysis: On line 7, one phrase is created. On line 11, the integer fullLength is set to the length of
the phrase and tooShort is set to that length minus four, while tooLong is set to fullLength
plus six.
On line 15, the complete phrase is printed using write(). The length is set to the actual length of the
phrase, and the correct phrase is printed.
On line 16, the phrase is printed again, but is four characters shorter than the full phrase, and that is
reflected in the output.
On line 17, the phrase is printed again, but this time write() is instructed to write an extra six
characters. Once the phrase is written, the next six bytes of contiguous memory are written.
Manipulators, Flags, and Formatting Instructions
The output stream maintains a number of state flags, determining which base (decimal or
hexadecimal) to use, how wide to make the fields, and what character to use to fill in fields. A state
flag is just a byte whose individual bits are each assigned a special meaning. Manipulating bits in this
way is discussed on Day 21. Each of ostream's flags can be set using member functions and
manipulators.
Using cout.width()
The default width of your output will be just enough space to print the number, character, or string inthe output buffer. You can change this by using width(). Because width() is a member function,
it must be invoked with a cout object. It only changes the width of the very next output field and then
immediately reverts to the default. Listing 16.12 illustrates its use.
Listing 16.12. Adjusting the width of output.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20: }
// Listing 16.12 - Adjusting the width of output
#include <iostream.h>
int main()
{
cout << "Start >";
cout.width(25);
cout << 123 << "< End\n";
cout << "Start >";
cout.width(25);
cout << 123<< "< Next >";
cout << 456 << "< End\n";
cout << "Start >";
cout.width(4);
cout << 123456 << "< End\n";
return 0;
Output: Start >
Start >
Start >123456< End
123< End
123< Next >456< End
Analysis: The first output, on lines 6-8, prints the number 123 within a field whose width is set to 25
on line 7. This is reflected in the first line of output.
The second line of output first prints the value 123 in the same field whose width is set to 25, and then
prints the value 456. Note that 456 is printed in a field whose width is reset to just large enough; as
stated, the effect of width() lasts only as long as the very next output.
The final output reflects that setting a width that is smaller than the output is exactly like setting a
width that is just large enough.
Setting the Fill Characters
Normally cout fills the empty field created by a call to width() with spaces, as shown above. At
times you may want to fill the area with other characters, such as asterisks. To do this, you callfill() and pass in as a parameter the character you want used as a fill character. Listing 16.13
illustrates this.
Listing 16.13. Using fill().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17: }
// Listing 16.3 - fill()
#include <iostream.h>
int main()
{
cout << "Start >";
cout.width(25);
cout << 123 << "< End\n";
cout << "Start >";
cout.width(25);
cout.fill(`*');
cout << 123 << "< End\n";
return 0;
Output: Start >
123< End
Start >******************123< End
Analysis: Lines 7-9 repeat the functionality from the previous example. Lines 12-15 repeat this again,
but this time, on line 14, the fill character is set to asterisks, as reflected in the output.
Set Flags
The iostream objects keep track of their state by using flags. You can set these flags by calling
setf() and passing in one or another of the predefined enumerated constants.
New Term: Objects are said to have state when some or all of their data represents a condition
that can change during the course of the program.
For example, you can set whether or not to show trailing zeros (so that 20.00 does not become
truncated to 20). To turn trailing zeros on, call setf(ios::showpoint).
The enumerated constants are scoped to the iostream class (ios) and thus are called with the full
qualification ios::flagname, such as ios::showpoint.You can turn on the plus sign (+) before positive numbers by using ios::showpos. You can
change the alignment of the output by using ios::left, ios::right, or ios::internal.
Finally, you can set the base of the numbers for display by using ios::dec (decimal), ios::oct
(octal--base eight), or ios::hex (hexadecimal--base sixteen). These flags can also be concatenated
into the insertion operator. Listing 16.14 illustrates these settings. As a bonus, Listing 16.14 also
introduces the setw manipulator, which sets the width but can also be concatenated with the insertion
operator.
Listing 16.14. Using setf.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
endl;
30:
31: }
// Listing 16.14 - Using setf
#include <iostream.h>
#include <iomanip.h>
int main()
{
const int number = 185;
cout << "The number is " << number << endl;
cout << "The number is " << hex << number << endl;
cout.setf(ios::showbase);
cout << "The number is " << hex << number << endl;
cout << "The number is " ;
cout.width(10);
cout << hex << number << endl;
cout << "The number is " ;
cout.width(10);
cout.setf(ios::left);
cout << hex << number << endl;
cout << "The number is " ;
cout.width(10);
cout.setf(ios::internal);
cout << hex << number << endl;
cout << "The number is:" << setw(10) << hex << number <<
return 0;
Output: The number is 185
The number is b9The
The
The
The
The
number
number
number
number
number
is 0xb9
is
is 0xb9
is 0x
is:0x
0xb9
b9
b9
Analysis: On line 7, the constant int number is initialized to the value 185. This is displayed on
line 8.
The value is displayed again on line 10, but this time the manipulator hex is concatenated, causing the
value to be displayed in hexadecimal as b9. (b=11; 11*16=176+9=185).
On line 12, the flag showbase is set. This causes the prefix 0x to be added to all hexadecimal
numbers, as reflected in the output.
On line 16, the width is set to 10, and the value is pushed to the extreme right. On line 20, the width is
again set to 10, but this time the alignment is set to the left, and the number is again printed flush left.
On line 25, once again the width is set to 10, but this time the alignment is internal. Thus the 0x is
printed flush left, but the value, b9, is printed flush right.
Finally, on line 29, the concatenation operator setw() is used to set the width to 10, and the value is
printed again.
Streams Versus the printf() Function
Most C++ implementations also provide the standard C I/O libraries, including the printf()
statement. Although printf() is in some ways easier to use than cout, it is far less desirable.
printf() does not provide type safety, so it is easy to inadvertently tell it to display an integer as if
it was a character and vice versa. printf() also does not support classes, and so it is not possible to
teach it how to print your class data; you must feed each class member to printf() one by one.
On the other hand, printf() does make formatting much easier, because you can put the formatting
characters directly into the printf() statement. Because printf() has its uses and many
programmers still make extensive use of it, this section will briefly review its use.
To use printf(), be sure to include the STDIO.H header file. In its simplest form, printf()
takes a formatting string as its first parameter and then a series of values as its remaining parameters.
The formatting string is a quoted string of text and conversion specifiers. All conversion specifiers
must begin with the percent symbol (%). The common conversion specifiers are presented in Table
16.1.Table 16.1. The Common Conversion Specifiers .
Specifier
%s
%d
%l
%ld
%f
Used For
strings
integers
long integer
long integers
float
Each of the conversion specifiers can also provide a width statement and a precision statement,
expressed as a float, where the digits to the left of the decimal are used for the total width, and the
digits to the right of the decimal provide the precision for floats. Thus, %5d is the specifier for a
five-digit-wide integer, and %15.5f is the specifier for a 15-digit-wide float, of which the final
five digits are dedicated to the decimal portion. Listing 16.15 illustrates various uses of printf().
Listing 16.15. Printing with printf().
1:
#include <stdio.h>
2:
int main()
3:
{
4:
printf("%s","hello world\n");
5:
6:
char *phrase = "Hello again!\n";
7:
printf("%s",phrase);
8:
9:
int x = 5;
10:
printf("%d\n",x);
11:
12:
char *phraseTwo = "Here's some values: ";
13:
char *phraseThree = " and also these: ";
14:
int y = 7, z = 35;
15:
long longVar = 98456;
16:
float floatVar = 8.8;
17:
18:
printf("%s %d %d %s %ld
%f\n",phraseTwo,y,z,phraseThree,longVar,floatVar);
19:
20:
char *phraseFour = "Formatted: ";
21:
printf("%s %5d %10d %10.5f\n",phraseFour,y,z,floatVar);
22:
return 0;
23: }
Output: hello worldHello again!
5
Here's some values: 7 35 and also these: 98456 8.800000
Formatted:
7
35
8.800000
Analysis: The first printf() statement, on line 4, uses the standard form: the term printf,
followed by a quoted string with a conversion specifier (in this case %s), followed by a value to insert
into the conversion specifier.
The %s indicates that this is a string, and the value for the string is, in this case, the quoted string
"hello world".
The second printf() statement is just like the first, but this time a char pointer is used, rather than
quoting the string right in place in the printf() statement.
The third printf(), on line 10, uses the integer conversion specifier, and for its value the integer
variable x. The fourth printf() statement, on line 18, is more complex. Here six values are
concatenated. Each conversion specifier is supplied, and then the values are provided, separated by
commas.
Finally, on line 21, format specifications are used to specify width and precision. As you can see, all of
this is somewhat easier than using manipulators.
As stated previously, however, the limitation here is that there is no type checking and printf()
cannot be declared a friend or member function of a class. So if you want to print the various member
data of a class, you must feed each accessor method to the printf() statement explicitly.
File Input and Output
Streams provide a uniform way of dealing with data coming from the keyboard or the hard disk and
going out to the screen or hard disk. In either case, you can use the insertion and extraction operators
or the other related functions and manipulators. To open and close files, you create ifstream and
ofstream objects as described in the next few sections.
ofstream
The particular objects used to read from or write to files are called ofstream objects. These are
derived from the iostream objects you've been using so far.
To get started with writing to a file, you must first create an ofstream object, and then associate that
object with a particular file on your disk. To use ofstream objects, you must be sure to include
fstream.h in your program.NOTE: Because fstream.h includes iostream.h, there is no need for you to
include iostream explicitly.
Condition States
The iostream objects maintain flags that report on the state of your input and output. You can
check each of these flags using the Boolean functions eof(), bad(), fail(), and good(). The
function eof() returns true if the iostream object has encountered EOF, end of file. The function
bad() returns TRUE if you attempt an invalid operation. The function fail() returns TRUE
anytime bad() is true or an operation fails. Finally, the function good() returns TRUE anytime all
three of the other functions are FALSE.
Opening Files for Input and Output
To open the file myfile.cpp with an ofstream object, declare an instance of an ofstream
object and pass in the filename as a parameter:
ofstream fout("myfile.cpp");
Opening this file for input works exactly the same way, except it uses an ifstream object:
ifstream fin("myfile.cpp");
Note that fout and fin are names you assign; here fout has been used to reflect its similarity to
cout, and fin has been used to reflect its similarity to cin.
One important file stream function that you will need right away is close(). Every file stream
object you create opens a file for either reading or writing (or both). It is important to close() the
file after you finish reading or writing; this ensures that the file won't be corrupted and that the data
you've written is flushed to the disk.
Once the stream objects are associated with files, they can be used like any other stream objects.
Listing 16.16 illustrates this.
Listing 16.16. Opening files for read and write.
1:
2:
3:
4:
5:
6:
7:
#include <fstream.h>
int main()
{
char fileName[80];
char buffer[255];
// for user input
cout << "File name: ";
cin >> fileName;8:
9:
10:
11:
12:
name
13:
14:
15:
reopen
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27: }
ofstream fout(fileName); // open for writing
fout << "This line written directly to the file...\n";
cout << "Enter text for the file: ";
cin.ignore(1,'\n'); // eat the newline after the file
cin.getline(buffer,255);
fout << buffer << "\n";
fout.close();
// get the user's input
// and write it to the file
// close the file, ready for
ifstream fin(fileName);
// reopen for reading
cout << "Here's the contents of the file:\n";
char ch;
while (fin.get(ch))
cout << ch;
cout << "\n***End of file contents.***\n";
fin.close();
return 0;
// always pays to be tidy
Output: File name: test1
Enter text for the file: This text is written to the file!
Here's the contents of the file:
This line written directly to the file...
This text is written to the file!
***End of file contents.***
Analysis: On line 4, a buffer is set aside for the filename, and on line 5 another buffer is set aside for
user input. The user is prompted to enter a filename on line 6, and this response is written to the
fileName buffer. On line 9, an ofstream object is created, fout, which is associated with the
new filename. This opens the file; if the file already exists, its contents are thrown away.
On line 10, a string of text is written directly to the file. On line 11, the user is prompted for input. The
newline character left over from the user's input of the filename is eaten on line 12, and the user's input
is stored into buffer on line 13. That input is written to the file along with a newline character on
line 14, and then the file is closed on line 15.
On line 17, the file is reopened, this time in input mode, and the contents are read, one character at a
time, on lines 20 and 21.
Changing the Default Behavior of ofstream on OpenThe default behavior upon opening a file is to create the file if it doesn't yet exist and to truncate the
file (that is, delete all its contents) if it does exist. If you don't want this default behavior, you can
explicitly provide a second argument to the constructor of your ofstream object.
Valid arguments include:
%+( ios::app--Appends to the end of existing files rather than truncating them.
&#! ios::at--Places you at the end of the file, but you can write data anywhere in the file.
*'( ios::trun--The default. Causes existing files to be truncated.
(-/ ios::nocreat--If the file does not exist, the open fails.
&$' ios::noreplac--If the file does already exist, the open fails.
Note that app is short for append; ate is short for at end, and trunc is short for truncate. Listing
16.17 illustrates using append by reopening the file from Listing 16.16 and appending to it.
Listing 16.17. Appending to the end of a file.
1:
#include <fstream.h>
2:
int main()
// returns 1 on error
3:
{
4:
char fileName[80];
5:
char buffer[255];
6:
cout << "Please re-enter the file name: ";
7:
cin >> fileName;
8:
9:
ifstream fin(fileName);
10:
if (fin)
// already exists?
11:
{
12:
cout << "Current file contents:\n";
13:
char ch;
14:
while (fin.get(ch))
15:
cout << ch;
16:
cout << "\n***End of file contents.***\n";
17:
}
18:
fin.close();
19:
20:
cout << "\nOpening " << fileName << " in append
mode...\n";
21:
22:
ofstream fout(fileName,ios::app);
23:
if (!fout)24:
{
25:
cout << "Unable to open " << fileName << " for
appending.\n";
26:
return(1);
27:
}
28:
29:
cout << "\nEnter text for the file: ";
30:
cin.ignore(1,'\n');
31:
cin.getline(buffer,255);
32:
fout << buffer << "\n";
33:
fout.close();
34:
35:
fin.open(fileName); // reassign existing fin object!
36:
if (!fin)
37:
{
38:
cout << "Unable to open " << fileName << " for
reading.\n";
39:
return(1);
40:
}
41:
cout << "\nHere's the contents of the file:\n";
42:
char ch;
43:
while (fin.get(ch))
44:
cout << ch;
45:
cout << "\n***End of file contents.***\n";
46:
fin.close();
47:
return 0;
48: }
Output: Please re-enter the file name: test1
Current file contents:
This line written directly to the file...
This text is written to the file!
***End of file contents.***
Opening test1 in append mode...
Enter text for the file: More text for the file!
Here's the contents of the file:
This line written directly to the file...
This text is written to the file!
More text for the file!
***End of file contents.***
Analysis: The user is again prompted to enter the filename. This time an input file stream object iscreated on line 9. That open is tested on line 10, and if the file already exists, its contents are printed
on lines 12 to 16. Note that if(fin) is synonymous with if (fin.good()).
The input file is then closed, and the same file is reopened, this time in append mode, on line 22. After
this open (and every open), the file is tested to ensure that the file was opened properly. Note that
if(!fout) is the same as testing if (fout.fail()). The user is then prompted to enter text,
and the file is closed again on line 33.
Finally, as in Listing 16.16, the file is reopened in read mode; however, this time fin does not need to
be redeclared. It is just reassigned to the same filename. Again the open is tested, on line 36, and if all
is well, the contents of the file are printed to the screen and the file is closed for the final time.
DO test each open of a file to ensure that it opened successfully. DO reuse existing
ifstream and ofstream objects. DO close all fstream objects when you are
done using them. DON'T try to close or reassign cin or cout.
Binary Versus Text Files
Some operating systems, such as DOS, distinguish between text files and binary files. Text files store
everything as text (as you might have guessed), so large numbers such as 54,325 are stored as a string
of numerals (`5', `4', `,', `3', `2', `5'). This can be inefficient, but has the advantage that the text can be
read using simple programs such as the DOS program type.
To help the file system distinguish between text and binary files, C++ provides the ios::binary
flag. On many systems, this flag is ignored because all data is stored in binary format. On some rather
prudish systems, the ios::binary flag is illegal and won't compile!
Binary files can store not only integers and strings, but entire data structures. You can write all the
data at one time by using the write() method of fstream.
If you use write(), you can recover the data using read(). Each of these functions expects a
pointer to character, however, so you must cast the address of your class to be a pointer to character.
The second argument to these functions is the number of characters to write, which you can determine
using sizeof(). Note that what is being written is just the data, not the methods. What is recovered
is just data. Listing 16.18 illustrates writing the contents of a class to a file.
Listing 16.18. Writing a class to a file.
1:
2:
3:
#include <fstream.h>
class Animal4:
{
5:
public:
6:
Animal(int weight, long
days):itsWeight(weight),itsNumberDaysAlive(days){}
7:
~Animal(){}
8:
9:
int GetWeight()const { return itsWeight; }
10:
void SetWeight(int weight) { itsWeight = weight; }
11:
12:
long GetDaysAlive()const { return itsNumberDaysAlive; }
13:
void SetDaysAlive(long days) { itsNumberDaysAlive = days;
}
14:
15:
private:
16:
int itsWeight;
17:
long itsNumberDaysAlive;
18:
};
19:
20:
int main()
// returns 1 on error
21:
{
22:
char fileName[80];
23:
char buffer[255];
24:
25:
cout << "Please enter the file name: ";
26:
cin >> fileName;
27:
ofstream fout(fileName,ios::binary);
28:
if (!fout)
29:
{
30:
cout << "Unable to open " << fileName << " for
writing.\n";
31:
return(1);
32:
}
33:
34:
Animal Bear(50,100);
35:
fout.write((char*) &Bear,sizeof Bear);
36:
37:
fout.close();
38:
39:
ifstream fin(fileName,ios::binary);
40:
if (!fin)
41:
{
42:
cout << "Unable to open " << fileName << " for
reading.\n";
43:
return(1);
44:
}
45:46:
47:
48:
endl;
49:
endl;
50:
51:
52:
53:
endl;
54:
endl;
55:
56:
Animal BearTwo(1,1);
cout << "BearTwo weight: " << BearTwo.GetWeight() <<
cout << "BearTwo days: " << BearTwo.GetDaysAlive() <<
fin.read((char*) &BearTwo, sizeof BearTwo);
cout << "BearTwo weight: " << BearTwo.GetWeight() <<
cout << "BearTwo days: " << BearTwo.GetDaysAlive() <<
fin.close();
return 0;
57: }
Output:
BearTwo
BearTwo
BearTwo
BearTwo
Please enter the file name: Animals
weight: 1
days: 1
weight: 50
days: 100
Analysis: On lines 3-18, a stripped-down Animal class is declared. On lines 22-32, a file is created
and opened for output in binary mode. An animal whose weight is 50 and who is 100 days old is
created on line 34, and its data is written to the file on line 35.
The file is closed on line 37 and reopened for reading in binary mode on line 39. A second animal is
created on line 46 whose weight is 1 and who is only one day old. The data from the file is read into
the new animal object on line 51, wiping out the existing data and replacing it with the data from the
file.
Command-Line Processing
Many operating systems, such as DOS and UNIX, enable the user to pass parameters to your program
when the program starts. These are called command-line options, and are typically separated by spaces
on the command line. For example:
SomeProgram Param1 Param2 Param3
These parameters are not passed to main() directly. Instead, every program's main() function is
passed two parameters. The first is an integer count of the number of arguments on the command line.
The program name itself is counted, so every program has at least one parameter. The example
command line shown previously has four. (The name SomeProgram plus the three parameters makea total of four command-line arguments.)
The second parameter passed to main() is an array of pointers to character strings. Because an array
name is a constant pointer to the first element of the array, you can declare this argument to be a
pointer to a pointer to char, a pointer to an array of char, or an array of arrays of char.
Typically, the first argument is called argc (argument count), but you may call it anything you like.
The second argument is often called argv (argument vector), but again this is just a convention.
It is common to test argc to ensure you've received the expected number of arguments, and to use
argv to access the strings themselves. Note that argv[0] is the name of the program, and
argv[1] is the first parameter to the program, represented as a string. If your program takes two
numbers as arguments, you will need to translate these numbers to strings. On Day 21 you will see
how to use the standard library conversions. Listing 16.19 illustrates how to use the command-line
arguments.
Listing 16.19. Using command-line arguments.
1:
2:
3:
4:
5:
6:
7:
8: }
#include <iostream.h>
int main(int argc, char **argv)
{
cout << "Received " << argc << " arguments...\n";
for (int i=0; i<argc; i++)
cout << "argument " << i << ": " << argv[i] << endl;
return 0;
Output: TestProgram Teach Yourself C++ In 21 Days
Received 7 arguments...
argumnet 0: TestProgram.exe
argument 1: Teach
argument 2: Yourself
argument 3: C++
argument 4: In
argument 5: 21
argument 6: Days
Analysis: The function main() declares two arguments: argc is an integer that contains the count
of command-line arguments, and argv is a pointer to the array of strings. Each string in the array
pointed to by argv is a command-line argument. Note that argv could just as easily have been
declared as char *argv[] or char argv[][]. It is a matter of programming style how you
declare argv; even though this program declared it as a pointer to a pointer, array offsets were still
used to access the individual strings.
On line 4, argc is used to print the number of command-line arguments: seven in all, counting theprogram name itself.
On lines 5 and 6, each of the command-line arguments is printed, passing the null-terminated strings to
cout by indexing into the array of strings.
A more common use of command-line arguments is illustrated by modifying Listing 16.18 to take the
filename as a command-line argument. This listing does not include the class declaration, which is
unchanged.
Listing 16.20. Using command-line arguments.
1:
#include <fstream.h>
2:
int main(int argc, char *argv[])
// returns 1 on error
3:
{
4:
if (argc != 2)
5:
{
6:
cout << "Usage: " << argv[0] << " <filename>" << endl;
7:
return(1);
8:
}
9:
10:
ofstream fout(argv[1],ios::binary);
11:
if (!fout)
12:
{
13:
cout << "Unable to open " << argv[1] << " for
writing.\n";
14:
return(1);
15:
}
16:
17:
Animal Bear(50,100);
18:
fout.write((char*) &Bear,sizeof Bear);
19:
20:
fout.close();
21:
22:
ifstream fin(argv[1],ios::binary);
23:
if (!fin)
24:
{
25:
cout << "Unable to open " << argv[1] << " for
reading.\n";
26:
return(1);
27:
}
28:
29:
Animal BearTwo(1,1);
30:
31:
cout << "BearTwo weight: " << BearTwo.GetWeight() <<
endl;32:
endl;
33:
34:
35:
36:
endl;
37:
endl;
38:
39:
40: }
Output:
BearTwo
BearTwo
BearTwo
cout << "BearTwo days: " << BearTwo.GetDaysAlive() <<
fin.read((char*) &BearTwo, sizeof BearTwo);
cout << "BearTwo weight: " << BearTwo.GetWeight() <<
cout << "BearTwo days: " << BearTwo.GetDaysAlive() <<
fin.close();
return 0;
BearTwo weight: 1
days: 1
weight: 50
days: 100
Analysis: The declaration of the Animal class is the same as in Listing 16.18, and so is left out of
this example. This time, however, rather than prompting the user for the filename, command-line
arguments are used. On line 2, main() is declared to take two parameters: the count of the command-
line arguments and a pointer to the array of command-line argument strings.
On lines 4-8, the program ensures that the expected number of arguments (exactly two) is received. If
the user fails to supply a single filename, an error message is printed:
Usage TestProgram <filename>
Then the program exits. Note that by using argv[0] rather than hard-coding a program name, you
can compile this program to have any name, and this usage statement will work automatically.
On line 10, the program attempts to open the supplied filename for binary output. There is no reason to
copy the filename into a local temporary buffer. It can be used directly by accessing argv[1].
This technique is repeated on line 22 when the same file is reopened for input, and is used in the error
condition statements when the files cannot be opened, on lines 13 and 25.
Summary
Today streams were introduced, and the global objects cout and cin were described. The goal of the
istream and ostream objects is to encapsulate the work of writing to device drivers and buffering
input and output.
There are four standard stream objects created in every program: cout, cin, cerr, and clog. Each
of these can be "redirected" by many operating systems.The istream object cin is used for input, and its most common use is with the overloaded
extraction operator (>>). The ostream object cout is used for output, and its most common use is
with the overloaded insertion operator (<<).
Each of these objects has a number of other member functions, such as get() and put(). Because
the common forms of each of these methods returns a reference to a stream object, it is easy to
concatenate each of these operators and functions.
The state of the stream objects can be changed by using manipulators. These can set the formatting
and display characteristics and various other attributes of the stream objects.
File I/O can be accomplished by using the fstream classes, which derive from the stream classes.
In addition to supporting the normal insertion and extraction operators, these objects also support
read() and write() for storing and retrieving large binary objects.
Q&A
Q. How do you know when to use the insertion and extraction operators and when to use
the other member functions of the stream classes?
A. In general, it is easier to use the insertion and extraction operators, and they are preferred
when their behavior is what is needed. In those unusual circumstances when these operators
don't do the job (such as reading in a string of words), the other functions can be used.
Q. What is the difference between cerr and clog?
A. cerr is not buffered. Everything written to cerr is immediately written out. This is fine
for errors to be written to the screen, but may have too high a performance cost for writing logs
to disk. clog buffers its output, and thus can be more efficient.
Q. Why were streams created if printf() works well?
A. printf() does not support the strong type system of C++, and it does not support user-
defined classes.
Q. When would you ever use putback()?
A. When one read operation is used to determine whether or not a character is valid, but a
different read operation (perhaps by a different object) needs the character to be in the buffer.
This is most often used when parsing a file; for example, the C++ compiler might use
putback().
Q. When would you use ignore()?
A. A common use of this is after using get(). Because get() leaves the terminating
character in the buffer, it is not uncommon to immediately follow a call to get() with a call toignore(1,'\n');. Once again, this is often used in parsing.
Q. My friends use printf() in their C++ programs. Can I?
A. Sure. You'll gain some convenience, but you'll pay by sacrificing type safety.
Workshop
The Workshop contains quiz questions to help solidify your understanding of the material covered and
exercises to provide you with experience in using what you've learned. Try to answer the quiz and
exercise questions before checking the answers in Appendix D, and make sure you understand the
answers before going to the next chapter.
Quiz
1. What is the insertion operator, and what does it do?
2. What is the extraction operator, and what does it do?
3. What are the three forms of cin.get(), and what are their differences?
4. What is the difference between cin.read() and cin.getline()?
5. What is the default width for outputting a long integer using the insertion operator?
6. What is the return value of the insertion operator?
7. What parameter does the constructor to an ofstream object take?
8. What does the ios::ate argument do?
Exercises
1. Write a program that writes to the four standard iostream objects: cin, cout, cerr, and
clog.
2. Write a program that prompts the user to enter her full name and then displays it on the
screen.
3. Rewrite Listing 16.9 to do the same thing, but without using putback() or ignore().
4. Write a program that takes a filename as a parameter and opens the file for reading. Read
every character of the file and display only the letters and punctuation to the screen. (Ignore all
nonprinting characters.) Then close the file and exit.
5. Write a program that displays its command-line arguments in reverse order and does not
display the program name.
The Preprocessor and the Compiler
Every time you run your compiler, your preprocessor runs first. The preprocessor looks for
preprocessor instructions, each of which begins with a pound symbol (#). The effect of each of these
instructions is a change to the text of the source code. The result is a new source code file, a
temporary file that you normally don't see, but that you can instruct the compiler to save so that you
can examine it if you want to.
The compiler does not read your original source code file; it reads the output of the preprocessor and
compiles that file. You've seen the effect of this already with the #include directive. This instructs
the preprocessor to find the file whose name follows the #include directive, and to write it into the
intermediate file at that location. It is as if you had typed that entire file right into your source code,
and by the time the compiler sees the source code, the included file is there.
Seeing the Intermediate Form
Just about every compiler has a switch that you can set either in the integrated development
environment (IDE) or at the command line, and that instructs the compiler to save the intermediate
file. Check your compiler manual for the right switches to set for your compiler, if you'd like to
examine this file.
Using #defineThe #define command defines a string substitution. If you write
#define BIG 512
you have instructed the precompiler to substitute the string 512 wherever it sees the string BIG. This
is not a string in the C++ sense. The characters 512 are substituted in your source code wherever the
token BIG is seen. A token is a string of characters that can be used wherever a string or constant or
other set of letters might be used. Thus, if you write
#define BIG 512
int myArray[BIG];
The intermediate file produced by the precompiler will look like this:
int myArray[512];
Note that the #define statement is gone. Precompiler statements are all removed from the
intermediate file; they do not appear in the final source code at all.
Using #define for Constants
One way to use #define is as a substitute for constants. This is almost never a good idea, however,
as #define merely makes a string substitution and does no type checking. As explained in the
section on constants, there are tremendous advantages to using the const keyword rather than
#define.
Using #define for Tests
A second way to use #define, however, is simply to declare that a particular character string is
defined. Therefore, you could write
#define BIG
Later, you can test whether BIG has been defined and take action accordingly. The precompiler
commands to test whether a string has been defined are #ifdef and #ifndef. Both of these must
be followed by the command #endif before the block ends (before the next closing brace).
#ifdef evaluates to TRUE if the string it tests has been defined already. So, you can write
#ifdef DEBUG
cout << "Debug defined";
#endif
When the precompiler reads the #ifdef, it checks a table it has built to see if you've defined DEBUG.If you have, the #ifdef evaluates to TRUE, and everything to the next #else or #endif is written
into the intermediate file for compiling. If it evaluates to FALSE, nothing between #ifdef DEBUG
and #endif will be written into the intermediate file; it will be as if it were never in the source code
in the first place.
Note that #ifndef is the logical reverse of #ifdef. #ifndef evaluates to TRUE if the string has
not been defined up to that point in the file.
The #else Precompiler Command
As you might imagine, the term #else can be inserted between either #ifdef or #ifndef and the
closing #endif. Listing 17.1 illustrates how these terms are used.
Listing 17.1. Using #define.
1:
#define DemoVersion
2:
#define DOS_VERSION 5
3:
#include <iostream.h>
4:
5:
6:
int main()
7:
{
8:
9:
cout << "Checking on the definitions of DemoVersion,
DOS_VERSION ("
_and WINDOWS_VERSION...\n";
10:
11:
#ifdef DemoVersion
12:
cout << "DemoVersion defined.\n";
13:
#else
14:
cout << "DemoVersion not defined.\n";
15:
#endif
16:
17:
#ifndef DOS_VERSION
18:
cout << "DOS_VERSION not defined!\n";
19:
#else
20:
cout << "DOS_VERSION defined as: " << DOS_VERSION <<
endl;
21:
#endif
22:
23:
#ifdef WINDOWS_VERSION
24:
cout << "WINDOWS_VERSION defined!\n";
25:
#else
26:
cout << "WINDOWS_VERSION was not defined.\n";
27:
#endif
28:29:
30:
31: }
cout << "Done.\n";
return 0;
Output: Checking on the definitions of DemoVersion, DOS_VERSION
("
_and WINDOWS_VERSION...\n";
DemoVersion defined.
DOS_VERSION defined as: 5
WINDOWS_VERSION was not defined.
Done.
Analysis: On lines 1 and 2, DemoVersion and DOS_VERSION are defined, with DOS_VERSION
defined with the string 5. On line 11, the definition of DemoVersion is tested, and because
DemoVersion is defined (albeit with no value), the test is true and the string on line 12 is printed.
On line 17 is the test that DOS_VERSION is not defined. Because DOS_VERSION is defined, this test
fails and execution jumps to line 20. Here the string 5 is substituted for the word DOS_VERSION;
this is seen by the compiler as
cout << "DOS_VERSION defined as: " << 5 << endl;
Note that the first word DOS_VERSION is not substituted because it is in a quoted string. The second
DOS_VERSION is substituted, however, and thus the compiler sees 5 as if you had typed 5 there.
Finally, on line 23, the program tests for WINDOWS_VERSION. Because you did not define
WINDOWS_VERSION, the test fails and the message on line 24 is printed.
Inclusion and Inclusion Guards
You will create projects with many different files. You will probably organize your directories so that
each class has its own header file (HPP) with the class declaration, and its own implementation file
(CPP) with the source code for the class methods.
Your main() function will be in its own CPP file, and all the CPP files will be compiled into OBJ
files, which will then be linked together into a single program by the linker.
Because your programs will use methods from many classes, many header files will be included in
each file. Also, header files often need to include one another. For example, the header file for a
derived class's declaration must include the header file for its base class.
Imagine that the Animal class is declared in the file ANIMAL.HPP. The Dog class (which derives
from Animal) must include the file ANIMAL.HPP in DOG.HPP, or Dog will not be able to derive
from Animal. The Cat header also includes ANIMAL.HPP for the same reason.
If you create a method that uses both a Cat and a Dog, you will be in danger of including
ANIMAL.HPP twice. This will generate a compile-time error, because it is not legal to declare a class(Animal) twice, even though the declarations are identical. You can solve this problem with
inclusion guards. At the top of your ANIMAL header file, you write these lines:
#ifndef ANIMAL_HPP
#define ANIMAL_HPP
...
#endif
// the whole file goes here
This says, if you haven't defined the term ANIMAL_HPP, go ahead and define it now. Between the
#define statement and the closing #endif are the entire contents of the file.
The first time your program includes this file, it reads the first line and the test evaluates to TRUE; that
is, you have not yet defined ANIMAL_HPP. So, it goes ahead and defines it and then includes the
entire file.
The second time your program includes the ANIMAL.HPP file, it reads the first line and the test
evaluates to FALSE; ANIMAL.HPP has been defined. It therefore skips to the next #else (there isn't
one) or the next #endif (at the end of the file). Thus, it skips the entire contents of the file, and the
class is not declared twice.
The actual name of the defined symbol (ANIMAL_HPP) is not important, although it is customary to
use the filename in all uppercase with the dot (.) changed to an underscore. This is purely convention,
however.
NOTE: It never hurts to use inclusion guards. Often they will save you hours of
debugging time.
Defining on the Command Line
Almost all C++ compilers will let you #define values either from the command line or from the
integrated development environment (and usually both). Thus you can leave out lines 1 and 2 from
Listing 17.1, and define DemoVersion and BetaTestVersion from the command line for some
compilations, and not for others.
It is common to put in special debugging code surrounded by #ifdef DEBUG and #endif. This
allows all the debugging code to be easily removed from the source code when you compile the final
version; just don't define the term DEBUG.
Undefining
If you have a name defined and you'd like to turn it off from within your code, you can use #undef.
This works as the antidote to #define. Listing 17.2 provides an illustration of its use.Listing 17.2. Using #undef.
1:
#define DemoVersion
2:
#define DOS_VERSION 5
3:
#include <iostream.h>
4:
5:
6:
int main()
7:
{
8:
9:
cout << "Checking on the definitions of DemoVersion,
DOS_VERSION !/
_and WINDOWS_VERSION...\n";
10:
11:
#ifdef DemoVersion
12:
cout << "DemoVersion defined.\n";
13:
#else
14:
cout << "DemoVersion not defined.\n";
15:
#endif
16:
17:
#ifndef DOS_VERSION
18:
cout << "DOS_VERSION not defined!\n";
19:
#else
20:
cout << "DOS_VERSION defined as: " << DOS_VERSION <<
endl;
21:
#endif
22:
23:
#ifdef WINDOWS_VERSION
24:
cout << "WINDOWS_VERSION defined!\n";
25:
#else
26:
cout << "WINDOWS_VERSION was not defined.\n";
27:
#endif
28:
29:
#undef DOS_VERSION
30:
31:
#ifdef DemoVersion
32:
cout << "DemoVersion defined.\n";
33:
#else
34:
cout << "DemoVersion not defined.\n";
35:
#endif
36:
37:
#ifndef DOS_VERSION
38:
cout << "DOS_VERSION not defined!\n";
39:
#else
40:
cout << "DOS_VERSION defined as: " << DOS_VERSION <<
endl;
41:
#endif42:
43:
44:
45:
46:
47:
48:
49:
50:
51: }
#if_Tz'WINDOWS_VERSION
cout << "WINDOWS_VERSION defined!\n";
#else
cout << "WINDOWS_VERSION was not defined.\n";
#endif
cout << "Done.\n";
return 0;
Output: Checking on the definitions of DemoVersion, DOS_VERSION
#%
_and WINDOWS_VERSION...\n";
DemoVersion defined.
DOS_VERSION defined as: 5
WINDOWS_VERSION was not defined.
DemoVersion defined.
DOS_VERSION not defined!
WINDOWS_VERSION was not defined.
Done.
Analysis: Listing 17.2 is the same as Listing 17.1 until line 29, when #undef DOS_VERSION is
called. This removes the definition of the term DOS_VERSION without changing the other defined
terms (in this case, DemoVersion). The rest of the listing just repeats the printouts. The tests for
DemoVersion and WINDOWS_VERSION act as they did the first time, but the test for
DOS_VERSION now evaluates TRUE. In this second case DOS_VERSION does not exist as a defined
term.
Conditional Compilation
By combining #define or command-line definitions with #ifdef, #else, and #ifndef, you
can write one program that compiles different code, depending on what is already #defined. This
can be used to create one set of source code to compile on two different platforms, such as DOS and
Windows.
Another common use of this technique is to conditionally compile in some code based on whether
debug has been defined, as you'll see in a few moments.
DO use conditional compilation when you need to create more than one version of your
code at the same time. DON'T let your conditions get too complex to manage. DO use
#undef as often as possible to avoid leaving stray definitions in your code. DO use
inclusion guards!Macro Functions
The #define directive can also be used to create macro functions. A macro function is a symbol
created using #define and that takes an argument, much like a function does. The preprocessor will
substitute the substitution string for whatever argument it is given. For example, you can define the
macro TWICE as
#define TWICE(x) ( (x) * 2 )
and then in your code you write
TWICE(4)
The entire string TWICE(4) will be removed, and the value 8 will be substituted! When the
precompiler sees the 4, it will substitute ( (4) * 2 ), which will then evaluate to 4 * 2 or 8.
A macro can have more than one parameter, and each parameter can be used repeatedly in the
replacement text. Two common macros are MAX and MIN:
#define MAX(x,y) ( (x) > (y) ? (x) : (y) )
#define MIN(x,y) ( (x) < (y) ? (x) : (y) )
Note that in a macro function definition, the opening parenthesis for the parameter list must
immediately follow the macro name, with no spaces. The preprocessor is not as forgiving of white
space as is the compiler.
If you were to write
#define MAX (x,y) ( (x) > (y) ? (x) : (y) )
and then tried to use MAX like this,
int x = 5, y = 7, z;
z = MAX(x,y);
the intermediate code would be
int x = 5, y = 7, z;
z = (x,y) ( (x) > (y) ? (x) : (y) ) (x,y)
A simple text substitution would be done, rather than invoking the macro function. Thus the token
MAX would have substituted for it (x,y) ( (x) > (y) ? (x) : (y) ), and then that would
be followed by the (x,y) which followed Max.By removing the space between MAX and (x,y), however, the intermediate code becomes:
int x = 5, y = 7, z;
z =7;
Why All the Parentheses?
You may be wondering why there are so many parentheses in many of the macros presented so far.
The preprocessor does not demand that parentheses be placed around the arguments in the substitution
string, but the parentheses help you to avoid unwanted side effects when you pass complicated values
to a macro. For example, if you define MAX as
#define MAX(x,y) x > y ? x : y
and pass in the values 5 and 7, the macro works as intended. But if you pass in a more complicated
expression, you'll get unintended results, as shown in Listing 17.3.
Listing 17.3. Using parentheses in macros.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23: }
// Listing 17.3 Macro Expansion
#include <iostream.h>
#define CUBE(a) ( (a) * (a) * (a) )
#define THREE(a) a * a * a
int main()
{
long x = 5;
long y = CUBE(x);
long z = THREE(x);
cout << "y: " << y << endl;
cout << "z: " << z << endl;
long a = 5, b = 7;
y = CUBE(a+b);
z = THREE(a+b);
cout << "y: " << y << endl;
cout << "z: " << z << endl;
return 0;
Output: y: 125
z: 125y: 1728
z: 82
Analysis: On line 4, the macro CUBE is defined, with the argument x put into parentheses each time it
is used. On line 5, the macro THREE is defined, without the parentheses.
In the first use of these macros, the value 5 is given as the parameter, and both macros work fine.
CUBE(5) expands to ( (5) * (5) * (5) ), which evaluates to 125, and THREE(5) expands
to 5 * 5 * 5, which also evaluates to 125.
In the second use, on lines 16-18, the parameter is 5 + 7. In this case, CUBE(5+7) evaluates to
( (5+7) * (5+7) * (5+7) )
which evaluates to
( (12) * (12) * (12) )
which in turn evaluates to 1728. THREE(5+7), however, evaluates to
5 + 7 * 5 + 7 * 5 + 7
Because multiplication has a higher precedence than addition, this becomes
5 + (7 * 5) + (7 * 5) + 7
which evaluates to
5 + (35) + (35) + 7
which finally evaluates to 82.
Macros Versus Functions and Templates
Macros suffer from four problems in C++. The first is that they can be confusing if they get large,
because all macros must be defined on one line. You can extend that line by using the backslash
character (\), but large macros quickly become difficult to manage.
The second problem is that macros are expanded inline each time they are used. This means that if a
macro is used a dozen times, the substitution will appear 12 times in your program, rather than appear
once as a function call will. On the other hand, they are usually quicker than a function call because
the overhead of a function call is avoided.
The fact that they are expanded inline leads to the third problem, which is that the macro does not
appear in the intermediate source code used by the compiler, and therefore is unavailable in mostdebuggers. This makes debugging macros tricky.
The final problem, however, is the biggest: macros are not type-safe. While it is convenient that
absolutely any argument may be used with a macro, this completely undermines the strong typing of
C++ and so is anathema to C++ programmers. However, there is a way to overcome this problem, as
you'll see on Day 19, "Templates."
Inline Functions
It is often possible to declare an inline function rather than a macro. For example, Listing 17.4 creates
a CUBE function, which accomplishes the same thing as the CUBE macro in Listing 17.3, but does so
in a type-safe way.
Listing 17.4. Using inline rather than a macro.
1:
2:
3:
}
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22: }
#include <iostream.h>
inline unsigned long Square(unsigned long a) { return a * a;
inline unsigned long Cube(unsigned long a)
{ return a * a * a; }
int main()
{
unsigned long x=1 ;
for (;;)
{
cout << "Enter a number (0 to quit): ";
cin >> x;
if (x == 0)
break;
cout << "You entered: " << x;
cout << ". Square(" << x << "): ";
cout << Square(x);
cout<< ". Cube(" _<< x << "): ";
cout << Cube(x) << "." << endl;
}
return 0;
Output: Enter a number (0 to quit): 1
You entered: 1. Square(1): 1. Cube(1): 1.
Enter a number (0 to quit): 2
You entered: 2. Square(2): 4. Cube(2): 8.
Enter a number (0 to quit): 3
You entered: 3. Square(3): 9. Cube(3): 27.Enter a number (0 to quit):
You entered: 4. Square(4):
Enter a number (0 to quit):
You entered: 5. Square(5):
Enter a number (0 to quit):
You entered: 6. Square(6):
Enter a number (0 to quit):
4
16. Cube(4): 64.
5
25. Cube(5): 125.
6
36. Cube(6): 216.
0
Analysis: On lines 3 and 4, two inline functions are declared: Square() and Cube(). Each is
declared to be inline, so like a macro function these will be expanded in place for each call, and there
will be no function call overhead.
As a reminder, expanded inline means that the content of the function will be placed into the code
wherever the function call is made (for example, on line 16). Because the function call is never made,
there is no overhead of putting the return address and the parameters on the stack.
On line 16, the function Square is called, as is the function Cube. Again, because these are inline
functions, it is exactly as if this line had been written like this:
16:
cout << ". Square(" << x << "): "
Cube(" << x << '*"): " << x * x * x <<
"." << endl;
<< x * x << ".
String Manipulation
The preprocessor provides two special operators for manipulating strings in macros. The stringizing
operator (#) substitutes a quoted string for whatever follows the stringizing operator. The
concatenation operator bonds two strings together into one.
Stringizing
The stringizing operator puts quotes around any characters following the operator, up to the next
white space. Thus, if you write
#define WRITESTRING(x) cout << #x
and then call
WRITESTRING(This is a string);
the precompiler will turn it into
cout << "This is a string";
Note that the string This is a string is put into quotes, as required by cout.Concatenation
The concatenation operator allows you to bond together more than one term into a new word. The
new word is actually a token that can be used as a class name, a variable name, an offset into an array,
or anywhere else a series of letters might appear.
Assume for a moment that you have five functions, named fOnePrint, fTwoPrint,
fThreePrint, fFourPrint, and fFivePrint. You can then declare:
#define fPRINT(x) f ## x ## Print
and then use it with fPRINT(Two) to generate fTwoPrint and with fPRINT(Three) to
generate fThreePrint.
At the conclusion of Week 2, a PartsList class was developed. This list could only handle objects
of type List. Let's say that this list works well, and you'd like to be able to make lists of animals,
cars, computers, and so forth.
One approach would be to create AnimalList, CarList, ComputerList, and so on, cutting
and pasting the code in place. This will quickly become a nightmare, as every change to one list must
be written to all the others.
An alternative is to use macros and the concatenation operator. For example, you could define
#define Listof(Type)
{ \
public: \
Type##List(){} \
private:
\
int itsLength; \
};
class Type##List \
This example is overly sparse, but the idea would be to put in all the necessary methods and data.
When you were ready to create an AnimalList, you would write
Listof(Animal)
and this would be turned into the declaration of the AnimalList class. There are some problems
with this approach, all of which are discussed in detail on Day 19, when templates are discussed.
Predefined Macros
Many compilers predefine a number of useful macros, including __DATE__, __TIME__,__LINE__, and __FILE__. Each of these names is surrounded by two underscore characters to
reduce the likelihood that the names will conflict with names you've used in your program.
When the precompiler sees one of these macros, it makes the appropriate substitutes. For __DATE__,
the current date is substituted. For __TIME__, the current time is substituted. __LINE__ and
__FILE__ are replaced with the source code line number and filename, respectively. You should
note that this substitution is made when the source is precompiled, not when the program is run. If you
ask the program to print __DATE__, you will not get the current date; instead, you will get the date
the program was compiled. These defined macros are very useful in debugging.
assert()
Many compilers offer an assert() macro. The assert() macro returns TRUE if its parameter
evaluates TRUE and takes some kind of action if it evaluates FALSE. Many compilers will abort the
program on an assert() that fails; others will throw an exception (see Day 20, "Exceptions and
Error Handling").
One powerful feature of the assert() macro is that the preprocessor collapses it into no code at all
if DEBUG is not defined. It is a great help during development, and when the final product ships there
is no performance penalty nor increase in the size of the executable version of the program.
Rather than depending on the compiler-provided assert(), you are free to write your own
assert() macro. Listing 17.5 provides a simple assert() macro and shows its use.
Listing 17.5. A simple assert() macro.
1:
// Listing 17.5 ASSERTS
2:
#define DEBUG
3:
#include <iostream.h>
4:
5:
#ifndef DEBUG
6:
#define ASSERT(x)
7:
#else
8:
#define ASSERT(x) \
9:
if (! (x)) \
10:
{ \
11:
cout << "ERROR!! Assert " << #x << "
failed\n"; \
12:
cout << " on line " << __LINE__ << "\n"; \
13:
cout << " in file " << __FILE__ << "\n"; \
14:
}
15:
#endif
16:
17:
18:
int main()19:
20:
21:
22:
23:
24:
25:
26:
27: }
{
int x = 5;
cout << "First assert: \n";
ASSERT(x==5);
cout << "\nSecond assert: \n";
ASSERT(x != 5);
cout << "\nDone.\n";
return 0;
Output: First assert:
Second assert:
ERROR!! Assert x !=5 failed
on line 24
in file test1704.cpp
Done.
Analysis: On line 2, the term DEBUG is defined. Typically, this would be done from the command
line (or the IDE) at compile time, so you can turn this on and off at will. On lines 8-14, the
assert() macro is defined. Typically, this would be done in a header file, and that header
(ASSERT.HPP) would be included in all your implementation files.
On line 5, the term DEBUG is tested. If it is not defined, assert() is defined to create no code at all.
If DEBUG is defined, the functionality defined on lines 8-14 is applied.
The assert() itself is one long statement, split across seven source code lines, as far as the
precompiler is concerned. On line 9, the value passed in as a parameter is tested; if it evaluates
FALSE, the statements on lines 11-13 are invoked, printing an error message. If the value passed in
evaluates TRUE, no action is taken.
Debugging with assert()
When writing your program, you will often know deep down in your soul that something is true: a
function has a certain value, a pointer is valid, and so forth. It is the nature of bugs that what you
know to be true might not be so under some conditions. For example, you know that a pointer is valid,
yet the program crashes. assert() can help you find this type of bug, but only if you make it a
regular practice to use assert() liberally in your code. Every time you assign or are passed a
pointer as a parameter or function return value, be sure to assert that the pointer is valid. Any time
your code depends on a particular value being in a variable, assert() that that is true.
There is no penalty for frequent use of assert(); it is removed from the code when you undefine
debugging. It also provides good internal documentation, reminding the reader of what you believe is
true at any given moment in the flow of the code.
assert() Versus ExceptionsOn Day 20, you will learn how to work with exceptions to handle error conditions. It is important to
note that assert() is not intended to handle runtime error conditions such as bad data, out-of-
memory conditions, unable to open file, and so forth. assert() is created to catch programming
errors only. That is, if an assert() "fires," you know you have a bug in your code.
This is critical, because when you ship your code to your customers, instances of assert() will be
removed. You can't depend on an assert() to handle a runtime problem, because the assert()
won't be there.
It is a common mistake to use assert() to test the return value from a memory assignment:
Animal *pCat = new Cat;
Assert(pCat);
// bad use of assert
pCat->SomeFunction();
This is a classic programming error; every time the programmer runs the program, there is enough
memory and the assert() never fires. After all, the programmer is running with lots of extra RAM
to speed up the compiler, debugger, and so forth. The programmer then ships the executable, and the
poor user, who has less memory, reaches this part of the program and the call to new fails and returns
NULL. The assert(), however, is no longer in the code and there is nothing to indicate that the
pointer points to NULL. As soon as the statement pCat->SomeFunction() is reached, the
program crashes.
Getting NULL back from a memory assignment is not a programming error, although it is an
exceptional situation. Your program must be able to recover from this condition, if only by throwing
an exception. Remember: The entire assert() statement is gone when DEBUG is undefined.
Exceptions are covered in detail on Day 20.
Side Effects
It is not uncommon to find that a bug appears only after the instances of assert() are removed.
This is almost always due to the program unintentionally depending on side effects of things done in
assert() and other debug-only code. For example, if you write
ASSERT (x = 5)
when you mean to test whether x == 5, you will create a particularly nasty bug.
Let's say that just prior to this assert() you called a function that set x equal to 0. With this
assert() you think you are testing whether x is equal to 5; in fact, you are setting x equal to 5. The
test returns TRUE, because x = 5 not only sets x to 5, but returns the value 5, and because 5 is non-
zero it evaluates as TRUE.
Once you pass the assert() statement, x really is equal to 5 (you just set it!). Your program runsjust fine. You're ready to ship it, so you turn off debugging. Now the assert() disappears, and you
are no longer setting x to 5. Because x was set to 0 just before this, it remains at 0 and your program
breaks.
In frustration, you turn debugging back on, but hey! Presto! The bug is gone. Once again, this is rather
funny to watch, but not to live through, so be very careful about side effects in debugging code. If you
see a bug that only appears when debugging is turned off, take a look at your debugging code with an
eye out for nasty side effects.
Class Invariants
Most classes have some conditions that should always be true whenever you are finished with a class
member function. These class invariants are the sine qua non of your class. For example, it may be
true that your CIRCLE object should never have a radius of zero, or that your ANIMAL should always
have an age greater than zero and less than 100.
It can be very helpful to declare an Invariants() method that returns TRUE only if each of these
conditions is still true. You can then ASSERT(Invariants()) at the start and completion of
every class method. The exception would be that your Invariants() would not expect to return
TRUE before your constructor runs or after your destructor ends. Listing 17.6 demonstrates the use of
the Invariants() method in a trivial class.
Listing 17.6. Using Invariants().
0:
#define DEBUG
1:
#define SHOW_INVARIANTS
2:
#include <iostream.h>
3:
#include <string.h>
4:
5:
#ifndef DEBUG
6:
#define ASSERT(x)
7:
#else
8:
#define ASSERT(x) \
9:
if (! (x)) \
10:
{ \
11:
cout << "ERROR!! Assert " << #x << "
failed\n"; \
12:
cout << " on line " << __LINE__ << "\n"; \
13:
cout << " in file " << __FILE__ << "\n"; \
14:
}
15:
#endif
16:
17:
18:
const int FALSE = 0;
19:
const int TRUE = 1;20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
typedef int BOOL;
class String
{
public:
// constructors
String();
String(const char *const);
String(const String &);
~String();
char & operator[](int offset);
char operator[](int offset) const;
String & operator= (const String &);
int GetLen()const { return itsLen; }
const char * GetString() const { return itsString; }
BOOL Invariants() const;
private:
String (int);
// private constructor
char * itsString;
// unsigned short itsLen;
int itsLen;
};
// default constructor creates string of 0 bytes
String::String()
{
itsString = new char[1];
itsString[0] = `\0';
itsLen=0;
ASSERT(Invariants());
}
// private (helper) constructor, used only by
// class methods for creating a new string of
// required size. Null filled.
String::String(int len)
{
itsString = new char[len+1];
for (int i = 0; i<=len; i++)
itsString[i] = `\0';
itsLen=len;
ASSERT(Invariants());66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
}
// Converts a character array to a String
String::String(const char * const cString)
{
itsLen = strlen(cString);
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen; i++)
itsString[i] = cString[i];
itsString[itsLen]='\0';
ASSERT(Invariants());
}
// copy constructor
String::String (const String & rhs)
{
itsLen=rhs.GetLen();
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen;i++)
itsString[i] = rhs[i];
itsString[itsLen] = `\0';
ASSERT(Invariants());
}
// destructor, frees allocated memory
String::~String ()
{
ASSERT(Invariants());
delete [] itsString;
itsLen = 0;
}
// operator equals, frees existing memory
// then copies string and size
String& String::operator=(const String & rhs)
{
ASSERT(Invariants());
if (this == &rhs)
return *this;
delete [] itsString;
itsLen=rhs.GetLen();
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen;i++)
itsString[i] = rhs[i];
itsString[itsLen] = `\0';
ASSERT(Invariants());112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
return *this;
}
//non constant offset operator, returns
// reference to character so it can be
// changed!
char & String::operator[](int offset)
{
ASSERT(Invariants());
if (offset > itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
ASSERT(Invariants());
}
// constant offset operator for use
// on const objects (see copy constructor!)
char String::operator[](int offset) const
{
ASSERT(Invariants());
if (offset > itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
ASSERT(Invariants());
}
BOOL String::Invariants() const
{
#ifdef SHOW_INVARIANTS
cout << " String OK ";
#endif
return ( (itsLen && itsString) ||
(!itsLen && !itsString) );
}
class Animal
{
public:
Animal():itsAge(1),itsName("John Q. Animal")
{ASSERT(Invariants());}
Animal(int, const String&);
~Animal(){}
int GetAge() { ASSERT(Invariants()); return itsAge;}158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
";
200:
201:
202:
void SetAge(int Age)
{
ASSERT(Invariants());
itsAge = Age;
ASSERT(Invariants());
}
String& GetName()
{
ASSERT(Invariants());
return itsName;
}
void SetName(const String& name)
{
ASSERT(Invariants());
itsName = name;
ASSERT(Invariants());
}
BOOL Invariants();
private:
int itsAge;
String itsName;
};
Animal::Animal(int age, const String& name):
itsAge(age),
itsName(name)
{
ASSERT(Invariants());
}
BOOL Animal::Invariants()
{
#ifdef SHOW_INVARIANTS
cout << " Animal OK ";
#endif
return (itsAge > 0 && itsName.GetLen());
}
int main()
{
Animal sparky(5,"Sparky");
cout << "\n" << sparky.GetName().GetString() << " is
cout << sparky.GetAge() << " years old.";
sparky.SetAge(8);
cout << "\n" << sparky.GetName().GetString() << " is";
203:
204:
205: }
cout << sparky.GetAge() << " years old.";
return 0;
Output: String OK String OK String OK String OK String OK
String OK String OK Animal OK String OK Animal OK
Sparky is Animal OK 5 years old. Animal OK Animal OK
Animal OK Sparky is Animal OK 8 years old. String OK
Analysis: On lines 6-16, the assert() macro is defined. If DEBUG is defined, this will write out an
error message when the assert() macro evaluates FALSE.
On line 38, the String class member function Invariants() is declared; it is defined on lines
141-148. The constructor is declared on lines 48-54, and on line 53, after the object is fully
constructed, Invariants() is called to confirm proper construction.
This pattern is repeated for the other constructors, and the destructor calls Invariants() only
before it sets out to destroy the object. The remaining class functions call Invariants() both
before taking any action and then again before returning. This both affirms and validates a
fundamental principal of C++: Member functions other than constructors and destructors should work
on valid objects and should leave them in a valid state.
On line 175, class Animal declares its own Invariants() method, implemented on lines 188-
194. Note on lines 154, 157, 160, and 162 that inline functions can call the Invariants() method.
Printing Interim Values
In addition to asserting that something is true using the assert() macro, you may want to print the
current value of pointers, variables, and strings. This can be very helpful in checking your
assumptions about the progress of your program, and in locating off-by-one bugs in loops. Listing
17.7 illustrates this idea.
Listing 17.7. Printing values in DEBUG mode.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
// Listing 17.7 - Printing values in DEBUG mode
#include <iostream.h>
#define DEBUG
#ifndef
#define
#else
#define
cout
#endif
DEBUG
PRINT(x)
PRINT(x) \
<< #x << ":\t" << x << endl;12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30: }
enum BOOL { FALSE, TRUE } ;
Output:
i:
i:
i:
i:
i:
y:
"Hi.":
px:
*px:
int main()
{
int x = 5;
long y = 73898l;
PRINT(x);
for (int i = 0; i < x; i++)
{
PRINT(i);
}
PRINT (y);
PRINT("Hi.");
int *px = &x;
PRINT(px);
PRINT (*px);
return 0;
x:
5
0
1
2
3
4
73898
Hi.
0x2100 (You may receive a value other than 0x2100)
5
Analysis: The macro on lines 5-10 provides printing of the current value of the supplied parameter.
Note that the first thing fed to cout is the stringized version of the parameter; that is, if you pass in x,
cout receives "x".
Next, cout receives the quoted string ":\t", which prints a colon and then a tab. Third, cout
receives the value of the parameter (x), and then finally, endl, which writes a new line and flushes
the buffer.
Debugging Levels
In large, complex projects, you may want more control than simply turning DEBUG on and off. You
can define debug levels and test for these levels when deciding which macros to use and which to strip
out.
To define a level, simply follow the #define DEBUG statement with a number. While you can haveany number of levels, a common system is to have four levels: HIGH, MEDIUM, LOW, and NONE.
Listing 17.8 illustrates how this might be done, using the String and Animal classes from Listing
17.6. The definitions of the class methods other than Invariants() have been left out to save
space because they are unchanged from Listing 17.6.
NOTE: To compile this code, copy lines 43-136 of Listing 17.6 between lines 64 and
65 of this listing.
Listing 17.8. Levels of debugging.
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
enum LEVEL { NONE, LOW, MEDIUM, HIGH };
const int FALSE = 0;
const int TRUE = 1;
typedef int BOOL;
#define DEBUGLEVEL HIGH
#include <iostream.h>
#include <string.h>
#if DEBUGLEVEL < LOW // must be medium or high
#define ASSERT(x)
#else
#define ASSERT(x) \
if (! (x)) \
{ \
cout << "ERROR!! Assert " << #x << " failed\n"; \
cout << " on line " << __LINE__ << "\n"; \
cout << " in file " << __FILE__ << "\n"; \
}
#endif
#if DEBUGLEVEL < MEDIUM
#define EVAL(x)
#else
#define EVAL(x) \
cout << #x << ":\t" << x << endl;
#endif
#if DEBUGLEVEL < HIGH
#define PRINT(x)
#else
#define PRINT(x) \
cout << x << endl;34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
#endif
class String
{
public:
// constructors
String();
String(const char *const);
String(const String &);
~String();
char & operator[](int offset);
char operator[](int offset) const;
String & operator= (const String &);
int GetLen()const { return itsLen; }
const char * GetString() const
{ return itsString; }
BOOL Invariants() const;
private:
String (int);
// private constructor
char * itsString;
unsigned short itsLen;
};
BOOL String::Invariants() const
{
PRINT("(String Invariants Checked)");
return ( (BOOL) (itsLen && itsString) ||
(!itsLen && !itsString) );
}
class Animal
{
public:
Animal():itsAge(1),itsName("John Q. Animal")
{ASSERT(Invariants());}
Animal(int, const String&);
~Animal(){}
int GetAge()
{
ASSERT(Invariants());80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
return itsAge;
}
void SetAge(int Age)
{
ASSERT(Invariants());
itsAge = Age;
ASSERT(Invariants());
}
String& GetName()
{
ASSERT(Invariants());
return itsName;
}
void SetName(const String& name)
{
ASSERT(Invariants());
itsName = name;
ASSERT(Invariants());
}
BOOL Invariants();
private:
int itsAge;
String itsName;
};
BOOL Animal::Invariants()
{
PRINT("(Animal Invariants Checked)");
return (itsAge > 0 && itsName.GetLen());
}
int main()
{
const int AGE = 5;
EVAL(AGE);
Animal sparky(AGE,"Sparky");
cout << "\n" << sparky.GetName().GetString();
cout << " is ";
cout << sparky.GetAge() << " years old.";
sparky.SetAge(8);
cout << "\n" << sparky.GetName().GetString();
cout << " is ";
cout << sparky.GetAge() << " years old.";126:
127: }
return 0;
Output: AGE:
5
(String Invariants
(String Invariants
(String Invariants
(String Invariants
(String Invariants
(String Invariants
(String Invariants
(String Invariants
(String Invariants
(String Invariants
Checked)
Checked)
Checked)
Checked)
Checked)
Checked)
Checked)
Checked)
Checked)
Checked)
Sparky is (Animal Invariants Checked)
5 Years old. (Animal Invariants Checked)
(Animal Invariants Checked)
(Animal Invariants Checked)
Sparky is (Animal Invariants Checked)
8 years old. (String Invariants Checked)
(String Invariants Checked)
// run again with DEBUG = MEDIUM
AGE:
5
Sparky is 5 years old.
Sparky is 8 years old.
Analysis: On lines 10 to 20, the assert() macro is defined to be stripped if DEBUGLEVEL is less
than LOW (that is, DEBUGLEVEL is NONE). If any debugging is enabled, the assert() macro will
work. On line 23, EVAL is declared to be stripped if DEBUG is less than MEDIUM; if DEBUGLEVEL is
NONE or LOW, EVAL is stripped.
Finally, on lines 29-34, the PRINT macro is declared to be stripped if DEBUGLEVEL is less than
HIGH. PRINT is used only when DEBUGLEVEL is HIGH; you can eliminate this macro by setting
DEBUGLEVEL to MEDIUM and still maintain your use of EVAL and assert().
PRINT is used within the Invariants() methods to print an informative message. EVAL is used
on line 117 to evaluate the current value of the constant integer AGE.
DO use CAPITALS for your macro names. This is a pervasive convention, and other
programmers will be confused if you don't. DON'T allow your macros to have side
effects. Don't increment variables or assign values from within a macro. DO surround
all arguments with parentheses in macro functions.Summary
Today you learned more details about working with the preprocessor. Each time you run the compiler,
the preprocessor runs first and translates your preprocessor directives such as #define and
#ifdef.
The preprocessor does text substitution, although with the use of macros these can be somewhat
complex. By using #ifdef, #else, and #ifndef, you can accomplish conditional compilation,
compiling in some statements under one set of conditions and in another set of statements under other
conditions. This can assist in writing programs for more than one platform and is often used to
conditionally include debugging information.
Macro functions provide complex text substitution based on arguments passed at compile time to the
macro. It is important to put parentheses around every argument in the macro to ensure the correct
substitution takes place.
Macro functions, and the preprocessor in general, are less important in C++ than they were in C. C++
provides a number of language features, such as const variables and templates, that offer superior
alternatives to use of the preprocessor.
Q&A
Q. If C++ offers better alternatives than the preprocessor, why is this option still
available?
A. First, C++ is backward-compatible with C, and all significant parts of C must be supported
in C++. Second, there are some uses of the preprocessor that are still used frequently in C++,
such as inclusion guards.
Q. Why use macro functions when you can use a regular function?
A. Macro functions are expanded inline and are used as a substitute for repeatedly typing the
same commands with minor variations. Again, though, templates offer a better alternative.
Q. How do you know when to use a macro versus an inline function?
A. Often it doesn't matter much; use whichever is simpler. However, macros offer character
substitution, stringizing, and concatenation. None of these is available with functions.
Q. What is the alternative to using the preprocessor to print interim values during
debugging?
A. The best alternative is to use watch statements within a debugger. For information on
watch statements, consult your compiler or debugger documentation.Q. How do you decide when to use an assert() and when to throw an exception?
A. If the situation you're testing can be true without your having committed a programming
error, use an exception. If the only reason for this situation to ever be true is a bug in your
program, use an assert().
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material
covered and exercises to provide you with experience in using what you've learned. Try to answer the
quiz and exercise questions before checking the answers in Appendix D, and make sure you
understand the answers before continuing to the next chapter.
Quiz
1. What is an inclusion guard?
2. How do you instruct your compiler to print the contents of the intermediate file showing the
effects of the preprocessor?
3. What is the difference between #define debug 0 and #undef debug?
4. Name four predefined macros.
5. Why can't you call Invariants() as the first line of your constructor?
Exercises
1. Write the inclusion guard statements for the header file STRING.H.
2. Write an assert() macro that prints an error message and the file and line number if
debug level is 2, just a message (without file and line number) if the level is 1, and does
nothing if the level is 0.
3. Write a macro DPrint that tests if DEBUG is defined and, if it is, prints the value passed in
as a parameter.
4. Write a function that prints an error message. The function should print the line number and
filename where the error occurred. Note that the line number and filename are passed in to this
function.
5. How would you call the preceding error function?
6. Write an assert() macro that uses the error function from Exercise 4, and write a driver
program that calls this assert() macro.
The Development Cycle
Many volumes have been written about the development cycle. Some propose a "waterfall" method,
in which designers determine what the program should do; architects determine how the program will
be built, what classes will be used, and so forth; and then programmers implement the design and
architecture. By the time the design and architecture is given to the programmer, it is complete; all the
programmer needs to do is implement the required functionality.
Even if the waterfall method worked, it would probably be a poor method for writing good programs.
As the programmer proceeds, there is a necessary and natural feedback between what has been written
so far and what remains to be done. While it is true that good C++ programs are designed in great
detail before a line of code is written, it is not true that that design remains unchanged throughout the
cycle.
The amount of design that must be finished "up front," before programming begins, is a function of
the size of the program. A highly complex effort, involving dozens of programmers working for many
months, will require a more fully articulated architecture than a quick-and-dirty utility written in one
day by a single programmer.
This chapter will focus on the design of large, complex programs which will be expanded and
enhanced over many years. Many programmers enjoy working at the bleeding edge of technology;
they tend to write programs whose complexity pushes at the limits of their tools and understanding. In
many ways, C++ was designed to extend the complexity that a programmer or team of programmers
could manage.
This chapter will examine a number of design problems from an object-oriented perspective. The goal
will be to review the analysis process, and then to understand how you apply the syntax of C++ to
implement these design objectives.
Simulating an Alarm SystemA simulation is a computer model of a part of a real-world system. There are many reasons to build a
simulation, but a good design must start with an understanding of what questions you hope the
simulation will answer.
As a starting point, examine this problem: You have been asked to simulate the alarm system for a
house. The house is a center hall colonial with four bedrooms, a finished basement, and an under-the-
house garage.
The downstairs has the following windows: three in the kitchen, four in the dining room, one in the
half-bathroom, two each in the living room and the family room, and two small windows next to the
door. All four bedrooms are upstairs, each of which has two windows except for the master bedroom,
which has four. There are two baths, each with one window. Finally, there are four half-windows in
the basement, and one window in the garage.
Normal access to the house is through the front door. Additionally, the kitchen has a sliding glass
door, and the garage has two doors for the cars and one door for easy access to the basement. There is
also a cellar door in the backyard.
All the windows and doors are alarmed, and there are panic buttons on each phone and next to the
bed. The grounds are alarmed as well, though these are carefully calibrated so that they are not set off
by small animals or birds.
There is a central alarm system in the basement, which sounds a warning chirp when the alarm has
been tripped. If the alarm is not disabled within a setable amount of time, the police are called. If a
panic button is pushed, the police are called immediately.
The alarm is also wired into the fire and smoke detectors and the sprinkler system, and the alarm
system itself is fault tolerant, has its own internal backup power supply, and is encased in a fireproof
box.
Preliminary Design
You begin by asking, "What questions might this simulation answer?" For example, you might be able
to use the simulation to answer the questions, "How long might a sensor be broken before anyone
notices?" or "Is there a way to defeat the window alarms without the police being notified?"
Once you understand the purpose of the simulation you will know what parts of the real system the
program must model. Once that is well understood, it becomes much easier to design the program
itself.
What Are the Objects?
One way to approach this problem is to set aside issues relating to the user interface and to focus onlyon the components of the "problem space." A first approximation of an object-oriented design might
be to list the objects that you need to simulate, and then to examine what these objects "know" and
"do."
New Term: The problem space is the set of problems and issues your program is trying to
solve. The solution space is the set of possible solutions to the problems.
For example, clearly you have sensors of various types, a central alarm system, buttons, wires, and
telephones. Further thought convinces you that you must also simulate rooms, perhaps floors, and
possibly groups of people such as owners and police.
The sensors can be divided into motion detectors, trip wires, sound detectors, smoke detectors, and so
forth. All of these are types of sensors, though there is no such thing as a sensor per se. This is a good
indication that sensor is an abstract data type (ADT).
As an ADT, the class sensor would provide the complete interface for all types of sensors, and each
derived type would provide the implementation. Clients of the various sensors would use them
without regard to which type of sensor they are, and they would each "do the right thing" based on
their real type.
To create a good ADT, you need to have a complete understanding of what sensors do (rather than
how they work). For example, are sensors passive devices or are they active? Do they wait for some
element to heat up, a wire to break, or a piece of caulk to melt, or do they probe their environment?
Perhaps some sensors have only a binary state (alarm state or okay), but others have a more analog
state (what is the current temperature?). The interface to the abstract data type should be sufficiently
complete to handle all the anticipated needs of the myriad derived classes.
Other Objects
The design continues in this way, teasing out the various other classes that will be required to meet the
specification. For example, if a log is to be kept, probably a timer will be needed; should the timer
poll each sensor or should each sensor file its own report periodically?
The user is going to need to be able to set up, disarm, and program the system, and so a terminal of
some sort will be required. You may want a separate object in your simulation for the alarm program
itself.
What Are the Classes?
As you solve these problems, you will begin to design your classes. For example, you already have an
indication that HeatSensor will derive from Sensor. If the sensor is to make periodic reports, it
may also derive via multiple inheritance from Timer, or it may have a timer as a member variable.The HeatSensor will probably have member functions such as CurrentTemp() and
SetTempLimit() and will probably inherit functions such as SoundAlarm() from its base class,
Sensor.
A frequent issue in object-oriented design is that of encapsulation. You could imagine a design in
which the alarm system has a setting for MaxTemp. The alarm system asks the heat sensor what the
current temperature is, compares it to the maximum temperature, and sounds the alarm if it is too hot.
One could argue that this violates the principle of encapsulation. Perhaps it would be better if the
alarm system didn't know or care what the details are of temperature analysis; arguably that should be
in the HeatSensor.
Whether or not you agree with that argument, it is the kind of decision you want to focus on during
the analysis of the problem. To continue this analysis, one could argue that only the Sensor and the
Log object should know any details of how sensor activity is logged; the Alarm object shouldn't
know or care.
Good encapsulation is marked by each class having a coherent and complete set of responsibilities,
and no other class having the same responsibilities. If the sensor is responsible for noting the current
temperature, no other class should have that responsibility.
On the other hand, other classes might help deliver the necessary functionality. For example, while it
might be the responsibility of the Sensor class to note and log the current temperature, it might
implement that responsibility by delegating to a Log object the job of actually recording the data.
Maintaining a firm division of responsibilities makes your program easier to extend and maintain.
When you decide to change the alarm system for an enhanced module, its interface to the log and to
the sensors will be narrow and well defined. Changes to the alarm system should not affect the
Sensor classes, and vice versa.
Should the HeatSensor have a ReportAlarm() function? All sensors will need the ability to
report an alarm. This is a good indication that ReportAlarm() should be a virtual method of
Sensor, and that Sensor may be an abstract base class. It is possible that HeatSensor will chain
up to Sensor's more general ReportAlarm() method; the overridden function would just fill in
the details it is uniquely qualified to supply.
How Are Alarms Reported?
When your sensors report an alarm condition, they will want to provide a lot of information to the
object that phones the police and to the log. It may well be that you'll want to create a Condition
class, whose constructor takes a number of measurements. Depending on the complexity of the
measurements, these too might be objects, or they might be simple scalar values such as integers.
It is possible that Condition objects are passed to the central Alarm object, or that Condition
objects are subclassed into Alarm objects, which themselves know how to take emergency action.
Perhaps there is no central object; instead there might be sensors, which know how to createCondition objects. Some Condition objects would know how to log themselves; others might
know how to contact the police.
A well-designed event-driven system need not have a central coordinator. One can imagine the
sensors all independently receiving and sending message objects to one another, setting parameters,
taking readings, and monitoring the house. When a fault is detected, an Alarm object is created,
which logs the problem (by sending a message to the Log object) and takes the appropriate action.
Event Loops
To simulate such an event-driven system, your program needs to create an event loop. An event loop
is typically an infinite loop such as while(1), which gets messages from the operating system
(mouse clicks, keyboard presses, and so on) and dispatches them one by one, returning to the loop
until an exit condition is satisfied. Listing 18.1 shows a rudimentary event loop.
Listing 18.1. A simple event loop.
1:
// Listing 18.1
2:
3:
#include <iostream.h>
4:
5:
class Condition
6:
{
7:
public:
8:
Condition() { }
9:
virtual ~Condition() {}
10:
virtual void Log() = 0;
11:
};
12:
13:
class Normal : public Condition
14:
{
15:
public:
16:
Normal() { Log(); }
17:
virtual ~Normal() {}
18:
virtual void Log() { cout << "Logging normal
conditions...\n"; }
19:
};
20:
21:
class Error : public Condition
22:
{
23:
public:
24:
Error() {Log();}
25:
virtual ~Error() {}
26:
virtual void Log() { cout << "Logging error!\n"; }
27:
};28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
class Alarm : public Condition
{
public:
Alarm ();
virtual
~Alarm() {}
virtual void Warn() { cout << "Warning!\n"; }
virtual void Log() { cout << "General Alarm log\n"; }
virtual void Call() = 0;
};
Alarm::Alarm()
{
Log();
Warn();
}
class FireAlarm : public Alarm
{
public:
FireAlarm(){Log();};
virtual ~FireAlarm() {}
virtual void Call() { cout<< "Calling Fire Dept.!\n"; }
virtual void Log() { cout << "Logging fire call.\n"; }
};
int main()
{
int input;
int okay = 1;
Condition * pCondition;
while (okay)
{
cout << "(0)Quit (1)Normal (2)Fire: ";
cin >> input;
okay = input;
switch (input)
{
case 0: break;
case 1:
pCondition = new Normal;
delete pCondition;
break;
case 2:
pCondition = new FireAlarm;
delete pCondition;74:
75:
76:
77:
78:
79:
80:
81:
82:
83: }
break;
default:
pCondition = new Error;
delete pCondition;
okay = 0;
break;
}
}
return 0;
Output: (0)Quit (1)Normal (2)Fire: 1
Logging normal conditions...
(0)Quit (1)Normal (2)Fire: 2
General Alarm log
Warning!
Logging fire call.
(0)Quit (1)Normal (2)Fire: 0
Analysis: The simple loop created on lines 59-80 allows the user to enter input simulating a normal
report from a sensor and a report of a fire. Note that the effect of this report is to spawn a
Condition object whose constructor calls various member functions.
Calling virtual member functions from a constructor can cause confusing results if you are not
mindful of the order of construction of objects. For example, when the FireAlarm object is created
on line 72, the order of construction is Condition, Alarm, FireAlarm. The Alarm constructor
calls Log, but it is Alarm's Log(), not FireAlarm's, that is invoked, despite Log() being
declared virtual. This is because at the time Alarm's constructor runs, there is no FireAlarm
object. Later, when FireAlarm itself is constructed, its constructor calls Log() again, and this time
FireAlarm::Log() is called.
PostMaster
Here's another problem on which to practice your object-oriented analysis: You have been hired by
Acme Software, Inc., to start a new software project and to hire a team of C++ programmers to
implement your program. Jim Grandiose, vice-president of new product development, is your new
boss. He wants you to design and build PostMaster, a utility to read electronic mail from various
unrelated e-mail providers. The potential customer is a businessperson who uses more than one e-mail
product, for example Interchange, CompuServe, Prodigy, America Online, Delphi, Internet Mail,
Lotus Notes, AppleMail, cc:Mail, and so forth.
The customer will be able to "teach" PostMaster how to dial up or otherwise connect to each of the e-
mail providers, and PostMaster will get the mail and then present it in a uniform manner, allowing the
customer to organize the mail, reply, forward letters among services, and so forth.PostMasterProfessional, to be developed as version 2 of PostMaster, is already anticipated. It will add
an Administrative Assistant mode, which will allow the user to designate another person to read some
or all of the mail, to handle routine correspondence, and so forth. There is also speculation in the
marketing department that an artificial intelligence component might add the capability for
PostMaster to pre-sort and prioritize the mail based on subject and content keywords and associations.
Other enhancements have been talked about, including the ability to handle not only mail but
discussion groups such as Interchange discussions, CompuServe forums, Internet newsgroups, and so
forth. It is obvious that Acme has great hopes for PostMaster, and you are under severe time
constraints to bring it to market, though you seem to have a nearly unlimited budget.
Measure Twice, Cut Once
You set up your office and order your equipment, and then your first order of business is to get a good
specification for the product. After examining the market, you decide to recommend that development
be focused on a single platform, and you set out to decide among DOS; UNIX; the Macintosh; and
Windows, Windows NT, and OS/2.
You have many painful meetings with Jim Grandiose, and it becomes clear that there is no right
choice, and so you decide to separate the front end, that is the user interface or UI, from the back end,
the communications and database part. To get things going quickly, you decide to write for DOS first,
followed by Win32, the Mac, and then UNIX and OS/2.
This simple decision has enormous ramifications for your project. It quickly becomes obvious that
you will need a class library or a series of libraries to handle memory management, the various user
interfaces, and perhaps also the communications and database components.
Mr. Grandiose believes strongly that projects live or die by having one person with a clear vision, so
he asks that you do the initial architectural analysis and design before hiring any programmers. You
set out to analyze the problem.
Divide and Conquer
It quickly becomes obvious that you really have more than one problem to solve. You divide the
project into these significant sub-projects:
1. Communications: the ability for the software to dial into the e-mail provider via modem, or
to connect over a network.
2. Database: the ability to store data and to retrieve it from disk.
3. E-mail: the ability to read various e-mail formats and to write new messages to each system.
4. Editing: providing state-of-the-art editors for the creation and manipulation of messages.5. Platform issues: the various UI issues presented by each platform (DOS, Macintosh, and so
on).
6. Extensibility: planning for growth and enhancements.
7. Organization and scheduling: managing the various developers and their code
interdependencies. Each group must devise and publish schedules, and then be able to plan
accordingly. Senior management and marketing need to know when the product will be ready.
You decide to hire a manager to handle item 7, organization and scheduling. You then hire senior
developers to help you analyze and design, and then to manage the implementation of the remaining
areas. These senior developers will create the following teams:
1. Communications: responsible for both dial-up and network communications. They deal with
packets, streams, and bits, rather than with e-mail messages per se.
2. Message format: responsible for converting messages from each e-mail provider to a
canonical form (PostMaster standard) and back. It is also their job to write these messages to
disk and to get them back off the disk as needed.
3. Message editors: This group is responsible for the entire UI of the product, on each platform.
It is their job to ensure that the interface between the back end and the front end of the product
is sufficiently narrow that extending the product to other platforms does not require duplication
of code.
Message Format
You decide to focus on the message format first, setting aside the issues relating to communications
and user interface. These will follow once you understand more fully what it is you are dealing with.
There is little sense in worrying about how to present the information to the user until you understand
what information you are dealing with.
An examination of the various e-mail formats reveals that they have many things in common, despite
their various differences. Each e-mail message has a point of origination, a destination, and a creation
date. Nearly all such messages have a title or subject line and a body which may consist of simple
text, rich text (text with formatting), graphics, and perhaps even sound or other fancy additions. Most
such e-mail services also support attachments, so that users can send programs and other files.
You confirm your early decision that you will read each mail message out of its original format and
into PostMaster format. This way you will only have to store one record format, and writing to and
reading from the disk will be simplified. You also decide to separate the "header" information (sender,
recipient, date, title, and so on) from the body of the message. Often the user will want to scan the
headers without necessarily reading the contents of all the messages. You anticipate that a time may
come when users will want to download only the headers from the message provider, without getting
the text at all, but for now you intend that version 1 of PostMaster will always get the full message,
although it may not display it to the user.Initial Class Design
This analysis of the messages leads you to design the Message class. In anticipation of extending the
program to non-e-mail messages, you derive EmailMessage from the abstract base Message.
From EmailMessage you derive PostMasterMessage, InterchangeMessage,
CISMessage, ProdigyMessage, and so forth.
Messages are a natural choice for objects in a program handling mail messages, but finding all the
right objects in a complex system is the single greatest challenge of object-oriented programming. In
some cases, such as with messages, the primary objects seem to "fall out" of your understanding of the
problem. More often, however, you have to think long and hard about what you are trying to
accomplish to find the right objects.
Don't despair. Most designs are not perfect the first time. A good starting point is to describe the
problem out loud. Make a list of all the nouns and verbs you use when describing the project. The
nouns are good candidates for objects. The verbs might be the methods of those objects (or they may
be objects in their own right). This is not a foolproof method, but it is a good technique to use when
getting started on your design.
That was the easy part. Now the question arises, "Should the message header be a separate class from
the body?" If so, do you need parallel hierarchies, CompuServeBody and CompuServeHeader,
as well as ProdigyBody and ProdigyHeader?
Parallel hierarchies are often a warning sign of a bad design. It is a common error in object-oriented
design to have a set of objects in one hierarchy, and a matching set of "managers" of those objects in
another. The burden of keeping these hierarchies up-to-date and in sync with each other soon becomes
overwhelming: a classic maintenance nightmare.
There are no hard-and-fast rules, of course, and at times such parallel hierarchies are the most efficient
way to solve a particular problem. Nonetheless, if you see your design moving in this direction, you
should rethink the problem; there may be a more elegant solution available.
When the messages arrive from the e-mail provider, they will not necessarily be separated into header
and body; many will be one large stream of data, which your program will have to disentangle.
Perhaps your hierarchy should reflect that idea directly.
Further reflection on the tasks at hand leads you to try to list the properties of these messages, with an
eye towards introducing capabilities and data storage at the right level of abstraction. Listing
properties of your objects is a good way to find the data members, as well as to "shake out" other
objects you might need.
Mail messages will need to be stored, as will the user's preferences, phone numbers, and so forth.
Storage clearly needs to be high up in the hierarchy. Should the mail messages necessarily share a
base class with the preferences?Rooted Hierarchies Versus Non-Rooted Hierarchies
There are two overall approaches to inheritance hierarchies: you can have all, or nearly all, of your
classes descend from a common root class, or you can have more than one inheritance hierarchy. An
advantage of a common root class is that you often can avoid multiple inheritance; a disadvantage is
that many times implementation will percolate up into the base class.
New Term: A set of classes is rooted if all share a common ancestor. Non-rooted hierarchies
do not all share a common base class.
Because you know that your product will be developed on many platforms, and because multiple
inheritance is complex and not necessarily well supported by all compilers on all platforms, your first
decision is to use a rooted hierarchy and single inheritance. You decide to identify those places where
multiple inheritance might be used in the future, and to design so that breaking apart the hierarchy and
adding multiple inheritance at a later time need not be traumatic to your entire design.
You decide to prefix the name of all of your internal classes with the letter p so that you can easily
and quickly tell which classes are yours and which are from other libraries. On Day 21, "What's
Next," you'll learn about name spaces, which can reinforce this idea, but for now the initial will do
nicely.
Your root class will be pObject; virtually every class you create will descend from this object.
pObject itself will be kept fairly simple; only that data which absolutely every item shares will
appear in this class.
If you want a rooted hierarchy, you'll want to give the root class a fairly generic name (like
pObject) and few capabilities. The point of a root object is to be able to create collections of all its
descendants and refer to them as instances of pObject. The trade-off is that rooted hierarchies often
percolate interface up into the root class. You will pay the price; by percolating these interfaces up
into the root object, other descendants will have interfaces that are inappropriate to their design. The
only good solution to this problem, in single inheritance, is to use templates. Templates are discussed
tomorrow.
The next likely candidates for top of the hierarchy status are pStored and pWired. pStored
objects are saved to disk at various times (for example when the program is not in use), and pWired
objects are sent over the modem or network. Because nearly all of your objects will need to be stored
to disk, it makes sense to push this functionality up high in the hierarchy. Because all the objects that
are sent over the modem must be stored, but not all stored objects must be sent over the wire, it makes
sense to derive pWired from pStored.
Each derived class acquires all the knowledge (data) and functionality (methods) of its base class, and
each should add one discrete additional ability. Thus, pWired may add various methods, but all arein service of adding the ability to be transferred over the modem.
It is possible that all wired objects are stored, or that all stored objects are wired, or that neither of
these statements is true. If only some wired objects are stored, and only some stored objects are wired,
you will be forced either to use multiple inheritance or to "hack around" the problem. A potential
"hack" for such a situation would be to inherit, for example, Wired from Stored, and then for those
objects that are sent via modem, but are never stored, to make the stored methods do nothing or return
an error.
In fact, you realize that some stored objects clearly are not wired: for example, user preferences. All
wired objects, however, are stored, and so your inheritance hierarchy so far is as reflected in Figure
18.1.
Figure 18.1. Initial inheritance hierarchy.
Designing the Interfaces
It is important at this stage of designing your product to avoid being concerned with implementation.
You want to focus all of your energies on designing a clean interface among the classes and then
delineating what data and methods each class will need.
It is often a good idea to have a solid understanding of the base classes before trying to design the
more derived classes, so you decide to focus on pObject, pStored, and pWired.
The root class, pObject, will only have the data and methods that are common to everything on
your system. Perhaps every object should have a unique identification number. You could create pID
(PostMaster ID) and make that a member of pObject; but first you must ask yourself, "Does any
object that is not stored and not wired need such a number?" That begs the question, "Are there any
objects that are not stored, but that are part of this hierarchy?"
If there are no such objects, you may want to consider collapsing pObject and pStored into one
class; after all, if all objects are stored, what is the point of the differentiation? Thinking this through,
you realize that there may be some objects, such as address objects, that it would be beneficial to
derive from pObject, but that will never be stored on their own; if they are stored, they will be as
part of some other object.
That says that for now having a separate pObject class would be useful. One can imagine that there
will be an address book that would be a collection of pAddress objects, and while no pAddress
will ever be stored on its own, there would be utility in having each one have its own unique
identification number. You tentatively assign pID to pObject, and this means that pObject, at a
minimum, will look like this:
class pObject
{
public:pObject();
~pObject();
pID GetID()const;
void SetID();
private:
pID itsID;
}
There are a number of things to note about this class declaration. First, this class is not declared to
derive from any other; this is your root class. Second, there is no attempt to show implementation,
even for methods such as GetID() that are likely to have inline implementation when you are done.
Third, const methods are already identified; this is part of the interface, not the implementation.
Finally, a new data type is implied: pID. Defining pID as a type, rather than using, for example,
unsigned long, puts greater flexibility into your design.
If it turns out that you don't need an unsigned long, or that an unsigned long is not
sufficiently large, you can modify pID. That modification will affect every place pID is used, and
you won't have to track down and edit every file with a pID in it.
For now, you will use typedef to declare pID to be ULONG, which in turn you will declare to be
unsigned long. This raises the question: Where do these declarations go?
When programming a large project, an overall design of the files is needed. A standard approach, one
which you will follow for this project, is that each class appears in its own header file, and the
implementation for the class methods appears in an associated CPP file. Thus, you will have a file
called OBJECT.HPP and another called OBJECT.CPP. You anticipate having other files such as
MSG.HPP and MSG.CPP, with the declaration of pMessage and the implementation of its methods,
respectively.
NOTE: Buy it or write it? One question that you will confront throughout the design
phase of your program is which routines might you buy and which must you write
yourself. It is entirely possible that you can take advantage of existing commercial
libraries to solve some or all of your communications issues. Licensing fees and other
non-technical concerns must also be resolved. It is often advantageous to purchase such
a library, and to focus your energies on your specific program, rather than to "reinvent
the wheel" about secondary technical issues. You might even want to consider
purchasing libraries that were not necessarily intended for use with C++, if they can
provide fundamental functionality you'd otherwise have to engineer yourself. This can
be instrumental in helping you hit your deadlines.
Building a PrototypeFor a project as large as PostMaster, it is unlikely that your initial design will be complete and perfect.
It would be easy to become overwhelmed by the sheer scale of the problem, and trying to create all
the classes and to complete their interface before writing a line of working code is a recipe for
disaster.
There are a number of good reasons to try out your design on a prototype--a quick-and-dirty working
example of your core ideas. There are a number of different types of prototypes, however, each
meeting different needs.
An interface design prototype provides the chance to test the look and feel of your product with
potential users.
A functionality prototype might be designed that does not have the final user interface, but allows
users to try out various features, such as forwarding messages or attaching files without worrying
about the final interface.
Finally, an architecture prototype might be designed to give you a chance to develop a smaller version
of the program and to assess how easily your design decisions will "scale up," as the program is
fleshed out.
It is imperative to keep your prototyping goals clear. Are you examining the user interface,
experimenting with functionality, or building a scale model of your final product? A good architecture
prototype makes a poor user interface prototype, and vice versa.
It is also important to keep an eye on over-engineering the prototype, or becoming so concerned with
the investment you've made in the prototype that you are reluctant to tear the code down and redesign
as you progress.
The 80/80 Rule
A good design rule of thumb at this stage is to design for those things that 80 percent of the people
want to do 80 percent of the time, and to set aside your concerns about the remaining 20 percent. The
"boundary conditions" will need to be addressed sooner or later, but the core of your design should
focus on the 80/80.
In the face of this, you might decide to start by designing the principal classes, setting aside the need
for the secondary classes. Further, when you identify multiple classes that will have similar designs
with only minor refinements, you might choose to pick one representative class and focus on that,
leaving until later the design and implementation of its close cousins.
NOTE: There is another rule, the 80/20 rule, which states that "the first 20% of your
program will take 80% of your time to code, and the remaining 80% of your program
will take the other 80% of your time!"Designing the PostMasterMessage Class
In keeping with these considerations, you decide to focus on PostMasterMessage. This is the
class that is most under your direct control.
As part of its interface, PostMasterMessage will need to talk with other types of messages, of
course. You hope to be able to work closely with the other message providers and to get their message
format specifications, but for now you can make some smart guesses just by observing what is sent to
your computer as you use their services.
In any case, you know that every PostMasterMessage will have a sender, a recipient, a date, and
a subject, as well as the body of the message and perhaps attached files. This tells you that you'll need
accessor methods for each of these attributes, as well as methods to report on the size of the attached
files, the size of the messages, and so forth.
Some of the services to which you will connect will use rich text--that is, text with formatting
instructions to set the font, character size, and attributes, such as bold and italic. Other services do not
support these attributes, and those that do may or may not use their own proprietary scheme for
managing rich text. Your class will need conversion methods for turning rich text into plain ASCII,
and perhaps for turning other formats into PostMaster formats.
Application Program Interface
An Application Program Interface (API) is a set of documentation and routines for using a service.
Many of the mail providers will give you an API so that PostMaster mail will be able to take
advantage of their more advanced features, such as rich text and embedding files. PostMaster will also
want to publish its own API so that other providers can plan for working with PostMaster in the
future.
Your PostMasterMessage class will want to have a well-designed public interface, and the
conversion functions will be a principal component of PostMaster's API. Listing 18.2 illustrates what
PostMasterMessage's interface looks like so far.
Listing 18.2. PostMasterMessages interface
1:
2:
3:
4:
5:
6:
7:
8:
class PostMasterMessage : public MailMessage
{
public:
PostMasterMessage();
PostMasterMessage(
pAddress Sender,
pAddress Recipient,
pString Subject,9:
pDate creationDate);
10:
11:
// other constructors here
12:
// remember to include copy constructor
13:
// as well as constructor from storage
14:
// and constructor from wire format
15:
// Also include constructors from other formats
16:
~PostMasterMessage();
17:
pAddress& GetSender() const;
18:
void SetSender(pAddress&);
19:
// other member accessors
20:
21:
// operator methods here, including operator equals
22:
// and conversion routines to turn PostMaster messages
23:
// into messages of other formats.
24:
25:
private:
26:
pAddress itsSender;
27:
pAddress itsRecipient;
28:
pString itsSubject;
29:
pDate itsCreationDate;
30:
pDate itsLastModDate;
31:
pDate itsReceiptDate;
32:
pDate itsFirstReadDate;
33:
pDate itsLastReadDate;
34: };
Output: None.
Analysis: Class PostMasterMessage is declared to derive from MailMessage. A number of
constructors will be provided, facilitating the creation of PostMasterMessages from other types
of mail messages.
A number of accessor methods are anticipated for reading and setting the various member data, as
well as operators for turning all or part of this message into other message formats. You anticipate
storing these messages to disk and reading them from the wire, so accessor methods are needed for
those purposes as well.
Programming in Large Groups
Even this preliminary architecture is enough to indicate how the various development groups ought to
proceed. The communications group can go ahead and start work on the communications back end,
negotiating a narrow interface with the message format group.
The message format group will probably lay out the general interface to the Message classes, as wasbegun above, and then will turn its attention to the question of how to write data to the disk and read it
back. Once this disk interface is well understood, they will be in a good position to negotiate the
interface to the communications layer.
The message editors will be tempted to create editors with an intimate knowledge of the internals of
the Message class, but this would be a bad design mistake. They too must negotiate a very narrow
interface to the Message class; message editor objects should know very little about the internal
structure of messages.
Ongoing Design Considerations
As the project continues, you will repeatedly confront this basic design issue: In which class should
you put a given set of functionality (or information)? Should the Message class have this function,
or should the Address class? Should the editor store this information, or should the message store it
itself?
Your classes should operate on a "need to know" basis, much like secret agents. They shouldn't share
any more knowledge than is absolutely necessary.
Design Decisions
As you progress with your program, you will face hundreds of design issues. They will range from the
more global questions, "What do we want this to do?" to the more specific, "How do we make this
work?"
While the details of your implementation won't be finalized until you ship the code, and some of the
interfaces will continue to shift and change as you work, you must ensure that your design is well
understood early in the process. It is imperative that you know what you are trying to build before you
write the code. The single most frequent cause of software dying on the vine must be that there was
not sufficient agreement early enough in the process about what was being built.
Decisions, Decisions
To get a feel for what the design process is like, examine this question, "What will be on the menu?"
For PostMaster, the first choice is probably "new mail message," and this immediately raises another
design issue: When the user presses New Message, what happens? Does an editor get created,
which in turn creates a mail message, or does a new mail message get created, which then creates the
editor?
The command you are working with is "new mail message," so creating a new mail message seems
like the obvious thing to do. But what happens if the user hits Cancel after starting to write the
message? Perhaps it would be cleaner to first create the editor and have it create (and own) the new
message.The problem with this approach is that the editor will need to act differently if it is creating a message
than if it is editing the message, whereas if the message is created first and then handed to the editor,
only one set of code need exist: Everything is an edit of an existing message.
If a message is created first, who creates it? Is it created by the menu command code? If so, does the
menu also tell the message to edit itself, or is this part of the constructor method of the message?
It makes sense for the constructor to do this at first glance; after all, every time you create a message
you'll probably want to edit it. Nonetheless, this is not a good design idea. First, it is very possible that
the premise is wrong: You may well create "canned" messages (that is, error messages mailed to the
system operator) that are not put into an editor. Second, and more important, a constructor's job is to
create an object; it should do no more and no less than that. Once a mail message is created, the
constructor's job is done; adding a call to the edit method just confuses the role of the constructor and
makes the mail message vulnerable to failures in the editor.
What is worse, the edit method will call another class, the editor, causing its constructor to be called.
Yet the editor is not a base class of the message, nor is it contained within the message; it would be
unfortunate if the construction of the message depended on successful construction of the editor.
Finally, you won't want to call the editor at all if the message can't be successfully created; yet
successful creation would, in this scenario, depend on calling the editor! Clearly you want to fully
return from the message's constructor before calling Message::Edit().
DO look for objects that arise naturally out of your design. DO redesign as your
understanding of the problem space improves. DON'T share more information among
the classes than is absolutely necessary. DO look for opportunities to take advantage of
C++'s polymorphism.
Working with Driver Programs
One approach to surfacing design issues is to create a driver program early in the process. For
example, the driver program for PostMaster might offer a very simple menu, which will create
PostMasterMessage objects, manipulate them, and otherwise exercise some of the design.
New Term: A driver program is a function that exists only to demonstrate or test other
functions.
Listing 18.3 illustrates a somewhat more robust definition of the PostMasterMessage class and a
simple driver program.Listing 18.3. A driver program for PostMasterMessage.
1:
#include <iostream.h>
2:
#include <string.h>
3:
4:
typedef unsigned long pDate;
5:
enum SERVICE
6:
{ PostMaster, Interchange, CompuServe, Prodigy, AOL,
Internet };
7:
class String
8:
{
9:
public:
10:
// constructors
11:
String();
12:
String(const char *const);
13:
String(const String &);
14:
~String();
15:
16:
// overloaded operators
17:
char & operator[](int offset);
18:
char operator[](int offset) const;
19:
String operator+(const String&);
20:
void operator+=(const String&);
21:
String & operator= (const String &);
22:
friend ostream& operator<<
23:
( ostream& theStream,String& theString);
24:
// General accessors
25:
int GetLen()const { return itsLen; }
26:
const char * GetString() const { return itsString; }
27:
// static int ConstructorCount;
28:
private:
29:
String (int);
// private constructor
30:
char * itsString;
31:
unsigned short itsLen;
32:
33:
};
34:
35:
// default constructor creates string of 0 bytes
36:
String::String()
37:
{
38:
itsString = new char[1];
39:
itsString[0] = `\0';
40:
itsLen=0;
41:
// cout << "\tDefault string constructor\n";
42:
// ConstructorCount++;
43:
}44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
// private (helper) constructor, used only by
// class methods for creating a new string of
// required size. Null filled.
String::String(int len)
{
itsString = new char[len+1];
for (int i = 0; i<=len; i++)
itsString[1] = `\0';
itsLen=len;
// cout << "\tString(int) constructor\n";
// ConstructorCount++;
}
// Converts a character array to a String
String::String(const char * const cString)
{
itsLen = strlen(cString);
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen; i++)
itsString[i] = cString[i];
itsString[itsLen]='\0';
// cout << "\tString(char*) constructor\n";
// ConstructorCount++;
}
// copy constructor
String::String (const String & rhs)
{
itsLen=rhs.GetLen();
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen;i++)
itsString[i] = rhs[i];
itsString[itsLen] = `\0';
// cout << "\tString(String&) constructor\n";
// ConstructorCount++;
}
// destructor, frees allocated memory
String::~String ()
{
delete [] itsString;
itsLen = 0;
// cout << "\tString destructor\n";
}90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
// operator equals, frees existing memory
// then copies string and size
String& String::operator=(const String & rhs)
{
if (this == &rhs)
return *this;
delete [] itsString;
itsLen=rhs.GetLen();
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen;i++)
itsString[i] = rhs[i];
itsString[itsLen] = `\0';
return *this;
// cout << "\tString operator=\n";
}
//non constant offset operator, returns
// reference to character so it can be
// changed!
char & String::operator[](int offset)
{
if (offset > itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
}
// constant offset operator for use
// on const objects (see copy constructor!)
char String::operator[](int offset) const
{
if (offset > itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
}
// creates a new string by adding current
// string to rhs
String String::operator+(const String& rhs)
{
int totalLen = itsLen + rhs.GetLen();
int i,j;
String temp(totalLen);
for ( i = 0; i<itsLen; i++)
temp[i] = itsString[i];136:
for ( j = 0; j<rhs.GetLen(); j++, i++)
137:
temp[i] = rhs[j];
138:
temp[totalLen]='\0';
139:
return temp;
140:
}
141:
142:
void String::operator+=(const String& rhs)
143:
{
144:
unsigned short rhsLen = rhs.GetLen();
145:
unsigned short totalLen = itsLen + rhsLen;
146:
String temp(totalLen);
147:
for (int i = 0; i<itsLen; i++)
148:
temp[i] = itsString[i];
149:
for (int j = 0; j<rhs.GetLen(); j++, i++)
150:
temp[i] = rhs[i-itsLen];
151:
temp[totalLen]='\0';
152:
*this = temp;
153:
}
154:
155:
// int String::ConstructorCount = 0;
156:
157:
ostream& operator<<( ostream& theStream,String& theString)
158:
{
159:
theStream << theString.GetString();
160:
return theStream;
161:
}
162:
163:
class pAddress
164:
{
165:
public:
166:
pAddress(SERVICE theService,
167:
const String& theAddress,
168:
const String& theDisplay):
169:
itsService(theService),
170:
itsAddressString(theAddress),
171:
itsDisplayString(theDisplay)
172:
{}
173:
// pAddress(String, String);
174:
// pAddress();
175:
// pAddress (const pAddress&);
176:
~pAddress(){}
177:
friend ostream& operator<<( ostream& theStream, pAddress&
theAddress);
178:
String& GetDisplayString() { return itsDisplayString; }
179:
private:
180:
SERVICE itsService;181:
String itsAddressString;
182:
String itsDisplayString;
183:
};
184:
185:
ostream& operator<<( ostream& theStream, pAddress&
theAddress)
186:
{
187:
theStream << theAddress.GetDisplayString();
188:
return theStream;
189:
}
190:
191:
class PostMasterMessage
192:
{
193:
public:
194:
// PostMasterMessage();
195:
196:
PostMasterMessage(const pAddress& Sender,
197:
const pAddress& Recipient,
198:
const String& Subject,
199:
const pDate& creationDate);
200:
201:
// other constructors here
202:
// remember to include copy constructor
203:
// as well as constructor from storage
204:
// and constructor from wire format
205:
// Also include constructors from other formats
206:
~PostMasterMessage(){}
207:
208:
void Edit(); // invokes editor on this message
209:
210:
pAddress& GetSender() const { return itsSender; }
211:
pAddress& GetRecipient() const { return itsRecipient; }
212:
String& GetSubject() const { return itsSubject; }
213:
// void SetSender(pAddress& );
214:
// other member accessors
215:
216:
// operator methods here, including operator equals
217:
// and conversion routines to turn PostMaster messages
218:
// into messages of other formats.
219:
220:
private:
221:
pAddress itsSender;
222:
pAddress itsRecipient;
223:
String itsSubject;
224:
pDate itsCreationDate;
225:
pDate itsLastModDate;226:
pDate itsReceiptDate;
227:
pDate itsFirstReadDate;
228:
pDate itsLastReadDate;
229:
};
230:
231:
PostMasterMessage::PostMasterMessage(
232:
const pAddress& Sender,
233:
const pAddress& Recipient,
234:
const String& Subject,
235:
const pDate& creationDate):
236:
itsSender(Sender),
237:
itsRecipient(Recipient),
238:
itsSubject(Subject),
239:
itsCreationDate(creationDate),
240:
itsLastModDate(creationDate),
241:
itsFirstReadDate(0),
242:
itsLastReadDate(0)
243:
{
244:
cout << "Post Master Message created. \n";
245:
}
246:
247:
void PostMasterMessage::Edit()
248:
{
249:
cout << "PostMasterMessage edit function called\n";
250:
}
251:
252:
253:
int main()
254:
{
255:
pAddress Sender(PostMaster, "jliberty@PostMaster", "Jesse
Liberty");
256:
pAddress Recipient(PostMaster, "sl@PostMaster","Stacey
Liberty");
257:
PostMasterMessage PostMessage(Sender, Recipient, "Saying
Hello", 0);
258:
cout << "Message review... \n";
259:
cout << "From:\t\t" << PostMessage.GetSender() << endl;
260:
cout << "To:\t\t" << PostMessage.GetRecipient() << endl;
261:
cout << "Subject:\t" << PostMessage.GetSubject() << endl;
262:
return 0;
263: }
WARNING: If you receive a "can't convert" error, remove the const keywords from
lines 210-212.Output: Post Master Message created.
Message review...
From:
Jesse Liberty
To:
Stacey Liberty
Subject:
Saying Hello
Analysis: On line 4, pDate is type-defined to be an unsigned long. It is not uncommon for
dates to be stored as a long integer (typically as the number of seconds since an arbitrary starting
date such as January 1, 1900). In this program, this is a placeholder; you would expect to
eventually turn pDate into a real class.
On line 5, an enumerated constant, SERVICE, is defined to allow the Address objects to keep track
of what type of address they are, including PostMaster, CompuServe, and so forth.
Lines 7-161 represent the interface to and implementation of String, along much the same lines as
you have seen in previous chapters. The String class is used for a number of member variables in
all of the Message classes and various other classes used by messages, and as such it is pivotal in
your program. A full and robust String class will be essential to making your Message classes
complete.
On lines 162-183, the pAddress class is declared. This represents only the fundamental
functionality of this class, and you would expect to flesh this out once your program is better
understood. These objects represent essential components in every message: both the sender's address
and that of the recipient. A fully functional pAddress object will be able to handle forwarding
messages, replies, and so forth.
It is the pAddress object's job to keep track of the display string as well as the internal routing string
for its service. One open question for your design is whether there should be one pAddress object or
if this should be subclassed for each service type. For now, the service is tracked as an enumerated
constant, which is a member variable of each pAddress object.
Lines 191-229 show the interface to the PostMasterMessage class. In this particular listing, this
class stands on its own, but very soon you'll want to make this part of its inheritance hierarchy. When
you do redesign this to inherit from Message, some of the member variables may move into the base
classes, and some of the member functions may become overrides of base class methods.
A variety of other constructors, accessor functions, and other member functions will be required to
make this class fully functional. Note that what this listing illustrates is that your class does not have
to be 100 percent complete before you can write a simple driver program to test some of your
assumptions.
On lines 247-250, the Edit() function is "stubbed out" in just enough detail to indicate where the
editing functionality will be put once this class is fully operational.Lines 253-263 represent the driver program. Currently this program does nothing more than exercise a
few of the accessor functions and the operator<< overload. Nonetheless, this gives you the starting
point for experimenting with PostMasterMessages and a framework within which you can
modify these classes and examine the impact.
Summary
Today you saw a review of how to bring together many of the elements of C++ syntax and apply them
to object-oriented analysis, design, and programming. The development cycle is not a linear
progression from clean analysis through design and culminating in programming; rather, it is cyclical.
The first phase is typically analysis of the problem, with the results of that analysis forming the basis
for the preliminary design.
Once a preliminary design is complete, programming can begin, but the lessons learned during the
programming phase are fed back into the analysis and design. As programming progresses, testing and
then debugging begins. The cycle continues, never really ending; although discrete points are reached,
at which time it is appropriate to ship the product.
When analyzing a large problem from an object-oriented viewpoint, the interacting parts of the
problem are often the objects of the preliminary design. The designer keeps an eye out for process,
hoping to encapsulate discrete activities into objects whenever possible.
A class hierarchy must be designed, and fundamental relationships among the interacting parts must
be established. The preliminary design is not meant to be final, and functionality will migrate among
objects as the design solidifies.
It is a principal goal of object-oriented analysis to hide as much of the data and implementation as
possible and to build discrete objects that have a narrow and well-defined interface. The clients of
your object should not need to understand the implementation details of how they fulfill their
responsibilities.
Q&A
Q. In what way is object-oriented analysis and design fundamentally different from other
approaches?
A. Prior to the development of these object-oriented techniques, analysts and programmers
tended to think of programs as functions that acted on data. Object-oriented programming
focuses on the integrated data and functionality as discrete units that have both knowledge
(data) and capabilities (functions). Procedural programs, on the other hand, focus on functions
and how they act on data. It has been said that Pascal and C programs are collections of
procedures and C++ programs are collections of classes.
Q. Is object-oriented programming finally the silver bullet that will solve all
programming problems?A. No, it was never intended to be. For large, complex problems, however, object-oriented
analysis, design, and programming can provide the programmer with tools to manage
enormous complexity in ways that were previously impossible.
Q. Is C++ the perfect object-oriented language?
A. C++ has a number of advantages and disadvantages when compared with alternative object-
oriented programming languages, but it has one killer advantage above and beyond all others:
It is the single most popular object-oriented programming language on the face of the Earth.
Frankly, most programmers don't decide to program in C++ after an exhaustive analysis of the
alternative object-oriented programming languages; they go where the action is, and in the
1990s the action is with C++. There are good reasons for that; C++ has a lot to offer, but this
book exists, and I'd wager you are reading it, because C++ is the development language of
choice at so many corporations.
Q. Where can I learn more about object-oriented analysis and design?
A. Day 21 offers some further suggestions, but it is my personal opinion that there are a
number of terrific object-oriented analysis and design books available. My personal favorites
include:
Object-Oriented Analysis and Design with Applications by Grady Booch (2nd Edition).
Published by Benjamin/Cummings Publishing Company, Inc., ISBN: 0-8053-5340-2.
Object-Oriented Modeling and Design by Rumbaugh, Blaha, Premerlani, Eddy, and Lorenson.
Published by Prentice-Hall, ISBN 0-13-629841-9.
There are many other excellent alternatives. Also be sure to join one of the newsgroups or
conferences on the Internet, Interchange, or one of the alternative dial-up services.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material
covered and exercises to provide you with experience in using what you've learned. Try to answer the
quiz and exercise questions before checking the answers in Appendix D, and make sure you
understand the answers before continuing to the next chapter.
Quiz
1. What is the difference between object-oriented programming and procedural programming?
2. To what does "event-driven" refer?
3. What are the stages in the development cycle?
4. What is a rooted hierarchy?
5. What is a driver program?6. What is encapsulation?
Exercises
1. Suppose you had to simulate the intersection of Massachusetts Avenue and Vassar Street--
two typical two-lane roads, with traffic lights and crosswalks. The purpose of the simulation is
to determine if the timing of the traffic signal allows for a smooth flow of traffic.
What kinds of objects should be modeled in the simulation? What would the classes be for the
simulation?
2. Suppose the intersection from Exercise 1 were in a suburb of Boston, which has arguably
the unfriendliest streets in the United States. At any time there are three kinds of Boston
drivers:
Locals, who continue to drive through intersections after the light turns red; tourists, who drive
slowly and cautiously (in a rental car, typically); and taxis, who have a wide variation of
driving patterns, depending on the kinds of passengers in the cabs.
Also, Boston has two kinds of pedestrians: locals, who cross the street whenever they feel like
it and seldom use the crosswalk buttons; and tourists, who always use the crosswalk buttons
and only cross when the Walk/Don't Walk light permits.
Finally, Boston has bicyclists who never pay attention to stop lights.
How do these considerations change the model?
3. You are asked to design a group scheduler. The software allows you to arrange meetings
among individuals or groups and to reserve a limited number of conference rooms. Identify the
principal subsystems.
4. Design and show the interfaces to the classes in the room reservation portion of the program
discussed in Exercise 3.
What Are Templates?
At the end of Week 2, you saw how to build a PartsList object and how to use it to create a
PartsCatalog. If you want to build on the PartsList object to make a list of cats, you have a
problem: PartsList only knows about parts.
To solve this problem, you can create a List base class and derive from it the PartsList and
CatsList classes. You could then cut and paste much of the PartsList class into the new
CatsList declaration. Next week, when you want to make a list of Car objects, you would then
have to make a new class, and again you'd cut and paste.
Needless to say, this is not a satisfactory solution. Over time, the List class and its derived classes
will have to be extended. Making sure that all the changes are propagated to all the related classes
would be a nightmare.
On Day 17, one approach to parameterizing lists was demonstrated briefly--using macros and name
concatenation. Although macros do save much of the cutting and pasting, they have one killer
disadvantage: Like everything else in the preprocessor, they are not type-safe.
Templates offer the preferred method of creating parameterized lists in C++. They are an integrated
part of the language, they are type-safe, and they are very flexible.
Parameterized Types
Templates allow you to teach the compiler how to make a list of any type of thing, rather than creating
a set of type-specific lists--a PartsList is a list of parts, a CatList is a list of cats. The only way
in which they differ is the type of the thing on the list. With templates, the type of the thing on the list
becomes a parameter to the definition of the class.
A common component of virtually all C++ libraries is an array class. As you saw with Lists, it is
tedious and inefficient to create one array class for integers, another for doubles, and yet another for
an array of Animals. Templates let you declare a parameterized array class and then specify whattype of object each instance of the array will hold.
New Term: Instantiation is the act of creating a specific type from a template. The individual
classes are called instances of the template.
Parameterized templates provide you with the ability to create a general class, and pass types as
parameters to that class, in order to build specific instances.
Template Definition
You declare a parameterized Array object (a template for an array) by writing
1:
2:
3:
4:
5:
6:
7:
template <class T>
// declare the template and the parameter
class Array
// the class being parameterized
{
public:
Array();
// full class declaration here
};
The keyword template is used at the beginning of every declaration and definition of a template
class. The parameters of the template are after the keyword template. The parameters are the things
that will change with each instance. For example, in the array template shown previously, the type of
the objects stored in the array will change. One instance might store an array of integers, while
another might store an array of Animals.
In this example, the keyword class is used, followed by the identifier T. The keyword class
indicates that this parameter is a type. The identifier T is used throughout the rest of the template
definition to refer to the parameterized type. One instance of this class will substitute int everywhere
T appears, and another will substitute Cat.
To declare an int and a Cat instance of the parameterized Array class, you would write
Array<int> anIntArray;
Array<Cat> aCatArray;
The object anIntArray is of the type array of integers; the object aCatArray is of the type array
of cats. You can now use the type Array<int> anywhere you would normally use a type--as the
return value from a function, as a parameter to a function, and so forth. Listing 19.1 provides the full
declaration of this stripped-down Array template.
NOTE: Listing 19.1 is not a complete program!Listing 19.1. A template of an Array class
1: Listing 19.1 A template of an array class
2:
#include <iostream.h>
3:
const int DefaultSize = 10;
4:
5:
template <class T> // declare the template and the
parameter
6:
class Array
// the class being parameterized
7:
{
8:
public:
9:
// constructors
10:
Array(int itsSize = DefaultSize);
11:
Array(const Array &rhs);
12:
~Array() { delete [] pType; }
13:
14:
// operators
15:
Array& operator=(const Array&);
16:
T& operator[](int offSet) { return pType[offSet]; }
17:
18:
// accessors
19:
int getSize() { return itsSize; }
20:
21:
private:
22:
T *pType;
23:
int itsSize;
24: };
Output: There is no output. This is an incomplete program.
Analysis: The definition of the template begins on line 5, with the keyword template followed by
the parameter. In this case, the parameter is identified to be a type by the keyword class, and the
identifier T is used to represent the parameterized type.
From line 6 until the end of the template on line 24, the rest of the declaration is like any other class
declaration. The only difference is that wherever the type of the object would normally appear, the
identifier T is used instead. For example, operator[] would be expected to return a reference to an
object in the array, and in fact it is declared to return a reference to a T.
When an instance of an integer array is declared, the operator= that is provided to that array will
return a reference to an integer. When an instance of an Animal array is declared, the operator=provided to the Animal array will return a reference to an Animal.
Using the Name
Within the class declaration, the word Array may be used without further qualification. Elsewhere in
the program, this class will be referred to as Array<T>. For example, if you do not write the
constructor within the class declaration, you must write
template <class T>
Array<T>::Array(int size):
itsSize = size
{
pType = new T[size];
for (int i = 0; i<size; i++)
pType[i] = 0;
}
The declaration on the first line of this code fragment is required to identify the type (class T). The
template name is Array<T>, and the function name is Array(int size).
The remainder of the function is exactly the same as it would be for a non-template function. It is a
common and preferred method to get the class and its functions working as a simple declaration
before turning it into a template.
Implementing the Template
The full implementation of the Array template class requires implementation of the copy
constructor, operator=, and so forth. Listing 19.2 provides a simple driver program to exercise this
template class.
NOTE: Some older compilers do not support templates. Templates are, however, part of the
emerging C++ standard. All major compiler vendors have committed to supporting templates
in their next release, if they have not already done so. If you have an older compiler, you won't
be able to compile and run the exercises in this chapter. It's still a good idea to read through the
entire chapter, however, and return to this material when you upgrade your compiler.
Listing 19.2. The implementation of the template array.
1:
2:
3:
4:
#include <iostream.h>
const int DefaultSize = 10;5:
// declare a simple Animal class so that we can
6:
// create an array of animals
7:
8:
class Animal
9:
{
10:
public:
11:
Animal(int);
12:
Animal();
13:
~Animal() {}
14:
int GetWeight() const { return itsWeight; }
15:
void Display() const { cout << itsWeight; }
16:
private:
17:
int itsWeight;
18:
};
19:
20:
Animal::Animal(int weight):
21:
itsWeight(weight)
22:
{}
23:
24:
Animal::Animal():
25:
itsWeight(0)
26:
{}
27:
28:
29:
template <class T> // declare the template and the
parameter
30:
class Array
// the class being parameterized
31:
{
32:
public:
33:
// constructors
34:
Array(int itsSize = DefaultSize);
35:
Array(const Array &rhs);
36:
~Array() { delete [] pType; }
37:
38:
// operators
39:
Array& operator=(const Array&);
40:
T& operator[](int offSet) { return pType[offSet]; }
41:
const T& operator[](int offSet) const
42:
{ return pType[offSet]; }
43:
// accessors
44:
int GetSize() const { return itsSize; }
45:
46:
private:
47:
T *pType;
48:
int itsSize;
49:
};50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
// implementations follow...
// implement the Constructor
template <class T>
Array<T>::Array(int size = DefaultSize):
itsSize(size)
{
pType = new T[size];
for (int i = 0; i<size; i++)
pType[i] = 0;
}
// copy constructor
template <class T>
Array<T>::Array(const Array &rhs)
{
itsSize = rhs.GetSize();
pType = new T[itsSize];
for (int i = 0; i<itsSize; i++)
pType[i] = rhs[i];
}
// operator=
template <class T>
Array<T>& Array<T>::operator=(const Array &rhs)
{
if (this == &rhs)
return *this;
delete [] pType;
itsSize = rhs.GetSize();
pType = new T[itsSize];
for (int i = 0; i<itsSize; i++)
pType[i] = rhs[i];
return *this;
}
// driver program
int main()
{
Array<int> theArray;
Array<Animal> theZoo;
Animal *pAnimal;
// an array of integers
// an array of Animals
// fill the arrays
for (int i = 0; i < theArray.GetSize(); i++)96:
{
97:
theArray[i] = i*2;
98:
pAnimal = new Animal(i*3);
99:
theZoo[i] = *pAnimal;
100:
delete pAnimal;
101:
}
102:
// print the contents of the arrays
103:
for (int j = 0; j < theArray.GetSize(); j++)
104:
{
105:
cout << "theArray[" << j << "]:\t";
106:
cout << theArray[j] << "\t\t";
107:
cout << "theZoo[" << j << "]:\t";
108:
theZoo[j].Display();
109:
cout << endl;
110:
}
111:
112:
for (int k = 0; k < theArray.GetSize(); k++)
113:
delete &theZoo[j];
114:
return 0;
115: }
Output: theArray[0]:
0
theZoo[0]:
0
theArray[1]:
2
theZoo[1]:
3
theArray[2]:
4
theZoo[2]:
6
theArray[3]:
6
theZoo[3]:
9
theArray[4]:
8
theZoo[4]:
12
theArray[5]:
10
theZoo[5]:
15
theArray[6]:
12
theZoo[6]:
18
theArray[7]:
14
theZoo[7]:
21
theArray[8]:
16
theZoo[8]:
24
theArray[9]:
18
theZoo[9]:
27
Analysis: Lines 8 to 26 provide a stripped-down Animal class, created here so that there are objects
of a user-defined type to add to the array.
Line 29 declares that what follows is a template, and that the parameter to the template is a type,
designated as T. The Array class has two constructors as shown, the first of which takes a size and
defaults to the constant integer DefaultSize.
The assignment and offset operators are declared, with the latter declaring both a const and a non-
const variant. The only accessor provided is GetSize(), which returns the size of the array.
One can certainly imagine a fuller interface, and, for any serious Array program, what has been
supplied here would be inadequate. At a minimum, operators to remove elements, to expand the array,
to pack the array, and so forth would be required.
The private data consists of the size of the array and a pointer to the actual in-memory array ofobjects.
Template Functions
If you want to pass an array object to a function, you must pass a particular instance of the array, not a
template. Therefore, if SomeFunction() takes an integer array as a parameter, you may write
void SomeFunction(Array<int>&);
// ok
but you may not write
void SomeFunction(Array<T>&);
// error!
because there is no way to know what a T& is. You also may not write
void SomeFunction(Array &);
// error!
because there is no class Array--only the template and the instances.
To accomplish the more general approach, you must declare a template function.
template <class T>
void MyTemplateFunction(Array<T>&);
// ok
Here the function MyTemplateFunction() is declared to be a template function by the
declaration on the top line. Note that template functions can have any name, just as other functions
can.
Template functions can also take instances of the template, in addition to the parameterized form. The
following is an example:
template <class T>
void MyOtherFunction(Array<T>&, Array<int>&);
// ok
Note that this function takes two arrays: a parameterized array and an array of integers. The former
can be an array of any object, but the latter is always an array of integers.
Templates and Friends
Template classes can declare three types of friends:
++-
A non-template friend class or function../. A general template friend class or function.
*#' A type-specific template friend class or function.
Non-Template Friend Classes and Functions
It is possible to declare any class or function to be a friend to your template class. Each instance of the
class will treat the friend properly, as if the declaration of friendship had been made in that particular
instance. Listing 19.3 adds a trivial friend function, Intrude(), to the template definition of the
Array class, and the driver program invokes Intrude(). Because it is a friend, Intrude() can
then access the private data of the Array. Because this is not a template function, it can only be
called on Arrays of int.
NOTE: To use Listing 19.3, copy lines 1-26 of Listing 19.2 after line 1 of this listing,
and then copy lines 51-86 of Listing 19.2 after line 37 of this listing.
Listing 19.3. Non-template friend function.
1:
// Listing 19.3 - Type specific friend functions in
templates
2:
3:
template <class T> // declare the template and the
parameter
4:
class Array
// the class being parameterized
5:
{
6:
public:
7:
// constructors
8:
Array(int itsSize = DefaultSize);
9:
Array(const Array &rhs);
10:
~Array() { delete [] pType; }
11:
12:
// operators
13:
Array& operator=(const Array&);
14:
T& operator[](int offSet) { return pType[offSet]; }
15:
const T& operator[](int offSet) const
16:
{ return pType[offSet]; }
17:
// accessors
18:
int GetSize() const { return itsSize; }
19:
20:
// friend function
21:
friend void Intrude(Array<int>);
22:
23:
private:24:
T *pType;
25:
int itsSize;
26:
};
27:
28:
// friend function. Not a template, can only be used
29:
// with int arrays! Intrudes into private data.
30:
void Intrude(Array<int> theArray)
31:
{
32:
cout << "\n*** Intrude ***\n";
33:
for (int i = 0; i < theArray.itsSize; i++)
34:
cout << "i: " <<
theArray.pType[i] << endl;
35:
cout << "\n";
36:
}
37:
38:
// driver program
39:
int main()
40:
{
41:
Array<int> theArray;
// an array of integers
42:
Array<Animal> theZoo;
// an array of Animals
43:
Animal *pAnimal;
44:
45:
// fill the arrays
46:
for (int i = 0; i < theArray.GetSize(); i++)
47:
{
48:
theArray[i] = i*2;
49:
pAnimal = new Animal(i*3);
50:
theZoo[i] = *pAnimal;
51:
}
52:
53:
int j, k;
54:
for (j = 0; j < theArray.GetSize(); j++)
55:
{
56:
cout << "theZoo[" << j << "]:\t";
57:
theZoo[j].Display();
58:
cout << endl;
59:
}
60:
cout << "Now use the friend function to ";
61:
cout << "find the members of Array<int>";
62:
Intrude(theArray);
63:
63:
// return the allocated memory before the arrays are
destroyed.
64:
for (k = 0; k < theArray.GetSize(); k++)
65:
delete &theZoo[j];
66:
67:
cout << "\n\nDone.\n";68:
69: }
return 0;
Output: theZoo[0]:
0
theZoo[1]:
3
theZoo[2]:
6
theZoo[3]:
9
theZoo[4]:
12
theZoo[5]:
15
theZoo[6]:
18
theZoo[7]:
21
theZoo[8]:
24
theZoo[9]:
27
Now use the friend function to find the members of Array<int>
*** Intrude ***
i: 0
i: 2
i: 4
i: 6
i: 8
i: 10
i: 12
i: 14
i: 16
i: 18
Done.
Analysis: The declaration of the Array template has been extended to include the friend function
Intrude(). This declares that every instance of an array will consider Intrude() to be a friend
function; thus, Intrude() will have access to the private member data and functions of the array
instance.
On line 33, Intrude() accesses itsSize directly, and on line 34 it accesses pType directly. This
trivial use of these members was unnecessary because the Array class provides public accessors for
this data, but it serves to demonstrate how friend functions can be declared with templates.
General Template Friend Class or Function
It would be helpful to add a display operator to the Array class. One approach would be to declare a
display operator for each possible type of Array, but this would undermine the whole point of
having made Array a template.
What is needed is an insertion operator that works for any possible type of Array.
ostream& operator<< (ostream& Array<T>&);To make this work, we need to declare operator<< to be a template function.
template <class T> ostream& operator<< (ostream&, Array<T>&)
Now that operator<< is a template function, you need only to provide an implementation. Listing
19.4 shows the Array template extended to include this declaration and provides the implementation
for the operator<<.
NOTE: To compile this listing, copy lines 8-26 of Listing 19.2 and insert them between
lines 3 and 4. Also copy lines 51-86 of Listing 19.2 and insert them between lines 37
and 38.
Listing 19.4. Using operator ostream.
1:
#include <iostream.h>
2:
3:
const int DefaultSize = 10;
4:
5:
template <class T> // declare the template and the
parameter
6:
class Array
// the class being parameterized
7:
{
8:
public:
9:
// constructors
10:
Array(int itsSize = DefaultSize);
11:
Array(const Array &rhs);
12:
~Array() { delete [] pType; }
13:
14:
// operators
15:
Array& operator=(const Array&);
16:
T& operator[](int offSet) { return pType[offSet]; }
17:
const T& operator[](int offSet) const
18:
{ return pType[offSet]; }
19:
// accessors
20:
int GetSize() const { return itsSize; }
21:
22:
friend ostream& operator<< (ostream&, Array<T>&);
23:
24:
private:
25:
T *pType;
26:
int itsSize;
27:
};28:
29:
template <class T>
30:
ostream& operator<< (ostream& output, Array<T>& theArray)
31:
{
32:
for (int i = 0; i<theArray.GetSize(); i++)
33:
output << "[" << i << "] " << theArray[i] << endl;
return output;
34:
}
35:
36:
enum BOOL { FALSE, TRUE};
37:
38:
int main()
39:
{
40:
BOOL Stop = FALSE;
// flag for looping
41:
int offset, value;
42:
Array<int> theArray;
43:
44:
while (!Stop)
45:
{
46:
cout << "Enter an offset (0-9) ";
47:
cout << "and a value. (-1 to stop): " ;
47:
cin >> offset >> value;
48:
49:
if (offset < 0)
50:
break;
51:
52:
if (offset > 9)
53:
{
54:
cout << "***Please use values between 0 and
9.***\n";
55:
continue;
56:
}
57:
58:
theArray[offset] = value;
59:
}
60:
61:
cout << "\nHere's the entire array:\n";
62:
cout << theArray << endl;
63:
return 0;
64: }
Output: Enter an offset (0-9) and a value. (-1 to stop): 1 10
Enter an offset (0-9) and a value. (-1 to stop): 2 20
Enter an offset (0-9) and a value. (-1 to stop): 3 30
Enter an offset (0-9) and a value. (-1 to stop): 4 40
Enter an offset (0-9) and a value. (-1 to stop): 5 50Enter an offset (0-9) and a value.
Enter an offset (0-9) and a value.
Enter an offset (0-9) and a value.
Enter an offset (0-9) and a value.
Enter an offset (0-9) and a value.
***Please use values between 0 and
Enter an offset (0-9) and a value.
(-1 to
(-1 to
(-1 to
(-1 to
(-1 to
9.***
(-1 to
stop):
stop):
stop):
stop):
stop):
6 60
7 70
8 80
9 90
10 10
stop): -1 -1
Here's the entire array:
[0] 0
[1] 10
[2] 20
[3] 30
[4] 40
[5] 50
[6] 60
[7] 70
[8] 80
[9] 90
Analysis: On line 22, the function template operator<<() is declared to be a friend of the Array
class template. Because operator<<() is implemented as a template function, every instance of
this parameterized array type will automatically have an operator<<(). The implementation for
this operator starts on line 29. Every member of an array is called in turn. This only works if there is
an operator<< defined for every type of object stored in the array.
A Type-Specific Template Friend Class or Function
Although the insertion operator shown in Listing 19.4 works, it is still not quite what is needed.
Because the declaration of the friend operator on line 29 declares a template, it will work for any
instance of Array and any insertion operator taking an array of any type.
The insertion operator template shown in Listing 19.4 makes all instances of the insertion
operator<< a friend of any instance of Array, whether the instance of the insertion operator is an
integer, an Animal, or a Car. It makes no sense, however, for an Animal insertion operator to be a
friend to the insertion operator for an integer array.
What is needed is for the insertion operator for an array of int to be a friend to the Array of int
class, and for the insertion operator of an array of Animals to be a friend to the Array of animals
instance.
To accomplish this, modify the declaration of the insertion operator on line 29 of Listing 19.4, and
remove the words template <class T>. That is, change line 30 to read
friend ostream& operator<< (ostream&, Array<T>&);This will use the type (T) declared in the template of Array. Thus, the operator<< for an integer
will only work with an array of integers, and so forth.
Using Template Items
You can treat template items as you would any other type. You can pass them as parameters, either by
reference or by value, and you can return them as the return values of functions, also by value or by
reference. Listing 19.5 demonstrates how to pass template objects.
Listing 19.5. Passing template objects to and from functions.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
}
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28
29:
30:
31:
32:
33:
#include <iostream.h>
const int DefaultSize = 10;
// A trivial class for adding to arrays
class Animal
{
public:
// constructors
Animal(int);
Animal();
~Animal();
// accessors
int GetWeight() const { return itsWeight; }
void SetWeight(int theWeight) { itsWeight = theWeight;
// friend operators
friend ostream& operator<< (ostream&, const Animal&);
private:
int itsWeight;
};
// extraction operator for printing animals
ostream& operator<<
(ostream& theStream, const Animal& theAnimal)
{
theStream << theAnimal.GetWeight();
return theStream;
}
Animal::Animal(int weight):34:
itsWeight(weight)
35:
{
36:
// cout << "Animal(int)\n";
37:
}
38:
39:
Animal::Animal():
40:
itsWeight(0)
41:
{
42:
// cout << "Animal()\n";
43:
}
44:
45:
Animal::~Animal()
46:
{
47:
// cout << "Destroyed an animal...\n";
48:
}
49:
50:
template <class T> // declare the template and the
parameter
51:
class Array
// the class being parameterized
52:
{
53:
public:
54:
Array(int itsSize = DefaultSize);
55:
Array(const Array &rhs);
56:
~Array() { delete [] pType; }
57:
58:
Array& operator=(const Array&);
59:
T& operator[](int offSet) { return pType[offSet]; }
60:
const T& operator[](int offSet) const
61:
{ return pType[offSet]; }
62:
int GetSize() const { return itsSize; }
63
64:
// friend function
65:
friend ostream& operator<< (ostream&, const Array<T>&);
66:
67:
private:
68:
T *pType;
69:
int itsSize;
70:
};
71:
70:
template <class T>
72:
ostream& operator<< (ostream& output, const Array<T>&
theArray)
73:
{
74:
for (int i = 0; i<theArray.GetSize(); i++)
75:
output << "[" << i << "] " << theArray[i] << endl;
76:
return output;77:
}
78:
79:
void IntFillFunction(Array<int>& theArray);
80:
void AnimalFillFunction(Array<Animal>& theArray);
81:
enum BOOL {FALSE, TRUE};
82:
84:
int main()
85:
{
86:
Array<int> intArray;
87:
Array<Animal> animalArray;
88:
IntFillFunction(intArray);
87:
AnimalFillFunction(animalArray);
89:
cout << "intArray...\n" << intArray;
90:
cout << "\nanimalArray...\n" << animalArray << endl;
91:
return 0;
92:
}
93:
94:
void IntFillFunction(Array<int>& theArray)
95:
{
96:
BOOL Stop = FALSE;
97:
int offset, value;
98:
while (!Stop)
99:
{
100:
cout << "Enter an offset (0-9) ";
101:
cout << "and a value. (-1 to stop): " ;
102:
cin >> offset >> value;
103:
if (offset < 0)
104:
break;
105:
if (offset > 9)
106:
{
107:
cout << "***Please use values between 0 and
9.***\n";
108:
continue;
109:
}
110:
theArray[offset] = value;
111:
}
112:
}
113:
114:
115:
void AnimalFillFunction(Array<Animal>& theArray)
116:
{
117:
Animal * pAnimal;
118:
for (int i = 0; i<theArray.GetSize(); i++)
119:
{
120:
pAnimal = new Animal;
121:
pAnimal->SetWeight(i*100);122:
123:
124:
125: }
theArray[i] = *pAnimal;
delete pAnimal; // a copy was put in the array
}
Output: Enter an offset (0-9) and a value. (-1 to stop): 1 10
Enter an offset (0-9) and a value. (-1 to stop): 2 20
Enter an offset (0-9) and a value. (-1 to stop): 3 30
Enter an offset (0-9) and a value. (-1 to stop): 4 40
Enter an offset (0-9) and a value. (-1 to stop): 5 50
Enter an offset (0-9) and a value. (-1 to stop): 6 60
Enter an offset (0-9) and a value. (-1 to stop): 7 70
Enter an offset (0-9) and a value. (-1 to stop): 8 80
Enter an offset (0-9) and a value. (-1 to stop): 9 90
Enter an offset (0-9) and a value. (-1 to stop): 10 10
***Please use values between 0 and 9.***
Enter an offset (0-9) and a value. (-1 to stop): -1 -1
intArray:...
[0] 0
[1] 10
[2] 20
[3] 30
[4] 40
[5] 50
[6] 60
[7] 70
[8] 80
[9] 90
animalArray:...
[0] 0
[1] 100
[2] 200
[3] 300
[4] 400
[5] 500
[6] 600
[7] 700
[8] 800
[9] 900
Analysis: Most of the Array class implementation is left out to save space. The Animal class is
declared on lines 6-23. Although this is a stripped-down and simplified class, it does provide its own
insertion operator (<<) to allow the printing of Animals. Printing simply prints the current weight of
the Animal.Note that Animal has a default constructor. This is necessary because, when you add an object to an
array, the object's default constructor is used to create the object. This creates some difficulties, as
you'll see.
On line 79, the function IntFillFunction() is declared. The prototype indicates that this
function takes an integer array. Note that this is not a template function. IntFillFunction()
expects only one type of an array--an integer array. Similarly, on line 80,
AnimalFillFunction() is declared to take an Array of Animal.
The implementations for these functions are different from one another, because filling an array of
integers does not have to be accomplished in the same way as filling an array of Animals.
Specialized Functions
If you uncomment the print statements in Animal's constructors and destructor in Listing 19.5,
you'll find there are unanticipated extra constructions and destructions of Animals.
When an object is added to an array, the object's default constructor is called. The Array constructor,
however, goes on to assign 0 to the value of each member of the array, as shown on lines 59 and 60 of
Listing 19.2.
When you write someAnimal = (Animal) 0;, you call the default operator= for Animal.
This causes a temporary Animal object to be created, using the constructor, which takes an integer
(zero). That temporary is used as the right-hand side of the operator= and then is destroyed.
This is an unfortunate waste of time, because the Animal object was already properly initialized.
However, you can't remove this line, because integers are not automatically initialized to a value of 0.
The solution is to teach the template not to use this constructor for Animals, but to use a special
Animal constructor.
You can provide an explicit implementation for the Animal class, as indicated in Listing 19.6.
Listing 19.6. Specializing template implementations.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
#include <iostream.h>
const int DefaultSize = 3;
// A trivial class for adding to arrays
class Animal
{
public:
// constructors
Animal(int);11:
Animal();
12:
~Animal();
13:
14:
// accessors
15:
int GetWeight() const { return itsWeight; }
16:
void SetWeight(int theWeight) { itsWeight = theWeight;
}
17:
18:
// friend operators
19:
friend ostream& operator<< (ostream&, const Animal&);
20:
21:
private:
22:
int itsWeight;
23:
};
24:
25:
// extraction operator for printing animals
26:
ostream& operator<<
27:
(ostream& theStream, const Animal& theAnimal)
28:
{
29:
theStream << theAnimal.GetWeight();
30:
return theStream;
31:
}
32:
33:
Animal::Animal(int weight):
34:
itsWeight(weight)
35:
{
36:
cout << "animal(int) ";
37:
}
38:
39:
Animal::Animal():
40:
itsWeight(0)
41:
{
42:
cout << "animal() ";
43:
}
44:
45:
Animal::~Animal()
46:
{
47:
cout << "Destroyed an animal...";
48:
}
49:
50:
template <class T> // declare the template and the
parameter
51:
class Array
// the class being parameterized
52:
{
53:
public:
54:
Array(int itsSize = DefaultSize);55:
56:
57:
58:
59:
60:
61:
62:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
Array(const Array &rhs);
~Array() { delete [] pType; }
// operators
Array& operator=(const Array&);
T& operator[](int offSet) { return pType[offSet]; }
const T& operator[](int offSet) const
{ return pType[offSet]; }
// accessors
int GetSize() const { return itsSize; }
// friend function
friend ostream& operator<< (ostream&, const Array<T>&);
private:
T *pType;
int itsSize;
};
template <class T>
Array<T>::Array(int size = DefaultSize):
itsSize(size)
{
pType = new T[size];
for (int i = 0; i<size; i++)
pType[i] = (T)0;
}
template <class T>
Array<T>& Array<T>::operator=(const Array &rhs)
{
if (this == &rhs)
return *this;
delete [] pType;
itsSize = rhs.GetSize();
pType = new T[itsSize];
for (int i = 0; i<itsSize; i++)
pType[i] = rhs[i];
return *this;
}
template <class T>
Array<T>::Array(const Array &rhs)
{
itsSize = rhs.GetSize();
pType = new T[itsSize];100:
for (int i = 0; i<itsSize; i++)
101:
pType[i] = rhs[i];
102:
}
103:
104:
105:
template <class T>
106:
ostream& operator<< (ostream& output, const Array<T>&
theArray)
107:
{
108:
for (int i = 0; i<theArray.GetSize(); i++)
109:
output << "[" << i << "] " << theArray[i] << endl;
110:
return output;
111:
}
112:
113:
114:
Array<Animal>::Array(int AnimalArraySize):
115:
itsSize(AnimalArraySize)
116:
{
117:
pType = new Animal[AnimalArraySize];
118:
}
119:
120:
121:
void IntFillFunction(Array<int>& theArray);
122:
void AnimalFillFunction(Array<Animal>& theArray);
123:
enum BOOL {FALSE, TRUE};
124:
125:
int main()
126:
{
127:
Array<int> intArray;
128:
Array<Animal> animalArray;
129:
IntFillFunction(intArray);
130:
AnimalFillFunction(animalArray);
131:
cout << "intArray...\n" << intArray;
132:
cout << "\nanimalArray...\n" << animalArray << endl;
133:
return 0;
134:
}
135:
136:
void IntFillFunction(Array<int>& theArray)
137:
{
138:
BOOL Stop = FALSE;
139:
int offset, value;
140:
while (!Stop)
141:
{
142:
cout << "Enter an offset (0-9) and a value. ";
143:
cout << "(-1 to stop): " ;
143:
cin >> offset >> value;144:
if (offset < 0)
145:
break;
146:
if (offset > 9)
147:
{
148:
cout << "***Please use values between 0 and
9.***\n";
149:
continue;
150:
}
151:
theArray[offset] = value;
152:
}
153:
}
154:
155:
156:
void AnimalFillFunction(Array<Animal>& theArray)
157:
{
158:
Animal * pAnimal;
159:
for (int i = 0; i<theArray.GetSize(); i++)
160:
{
161:
pAnimal = new Animal(i*10);
162:
theArray[i] = *pAnimal;
163:
delete pAnimal;
164:
}
165: }
NOTE: Line numbers have been added to the output to make analysis easier. Line
numbers will not appear in your output.
Output: 1: animal() animal() animal() Enter an offset (0-9) and a
value. (-1 to
stop): 0 0
2: Enter an offset (0-9) and a value. (-1 to stop): 1 1
3: Enter an offset (0-9) and a value. (-1 to stop): 2 2
4: Enter an offset (0-9) and a value. (-1 to stop): 3 3
5: Enter an offset (0-9) and a value. (-1 to stop): -1 -1
6: animal(int) Destroyed an animal...animal(int) Destroyed an
animal...animal(int) Destroyed an animal...initArray...
7: [0] 0
8: [1] 1
9: [2] 2
10:
11: animal array...
12: [0] 0
13: [1] 10
14: [2] 20
15:16: Destroyed an animal...Destroyed an animal...Destroyed an
animal...
17:
<<< Second run >>>
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
animal(int) Destroyed an
animal(int) Destroyed an
animal(int) Destroyed an
Enter an offset (0-9) and
Enter an offset (0-9) and
Enter an offset (0-9) and
Enter an offset (0-9) and
animal(int)
Destroyed an animal...
animal(int)
Destroyed an animal...
animal(int)
Destroyed an animal...
initArray...
[0] 0
[1] 1
[2] 2
animal...
animal...
animal...
a value. (-1
a value. (-1
a value. (-1
a value. (-1
to
to
to
to
stop):
stop):
stop):
stop):
0
1
2
3
0
1
2
3
animal array...
[0] 0
[1] 10
[2] 20
Destroyed an animal...
Destroyed an animal...
Destroyed an animal...
Analysis: Listing 19.6 reproduces both classes in their entirety, so that you can see the creation and
destruction of temporary Animal objects. The value of DefaultSize has been reduced to 3 to
simplify the output.
The Animal constructors and destructors on lines 33-48 each print a statement indicating when they
are called.
On lines 74-81, the template behavior of an Array constructor is declared. On lines 114-118, the
specialized constructor for an Array of Animals is demonstrated. Note that in this special
constructor, the default constructor is allowed to set the initial value for each Animal, and no explicit
assignment is done.
The first time this program is run, the first set of output is shown. Line 1 of the output shows the three
default constructors called by creating the array. The user enters four numbers, and these are entered
into the integer array.Execution jumps to AnimalFillFunction(). Here a temporary Animal object is created on the
heap on line 161, and its value is used to modify the Animal object in the array on line 162. On line
163, the temporary Animal is destroyed. This is repeated for each member of the array and is
reflected in the output on line 6.
At the end of the program, the arrays are destroyed, and when their destructors are called, all their
objects are destroyed as well. This is reflected in the output on line 16.
For the second set of output (lines 18-43), the special implementation of the array of character
constructor, shown on lines 114-118 of the program, is commented out. When the program is run
again, the template constructor, shown on lines 74-81 of the program, is run when the Animal
array is constructed.
This causes temporary Animal objects to be called for each member of the array on lines 79 and 80
of the program, and is reflected in the output on lines 18 to 20 of the output.
In all other respects, the output for the two runs is identical, as you would expect.
Static Members and Templates
A template can declare static data members. Each instantiation of the template then has its own set of
static data, one per class type. That is, if you add a static member to the Array class (for example, a
counter of how many arrays have been created), you will have one such member per type: one for all
the arrays of Animals, and another for all the arrays of integers. Listing 19.7 adds a static member
and a static function to the Array class.
Listing 19.7. Using static member data and functions with templates.
1:
#include <iostream.h>
2:
3:
template <class T> // declare the template and the
parameter
4:
class Array
// the class being parameterized
5:
{
6:
public:
7:
// constructors
8:
Array(int itsSize = DefaultSize);
9:
Array(const Array &rhs);
10:
~Array() { delete [] pType;
itsNumberArrays--; }
11:
12:
// operators
13:
Array& operator=(const Array&);
14:
T& operator[](int offSet) { return pType[offSet]; }
15:
const T& operator[](int offSet) const16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
{ return pType[offSet]; }
// accessors
int GetSize() const { return itsSize; }
static int GetNumberArrays() { return itsNumberArrays; }
// friend function
friend ostream& operator<< (ostream&, const Array<T>&);
private:
T *pType;
int itsSize;
static int itsNumberArrays;
};
template <class T>
int Array<T>::itsNumberArrays = 0;
template <class T>
Array<T>::Array(int size = DefaultSize):
itsSize(size)
{
pType = new T[size];
for (int i = 0; i<size; i++)
pType[i] = (T)0;
itsNumberArrays++;
}
template <class T>
Array<T>& Array<T>::operator=(const Array &rhs)
{
if (this == &rhs)
return *this;
delete [] pType;
itsSize = rhs.GetSize();
pType = new T[itsSize];
for (int i = 0; i<itsSize; i++)
pType[i] = rhs[i];
}
template <class T>
Array<T>::Array(const Array &rhs)
{
itsSize = rhs.GetSize();
pType = new T[itsSize];
for (int i = 0; i<itsSize; i++)
pType[i] = rhs[i];62:
itsNumberArrays++;
63:
}
64:
65:
66:
template <class T>
67:
ostream& operator<< (ostream& output, const Array<T>&
theArray)
68:
{
69:
for (int i = 0; i<theArray.GetSize(); i++)
70:
output << "[" << i << "] " << theArray[i] << endl;
71:
return output;
72:
}
73:
74:
75:
Array<Animal>::Array(int AnimalArraySize):
76:
itsSize(AnimalArraySize)
77:
{
78:
pType = new T[AnimalArraySize];
79:
itsNumberArrays++;
80:
}
81:
82:
int main()
83:
{
84:
85:
cout << Array<int>::GetNumberArrays() << " integer
arrays\n";
86:
cout << Array<Animal>::GetNumberArrays();
87
cout << " animal arrays\n\n";
88:
Array<int> intArray;
89:
Array<Animal> animalArray;
90:
91:
cout << intArray.GetNumberArrays() << " integer
arrays\n";
92:
cout << animalArray.GetNumberArrays();
93:
cout << " animal arrays\n\n";
93:
94:
Array<int> *pIntArray = new Array<int>;
95:
96:
cout << Array<int>::GetNumberArrays() << " integer
arrays\n";
97:
cout << Array<Animal>::GetNumberArrays();
98:
cout << " animal arrays\n\n";
98:
99:
delete pIntArray;
100:
101:
cout << Array<int>::GetNumberArrays() << " integerarrays\n";
102:
cout << Array<Animal>::GetNumberArrays();
103:
cout << " animal arrays\n\n";
103:
return 0;
104: }
Output: 0 integer arrays
0 animal arrays
1 integer arrays
1 animal arrays
2 integer arrays
1 animal arrays
1 integer arrays
1 animal arrays
Analysis: The declaration of the Animal class has been left out to save space. The Array class has
added the static variable itsNumberArrays on line 27, and because this data is private, the static
public accessor GetNumberArrays() was added on line 19.
Initialization of the static data is accomplished with a full template qualification, as shown on lines 30
and 31. The constructors of Array and the destructor are each modified to keep track of how many
arrays exist at any moment.
Accessing the static members is exactly like accessing the static members of any class: You can do so
with an existing object, as shown on lines 91 and 92, or by using the full class specification, as shown
on lines 85 and 86. Note that you must use a specific type of array when accessing the static data.
There is one variable for each type.
DO use statics with templates as needed. DO specialize template behavior by
overriding template functions by type. DO use the parameters to template functions to
narrow their instances to be type-safe.
The Standard Template Library
A new development in C++ is the adoption of the Standard Template Library (STL). All the major
compiler vendors now offer the STL as part of their compilers. STL is a library of template-based
container classes, including vectors, lists, queues, and stacks. The STL also includes a number of
common algorithms, including sorting and searching.
The goal of the STL is to give you an alternative to reinventing the wheel for these common
requirements. The STL is tested and debugged, offers high performance, and is free. Most important,
the STL is reusable; once you understand how to use an STL container, you can use it in all yourprograms without reinventing it.
Summary
Today you learned how to create and use templates. Templates are a built-in facility of C++, used to
create parameterized types--types that change their behavior based on parameters passed in at
creation. They are a way to reuse code safely and effectively.
The definition of the template determines the parameterized type. Each instance of the template is an
actual object, which can be used like any other object--as a parameter to a function, as a return value,
and so forth.
Template classes can declare three types of friend functions: non-template, general template, and type-
specific template. A template can declare static data members, in which case each instance of the
template has its own set of static data.
If you need to specialize behavior for some template functions based on the actual type, you can
override a template function with a particular type. This works for member functions as well.
Q&A
Q. Why use templates when macros will do?
A. Templates are type-safe and built into the language.
Q. What is the difference between the parameterized type of a template function and the
parameters to a normal function?
A. A regular function (non-template) takes parameters on which it may take action. A template
function allows you to parameterize the type of a particular parameter to the function. That is,
you can pass an Array of Type to a function, and then have the Type determined by the
template instance.
Q. When do you use templates and when do you use inheritance?
A. Use templates when all the behavior, or virtually all the behavior, is unchanged, except in
regard to the type of the item on which your class acts. If you find yourself copying a class and
changing only the type of one or more of its members, it may be time to consider using a
template.
Q. When do you use general template friend classes?
A. When every instance, regardless of type, should be a friend to this class or function.
Q. When do you use type-specific template friend classes or functions?A. When you want to establish a one-to-one relationship between two classes. For example,
array<int> should match iterator<int>, but not iterator<Animal>.
Workshop
The Workshop provides quiz questions to help you solidify your understanding of the material
covered, and exercises to provide you with experience in using what you've learned. Try to answer the
quiz and exercise questions before checking the answers in Appendix D, and make sure you
understand the answers before continuing to the next chapter.
Quiz
1. What is the difference between a template and a macro?
2. What is the difference between the parameter in a template and the parameter in a function?
3. What is the difference between a type-specific template friend class and a general template
friend class?
4. Is it possible to provide special behavior for one instance of a template but not for other
instances?
5. How many static variables are created if you put one static member into a template class
definition?
Exercises
1. Create a template based on this List class:
class List
{
private:
public:
List():head(0),tail(0),theCount(0) {}
virtual ~List();
void insert( int value );
void append( int value );
int is_present( int value ) const;
int is_empty() const { return head == 0; }
int count() const { return theCount; }
private:
class ListCell
{
public:
ListCell(int value, ListCell *cell =):val(value),next(cell){}
int val;
ListCell *next;
};
ListCell *head;
ListCell *tail;
int theCount;
};
2. Write the implementation for the List class (non-template) version.
3. Write the template version of the implementations.
4. Declare three list objects: a list of Strings, a list of Cats, and a list of ints.
5. BUG BUSTERS: What is wrong with the following code? (Assume the List template is
defined and Cat is the class defined earlier in the book.)
List<Cat> Cat_List;
Cat Felix;
CatList.append( Felix );
cout << "Felix is " <<
( Cat_List.is_present( Felix ) ) ? "" : "not " << "present\n";
HINT (this is tough): What makes Cat different from int?
6. Declare friend operator== for List.
7. Implement friend operator== for List.
8. Does operator== have the same problem as in Exercise 5?
9. Implement a template function for swap, which exchanges two variables.
',. What a debugger is.
Bugs, Errors, Mistakes, and Code Rot
All programs have bugs. The bigger the program, the more bugs, and many of those bugs actually "get
out the door" and into final, released software. That this is true does not make it okay, and making
robust, bug-free programs is the number-one priority of anyone serious about programming.
The single biggest problem in the software industry is buggy, unstable code. The biggest expense in
many major programming efforts is testing and fixing. The person who solves the problem of
producing good, solid, bulletproof programs at low cost and on time will revolutionize the software
industry.
There are a number of discrete kinds of bugs that can trouble a program. The first is poor logic: The
program does just what you asked, but you haven't thought through the algorithms properly. The
second is syntactic: You used the wrong idiom, function, or structure. These two are the most
common, and they are the ones most programmers are on the lookout for.
Research and real-world experience have shown beyond a doubt that the later in the development
process you find a problem, the more it costs to fix it. The least expensive problems or bugs to fix are
the ones you manage to avoid creating. The next cheapest are those the compiler spots. The C++
standards force compilers to put a lot of energy into making more and more bugs show up at compile
time.
Bugs that get compiled in but are caught at the first test--those that crash every time--are less
expensive to find and fix than those that are flaky and only crash once in a while.A bigger problem than logic or syntactic bugs is unnecessary fragility: Your program works just fine
if the user enters a number when you ask for one, but it crashes if the user enters letters. Other
programs crash if they run out of memory, or if the floppy disk is left out of the drive, or if the modem
drops the line.
To combat this kind of fragility, programmers strive to make their programs bulletproof. A bulletproof
program is one that can handle anything that comes up at runtime, from bizarre user input to running
out of memory.
It is important to distinguish between bugs, which arise because the programmer made a mistake in
syntax; logic errors, which arise because the programmer misunderstood the problem or how to solve
it; and exceptions, which arise because of unusual but predictable problems such as running out of
resources (memory or disk space).
Exceptions
Programmers use powerful compilers and sprinkle their code with asserts, as discussed on Day 17,
"The Preprocessor," to catch programming errors. They use design reviews and exhaustive testing to
find logic errors.
Exceptions are different, however. You can't eliminate exceptional circumstances; you can only
prepare for them. Your users will run out of memory from time to time, and the only question is what
you will do. Your choices are limited to these:
!#- Crash the program.
/!, Inform the user and exit gracefully.
%+* Inform the user and allow the user to try to recover and continue.
%," Take corrective action and continue without disturbing the user.
While it is not necessary or even desirable for every program you write to automatically and silently
recover from all exceptional circumstances, it is clear that you must do better than crashing.
C++ exception handling provides a type-safe, integrated method for coping with the predictable but
unusual conditions that arise while running a program.
A Word About Code Rot
Code rot is a well-proven phenomenon. Code rot is when code deteriorates due to being neglected.
Perfectly well-written, fully debugged code will develop new and bizarre behavior six months after
you release it, and there isn't much you can do to stop it. What you can do, of course, is write your
programs so that when you go back to fix the spoilage, you can quickly and easily identify where theproblems are.
NOTE: Code rot is somewhat of a programmer's joke used to explain how bug-free
code suddenly becomes unreliable. It does, however, teach an important lesson.
Programs are enormously complex, and bugs, errors, and mistakes can hide for a long
time before turning up. Protect yourself by writing easy-to-maintain code.
This means that your code must be commented even if you don't expect anyone else to ever look at it.
Six months after you deliver your code, you will read it with the eyes of a total stranger, bewildered
by how anyone could ever have written such convoluted and twisty code and expected anything but
disaster.
Exceptions
In C++, an exception is an object that is passed from the area of code where a problem occurs to the
part of the code that is going to handle the problem. The type of the exception determines which area
of code will handle the problem, and the contents of the object thrown, if any, may be used to provide
feedback to the user.
The basic idea behind exceptions is fairly straightforward:
&$(
/)'
)+"
The actual allocation of resources (for example, the allocation of memory or the locking of a
file) is usually done at a very low level in the program.
The logic of what to do when an operation fails, memory cannot be allocated, or a file cannot
be locked is usually high in the program, with the code for interacting with the user.
Exceptions provide an express path from the code that allocates resources to the code that can
handle the error condition. If there are intervening layers of functions, they are given an
opportunity to clean up memory allocations, but are not required to include code whose only
purpose is to pass along the error condition.
How Exceptions Are Used
try blocks are created to surround areas of code that may have a problem. For example:
try
{
SomeDangerousFunction();
}
catch blocks handle the exceptions thrown in the try block. For example:try
{
SomeDangerousFunction();
}
catch(OutOfMemory)
{
// take some actions
}
catch(FileNotFound)
{
// take other action
}
The basic steps in using exceptions are
1. Identify those areas of the program in which you begin an operation that might raise an
exception, and put them in try blocks.
2. Create catch blocks to catch the exceptions if they are thrown, to clean up allocated
memory, and to inform the user as appropriate. Listing 20.1 illustrates the use of both try
blocks and catch blocks.
New Term: Exceptions are objects used to transmit information about a problem.
New Term: A try block is a block surrounded by braces in which an exception may be thrown.
New Term: A catch block is the block immediately following a try block, in which
exceptions are handled.
When an exception is thrown (or raised), control transfers to the catch block immediately
following the current try block.
NOTE: Some older compilers do not support exceptions. Exceptions are, however, part
of the emerging C++ standard. All major compiler vendors have committed to
supporting exceptions in their next releases, if they have not already done so. If you
have an older compiler, you won't be able to compile and run the exercises in this
chapter. It's still a good idea to read through the entire chapter, however, and return tothis material when you upgrade your compiler.
Listing 20.1. Raising an exception.
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
#include <iostream.h>
const int DefaultSize = 10;
class Array
{
public:
// constructors
Array(int itsSize = DefaultSize);
Array(const Array &rhs);
~Array() { delete [] pType;}
// operators
Array& operator=(const Array&);
int& operator[](int offSet);
const int& operator[](int offSet) const;
// accessors
int GetitsSize() const { return itsSize; }
// friend function
friend ostream& operator<< (ostream&, const Array&);
class xBoundary {};
private:
int *pType;
int itsSize;
};
// define the exception class
Array::Array(int size):
itsSize(size)
{
pType = new int[size];
for (int i = 0; i<size; i++)
pType[i] = 0;
}
Array& Array::operator=(const Array &rhs)
{41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
theArray)
80:
81:
82:
83:
84:
85:
if (this == &rhs)
return *this;
delete [] pType;
itsSize = rhs.GetitsSize();
pType = new int[itsSize];
for (int i = 0; i<itsSize; i++)
pType[i] = rhs[i];
return *this;
}
Array::Array(const Array &rhs)
{
itsSize = rhs.GetitsSize();
pType = new int[itsSize];
for (int i = 0; i<itsSize; i++)
pType[i] = rhs[i];
}
int& Array::operator[](int offSet)
{
int size = GetitsSize();
if (offSet >= 0 && offSet < GetitsSize())
return pType[offSet];
throw xBoundary();
return pType[0]; // appease MSC
}
const int& Array::operator[](int offSet) const
{
int mysize = GetitsSize();
if (offSet >= 0 && offSet < GetitsSize())
return pType[offSet];
throw xBoundary();
return pType[0]; // appease MSC
}
ostream& operator<< (ostream& output, const Array&
{
for (int i = 0; i<theArray.GetitsSize(); i++)
output << "[" << i << "] " << theArray[i] << endl;
return output;
}86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103: }
int main()
{
Array intArray(20);
try
{
for (int j = 0; j< 100; j++)
{
intArray[j] = j;
cout << "intArray[" << j << "] okay..." << endl;
}
}
catch (Array::xBoundary)
{
cout << "Unable to process your input!\n";
}
cout << "Done.\n";
return 0;
Output: intArray[0] okay...
intArray[1] okay...
intArray[2] okay...
intArray[3] okay...
intArray[4] okay...
intArray[5] okay...
intArray[6] okay...
intArray[7] okay...
intArray[8] okay...
intArray[9] okay...
intArray[10] okay...
intArray[11] okay...
intArray[12] okay...
intArray[13] okay...
intArray[14] okay...
intArray[15] okay...
intArray[16] okay...
intArray[17] okay...
intArray[18] okay...
intArray[19] okay...
Unable to process your input!
Done.
Analysis: Listing 20.1 presents a somewhat stripped-down Array class, based on the template
developed on Day 19, "Templates." On line 23, a new class is contained within the declaration of the
boundary.This new class is not in any way distinguished as an exception class. It is just a class like any other.
This particular class is incredibly simple: It has no data and no methods. Nonetheless, it is a valid
class in every way.
In fact, it is incorrect to say it has no methods, because the compiler automatically assigns it a default
constructor, destructor, copy constructor, and the copy operator (operator equals); so it actually has
four class functions, but no data.
Note that declaring it from within Array serves only to couple the two classes together. As discussed
on Day 15, "Advanced Inheritance," Array has no special access to xBoundary, nor does
xBoundary have preferential access to the members of Array.
On lines 60-66 and 69-75, the offset operators are modified to examine the offset requested and, if it is
out of range, to throw the xBoundary class as an exception. The parentheses are required to
distinguish between this call to the xBoundary constructor and the use of an enumerated constant.
Note that Microsoft requires that you provide a return statement to match the declaration (in this
case, returning an integer reference), even though if an exception is thrown on line 65 the code will
never reach line 66. This is a compiler bug, proving only that even Microsoft finds this stuff difficult
and confusing!
On line 89, the keyword try begins a try block that ends on line 96. Within that try block, 100
integers are added to the array that was declared on line 88.
On line 97, the catch block to catch xBoundary exceptions is declared.
In the driver program on lines 86-103, a try block is created in which each member of the array is
initialized. When j (line 91) is incremented to 20, the member at offset 20 is accessed. This causes the
test on line 63 to fail, and operator[] raises an xBoundary exception on line 65.
Program control switches to the catch block on line 97, and the exception is caught or handled by
the catch on the same line, which prints an error message. Program flow drops through to the end of
the catch block on line 100.
try Blocks
A try block is a set of statements that begins with the word try, is followed by an opening brace,
and ends with a closing brace. Example:
try
{
Function();
};
catch BlocksA catch block is a series of statements, each of which begins with the word catch, followed by an
exception type in parentheses, followed by an opening brace, and ending with a closing brace.
Example:
try
{
Function();
};
catch (OutOfMemory)
{
// take action
}
Using try Blocks and catch Blocks
Figuring out where to put your try blocks is non-trivial: It is not always obvious which actions might
raise an exception. The next question is where to catch the exception. It may be that you'll want to
throw all memory exceptions where the memory is allocated, but you'll want to catch the exceptions
high in the program, where you deal with the user interface.
When trying to determine try block locations, look to where you allocate memory or use resources.
Other things to look for are out-of-bounds errors, illegal input, and so forth.
Catching Exceptions
Here's how it works: when an exception is thrown, the call stack is examined. The call stack is the list
of function calls created when one part of the program invokes another function.
The call stack tracks the execution path. If main() calls the function
Animal::GetFavoriteFood(), and GetFavoriteFood() calls
Animal::LookupPreferences(), which in turn calls fstream::operator>>(), all these
are on the call stack. A recursive function might be on the call stack many times.
The exception is passed up the call stack to each enclosing block. As the stack is unwound, the
destructors for local objects on the stack are invoked, and the objects are destroyed.
After each try block there is one or more catch statements. If the exception matches one of the
catch statements, it is considered to be handled by having that statement execute. If it doesn't match
any, the unwinding of the stack continues.
If the exception reaches all the way to the beginning of the program (main()) and is still not caught,
a built-in handler is called that terminates the program.
It is important to note that the exception unwinding of the stack is a one-way street. As it progresses,the stack is unwound and objects on the stack are destroyed. There is no going back: Once the
exception is handled, the program continues after the try block of the catch statement that handled
the exception.
Thus, in Listing 20.1, execution will continue on line 101, the first line after the try block of the
catch statement that handled the xBoundary exception. Remember that when an exception is
raised, program flow continues after the catch block, not after the point where the exception was
thrown.
More Than One catch Specification
It is possible for more than one condition to cause an exception. In this case, the catch statements
can be lined up one after another, much like the conditions in a switch statement. The equivalent to
the default statement is the "catch everything" statement, indicated by catch(...). Listing 20.2
illustrates multiple exception conditions.
Listing 20.2. Multiple exceptions.
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
#include <iostream.h>
const int DefaultSize = 10;
class Array
{
public:
// constructors
Array(int itsSize = DefaultSize);
Array(const Array &rhs);
~Array() { delete [] pType;}
// operators
Array& operator=(const Array&);
int& operator[](int offSet);
const int& operator[](int offSet) const;
// accessors
int GetitsSize() const { return itsSize; }
// friend function
friend ostream& operator<< (ostream&, const Array&);
// define the exception classes
class xBoundary {};
class xTooBig {};
class xTooSmall{};27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
class xZero {};
class xNegative {};
private:
int *pType;
int itsSize;
};
int& Array::operator[](int offSet)
{
int size = GetitsSize();
if (offSet >= 0 && offSet < GetitsSize())
return pType[offSet];
throw xBoundary();
return pType[0]; // appease MFC
}
const int& Array::operator[](int offSet) const
{
int mysize = GetitsSize();
if (offSet >= 0 && offSet < GetitsSize())
return pType[offSet];
throw xBoundary();
return pType[0];
return pType[0]; // appease MFC
}
Array::Array(int size):
itsSize(size)
{
if (size == 0)
throw xZero();
if (size < 10)
throw xTooSmall();
if (size > 30000)
throw xTooBig();
if (size < 1)
throw xNegative();
pType = new int[size];
for (int i = 0; i<size; i++)
pType[i] = 0;
}73:
74:
int main()
75:
{
76:
77:
try
78:
{
79:
Array intArray(0);
80:
for (int j = 0; j< 100; j++)
81:
{
82:
intArray[j] = j;
83:
cout << "intArray[" << j << "] okay...\n";
84:
}
85:
}
86:
catch (Array::xBoundary)
87:
{
88:
cout << "Unable to process your input!\n";
89:
}
90:
catch (Array::xTooBig)
91:
{
92:
cout << "This array is too big...\n";
93:
}
94:
catch (Array::xTooSmall)
95:
{
96:
cout << "This array is too small...\n";
97:
}
98:
catch (Array::xZero)
99:
{
100:
cout << "You asked for an array";
101:
cout << " of zero objects!\n";
102:
}
103:
catch (...)
104:
{
105:
cout << "Something went wrong!\n";
106:
}
107:
cout << "Done.\n";
108:
return 0;
109: }
Output: You asked for an array of zero objects!
Done.
Analysis: Four new classes are created in lines 24-27: xTooBig, xTooSmall, xZero, and
xNegative. In the constructor, on lines 55-70, the size passed to the constructor is examined. If it's
too big, too small, negative, or zero, an exception is thrown.
The try block is changed to include catch statements for each condition other than negative, which
is caught by the "catch everything" statement catch(...), shown on line 103.Try this with a number of values for the size of the array. Then try putting in -5. You might have
expected xNegative to be called, but the order of the tests in the constructor prevented this: size
< 10 was evaluated before size < 1. To fix this, swap lines 60 and 61 with lines 64 and 65 and
recompile.
Exception Hierarchies
Exceptions are classes, and as such they can be derived from. It may be advantageous to create a class
xSize, and to derive from it xZero, xTooSmall, xTooBig, and xNegative. Thus, some
functions might just catch xSize errors, while other functions might catch the specific type of
xSize error. Listing 20.3 illustrates this idea.
Listing 20.3. Class hierarchies and exceptions.
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
#include <iostream.h>
const int DefaultSize = 10;
class Array
{
public:
// constructors
Array(int itsSize = DefaultSize);
Array(const Array &rhs);
~Array() { delete [] pType;}
// operators
Array& operator=(const Array&);
int& operator[](int offSet);
const int& operator[](int offSet) const;
// accessors
int GetitsSize() const { return itsSize; }
// friend function
friend ostream& operator<< (ostream&, const Array&);
// define the exception classes
class xBoundary {};
class xSize {};
class xTooBig : public xSize {};
class xTooSmall : public xSize {};
class xZero : public xTooSmall {};
class xNegative : public xSize {};30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
private:
int *pType;
int itsSize;
};
Array::Array(int size):
itsSize(size)
{
if (size == 0)
throw xZero();
if (size > 30000)
throw xTooBig();
if (size <1)
throw xNegative();
if (size < 10)
throw xTooSmall();
pType = new int[size];
for (int i = 0; i<size; i++)
pType[i] = 0;
}
int& Array::operator[](int offSet)
{
int size = GetitsSize();
if (offSet >= 0 && offSet < GetitsSize())
return pType[offSet];
throw xBoundary();
return pType[0]; // appease MFC
}
const int& Array::operator[](int offSet) const
{
int mysize = GetitsSize();
if (offSet >= 0 && offSet < GetitsSize())
return pType[offSet];
throw xBoundary();
return pType[0];
return pType[0]; // appease MFC
}
int main()
{76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111: }
try
{
Array intArray(5);
for (int j = 0; j< 100; j++)
{
intArray[j] = j;
cout << "intArray[" << j << "] okay...\n";
}
}
catch (Array::xBoundary)
{
cout << "Unable to process your input!\n";
}
catch (Array::xTooBig)
{
cout << "This array is too big...\n";
}
catch (Array::xZero)
{
cout << "You asked for an array";
cout << " of zero objects!\n";
}
catch (Array::xTooSmall)
{
cout << "This array is too small...\n";
}
catch (...)
{
cout << "Something went wrong!\n";
}
cout << "Done.\n";
return 0
Output: This array is too small...
Done.
Analysis: The significant change is on lines 26-29, where the class hierarchy is established. Classes
xTooBig, xTooSmall, and xNegative are derived from xSize, and xZero is derived from
xTooSmall.
The Array is created with size zero, but what's this? The wrong exception appears to be caught!
Examine the catch block carefully, however, and you will find that it looks for an exception of typexTooSmall before it looks for an exception of type xZero. Because an xZero object is thrown
and an xZero object is an xTooSmall object, it is caught by the handler for xTooSmall. Once
handled, the exception is not passed on to the other handlers, so the handler for xZero is never
called.
The solution to this problem is to carefully order the handlers so that the most specific handlers come
first and the less specific handlers come later. In this particular example, switching the placement of
the two handlers xZero and xTooSmall will fix the problem.
Data in Exceptions and Naming Exception Objects
Often you will want to know more than just what type of exception was thrown so you can respond
properly to the error. Exception classes are like any other class. You are free to provide data, initialize
that data in the constructor, and read that data at any time. Listing 20.4 illustrates how to do this.
Listing 20.4. Getting data out of an exception object.
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
#include <iostream.h>
const int DefaultSize = 10;
class Array
{
public:
// constructors
Array(int itsSize = DefaultSize);
Array(const Array &rhs);
~Array() { delete [] pType;}
// operators
Array& operator=(const Array&);
int& operator[](int offSet);
const int& operator[](int offSet) const;
// accessors
int GetitsSize() const { return itsSize; }
// friend function
friend ostream& operator<< (ostream&, const Array&);
// define the exception classes
class xBoundary {};
class xSize
{
public:28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
xSize(int size):itsSize(size) {}
~xSize(){}
int GetSize() { return itsSize; }
private:
int itsSize;
};
class xTooBig : public xSize
{
public:
xTooBig(int size):xSize(size){}
};
class xTooSmall : public xSize
{
public:
xTooSmall(int size):xSize(size){}
};
class xZero : public xTooSmall
{
public:
xZero(int size):xTooSmall(size){}
};
class xNegative : public xSize
{
public:
xNegative(int size):xSize(size){}
};
private:
int *pType;
int itsSize;
};
Array::Array(int size):
itsSize(size)
{
if (size == 0)
throw xZero(size);
if (size > 30000)
throw xTooBig(size);
if (size <1)
throw xNegative(size);74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
endl;
111:
112:
113:
114:
115:
116:
117:
118:
if (size < 10)
throw xTooSmall(size);
pType = new int[size];
for (int i = 0; i<size; i++)
pType[i] = 0;
}
int& Array::operator[] (int offSet)
{
int size = GetitsSize();
if (offSet >= 0 && offSet < GetitsSize())
return pType[offSet];
throw xBoundary();
return pType[0];
}
const int& Array::operator[] (int offSet) const
{
int size = GetitsSize();
if (offSet >= 0 && offSet < GetitsSize())
return pType[offSet];
throw xBoundary();
return pType[0];
}
int main()
{
try
{
Array intArray(9);
for (int j = 0; j< 100; j++)
{
intArray[j] = j;
cout << "intArray[" << j << "] okay..." <<
}
}
catch (Array::xBoundary)
{
cout << "Unable to process your input!\n";
}
catch (Array::xZero theException)
{119:
<< endl;
120:
endl;
121:
122:
123:
124:
125:
endl;
126:
127:
128:
129:
130:
endl;
131:
132:
133:
134:
what!\n";
135:
136:
137:
138: }
cout << "You asked for an Array of zero objects!"
cout << "Received " << theException.GetSize() <<
}
catch (Array::xTooBig theException)
{
cout << "This Array is too big..." << endl;
cout << "Received " << theException.GetSize() <<
}
catch (Array::xTooSmall theException)
{
cout << "This Array is too small..." << endl;
cout << "Received " << theException.GetSize() <<
}
catch (...)
{
cout << "Something went wrong, but I've no idea
}
cout << "Done.\n";
return 0;
Output: This array is too small...
Received 9
Done.
Analysis: The declaration of xSize has been modified to include a member variable, itsSize, on
line 32 and a member function, GetSize(), on line 30. Additionally, a constructor has been added
that takes an integer and initializes the member variable, as shown on line 28.
The derived classes declare a constructor that does nothing but initialize the base class. No other
functions were declared, in part to save space in the listing.
The catch statements on lines 113 to 135 are modified to name the exception they catch,
theException, and to use this object to access the data stored in itsSize.
NOTE: Keep in mind that if you are constructing an exception, it is because an
exception has been raised: Something has gone wrong, and your exception should be
careful not to kick off the same problem. Therefore, if you are creating an
OutOfMemory exception, you probably don't want to allocate memory in its
constructor.It is tedious and error-prone to have each of these catch statements individually print the appropriate
message. This job belongs to the object, which knows what type of object it is and what value it
received. Listing 20.5 takes a more object-oriented approach to this problem, using virtual functions
so that each exception "does the right thing."
Listing 20.5.Passing by reference and using virtual functions in exceptions.
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
#include <iostream.h>
const int DefaultSize = 10;
class Array
{
public:
// constructors
Array(int itsSize = DefaultSize);
Array(const Array &rhs);
~Array() { delete [] pType;}
// operators
Array& operator=(const Array&);
int& operator[](int offSet);
const int& operator[](int offSet) const;
// accessors
int GetitsSize() const { return itsSize; }
// friend function
friend ostream& operator<<
(ostream&, const Array&);
// define the exception classes
class xBoundary {};
class xSize
{
public:
xSize(int size):itsSize(size) {}
~xSize(){}
virtual int GetSize() { return itsSize; }
virtual void PrintError()
{
cout << "Size error. Received: ";
cout << itsSize << endl;
}
protected:38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
int itsSize;
};
class xTooBig : public xSize
{
public:
xTooBig(int size):xSize(size){}
virtual void PrintError()
{
cout << "Too big! Received: ";
cout << xSize::itsSize << endl;
}
};
class xTooSmall : public xSize
{
public:
xTooSmall(int size):xSize(size){}
virtual void PrintError()
{
cout << "Too small! Received: ";
cout << xSize::itsSize << endl;
}
};
class xZero : public xTooSmall
{
public:
xZero(int size):xTooSmall(size){}
virtual void PrintError()
{
cout << "Zero!!. Received: " ;
cout << xSize::itsSize << endl;
}
};
class xNegative : public xSize
{
public:
xNegative(int size):xSize(size){}
virtual void PrintError()
{
cout << "Negative! Received: ";
cout << xSize::itsSize << endl;
}
};84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
private:
int *pType;
int itsSize;
};
Array::Array(int size):
itsSize(size)
{
if (size == 0)
throw xZero(size);
if (size > 30000)
throw xTooBig(size);
if (size <1)
throw xNegative(size);
if (size < 10)
throw xTooSmall(size);
pType = new int[size];
for (int i = 0; i<size; i++)
pType[i] = 0;
}
int& Array::operator[] (int offSet)
{
int size = GetitsSize();
if (offSet >= 0 && offSet < GetitsSize())
return pType[offSet];
throw xBoundary();
return pType[0];
}
const int& Array::operator[] (int offSet) const
{
int size = GetitsSize();
if (offSet >= 0 && offSet < GetitsSize())
return pType[offSet];
throw xBoundary();
return pType[0];
}
int main()
{
try
{130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151: }
Array intArray(9);
for (int j = 0; j< 100; j++)
{
intArray[j] = j;
cout << "intArray[" << j << "] okay...\n";
}
}
catch (Array::xBoundary)
{
cout << "Unable to process your input!\n";
}
catch (Array::xSize& theException)
{
theException.PrintError();
}
catch (...)
{
cout << "Something went wrong!\n";
}
cout << "Done.\n";
return 0;
Output: Too small! Received: 9
Done.
Analysis: Listing 20.5 declares a virtual method in the xSize class, PrintError(), that prints an
error message and the actual size of the class. This is overridden in each of the derived classes.
On line 141, the exception object is declared to be a reference. When PrintError() is called with
a reference to an object, polymorphism causes the correct version of PrintError() to be invoked.
The code is cleaner, easier to understand, and easier to maintain.
Exceptions and Templates
When creating exceptions to work with templates, you have a choice: you can create an exception for
each instance of the template, or you can use exception classes declared outside the template
declaration. Listing 20.6 illustrates both approaches.
Listing 20.6. Using exceptions with templates.
0:
1:
2:
3:
#include <iostream.h>
const int DefaultSize = 10;
class xBoundary {};4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
template <class T>
class Array
{
public:
// constructors
Array(int itsSize = DefaultSize);
Array(const Array &rhs);
~Array() { delete [] pType;}
// operators
Array& operator=(const Array<T>&);
T& operator[](int offSet);
const T& operator[](int offSet) const;
// accessors
int GetitsSize() const { return itsSize; }
// friend function
friend ostream& operator<< (ostream&, const Array<T>&);
// define the exception classes
class xSize {};
private:
int *pType;
int itsSize;
};
template <class T>
Array<T>::Array(int size):
itsSize(size)
{
if (size <10 || size > 30000)
throw xSize();
pType = new T[size];
for (int i = 0; i<size; i++)
pType[i] = 0;
}
template <class T>
Array<T>& Array<T>::operator=(const Array<T> &rhs)
{
if (this == &rhs)
return *this;50:
delete [] pType;
51:
itsSize = rhs.GetitsSize();
52:
pType = new T[itsSize];
53:
for (int i = 0; i<itsSize; i++)
54:
pType[i] = rhs[i];
55:
}
56:
template <class T>
57:
Array<T>::Array(const Array<T> &rhs)
58:
{
59:
itsSize = rhs.GetitsSize();
60:
pType = new T[itsSize];
61:
for (int i = 0; i<itsSize; i++)
62:
pType[i] = rhs[i];
63:
}
64:
65:
template <class T>
66:
T& Array<T>::operator[](int offSet)
67:
{
68:
int size = GetitsSize();
69:
if (offSet >= 0 && offSet < GetitsSize())
70:
return pType[offSet];
71:
throw xBoundary();
72:
return pType[0];
73:
}
74:
75:
template <class T>
76:
const T& Array<T>::operator[](int offSet) const
77:
{
78:
int mysize = GetitsSize();
79:
if (offSet >= 0 && offSet < GetitsSize())
80:
return pType[offSet];
81:
throw xBoundary();
82:
}
83:
84:
template <class T>
85:
ostream& operator<< (ostream& output, const Array<T>&
theArray)
86:
{
87:
for (int i = 0; i<theArray.GetitsSize(); i++)
88:
output << "[" << i << "] " << theArray[i] << endl;
89:
return output;
90:
}
91:
92:
93:
int main()
94:
{95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116: }
try
{
Array<int> intArray(9);
for (int j = 0; j< 100; j++)
{
intArray[j] = j;
cout << "intArray[" << j << "] okay..." << endl;
}
}
catch (xBoundary)
{
cout << "Unable to process your input!\n";
}
catch (Array<int>::xSize)
{
cout << "Bad Size!\n";
}
cout << "Done.\n";
return 0;
Output: Bad Size!
Done.
Analysis: The first exception, xBoundary, is declared outside the template definition on line 3. The
second exception, xSize, is declared from within the definition of the template, on line 27.
The exception xBoundary is not tied to the template class, but can be used like any other class.
xSize is tied to the template, and must be called based on the instantiated Array. You can see the
difference in the syntax for the two catch statements. Line 105 shows catch (xBoundary), but
line 109 shows catch (Array<int>::xSize). The latter is tied to the instantiation of an
integer Array.
Exceptions Without Errors
When C++ programmers get together for a virtual beer in the cyberspace bar after work, talk often
turns to whether exceptions should be used for routine conditions. Some maintain that by their nature,
exceptions should be reserved for those predictable but exceptional circumstances (hence the name!)
that a programmer must anticipate, but that are not part of the routine processing of the code.
Others point out that exceptions offer a powerful and clean way to return through many layers of
function calls without danger of memory leaks. A frequent example is this: The user requests an
action in a GUI environment. The part of the code that catches the request must call a member
function on a dialog manager, which in turn calls code that processes the request, which calls codethat decides which dialog box to use, which in turn calls code to put up the dialog box, which finally
calls code that processes the user's input. If the user presses Cancel, the code must return to the very
first calling method, where the original request was handled.
One approach to this problem is to put a try block around the original call and catch
CancelDialog as an exception, which can be raised by the handler for the Cancel button. This is
safe and effective, but pressing Cancel is a routine circumstance, not an exceptional one.
This frequently becomes something of a religious argument, but there is a reasonable way to decide
the question: Does use of exceptions in this way make the code easier or harder to understand? Are
there fewer risks of errors and memory leaks, or more? Will it be harder or easier to maintain this
code? These decisions, like so many others, will require an analysis of the trade-offs; there is no
single, obvious right answer.
Bugs and Debugging
You saw on Day 17 how to use assert() to trap runtime bugs during the testing phase, and today
you saw how to use exceptions to trap runtime problems. There is one more powerful weapon you'll
want to add to your arsenal as you attack bugs: the debugger.
Nearly all modern development environments include one or more high-powered debuggers. The
essential idea of using a debugger is this: You run the debugger, which loads your source code, and
then you run your program from within the debugger. This allows you to see each instruction in your
program as it executes, and to examine your variables as they change during the life of your program.
All compilers will let you compile with or without symbols. Compiling with symbols tells the
compiler to create the necessary mapping between your source code and the generated program; the
debugger uses this to point to the line of source code that corresponds to the next action in the
program.
Full-screen symbolic debuggers make this chore a delight. When you load your debugger, it will read
through all your source code and show the code in a window. You can step over function calls or
direct the debugger to step into the function, line by line.
With most debuggers, you can switch between the source code and the output to see the results of
each executed statement. More powerfully, you can examine the current state of each variable, look at
complex data structures, examine the value of member data within classes, and look at the actual
values in memory of various pointers and other memory locations. You can execute several types of
control within a debugger that include setting breakpoints, setting watch points, examining memory,
and looking at the assembler code.
Breakpoints
Breakpoints are instructions to the debugger that when a particular line of code is ready to beexecuted, the program should stop. This allows you to run your program unimpeded until the line in
question is reached. Breakpoints help you analyze the current condition of variables just before and
after a critical line of code.
Watch Points
It is possible to tell the debugger to show you the value of a particular variable or to break when a
particular variable is read or written to. Watch points allow you to set these conditions, and at times
even to modify the value of a variable while the program is running.
Examining Memory
At times it is important to see the actual values held in memory. Modern debuggers can show values
in the form of the actual variable; that is, strings can be shown as characters, longs as numbers rather
than as four bytes, and so forth. Sophisticated C++ debuggers can even show complete classes,
providing the current value of all the member variables, including the this pointer.
Assembler
Although reading through the source can be all that is required to find a bug, when all else fails it is
possible to instruct the debugger to show you the actual assembly code generated for each line of your
source code. You can examine the memory registers and flags, and generally delve as deep into the
inner workings of your program as required.
Learn to use your debugger. It can be the most powerful weapon in your holy war against bugs.
Runtime bugs are the hardest to find and squash, and a powerful debugger can make it possible, if not
easy, to find nearly all of them.
Summary
Today you learned how to create and use exceptions. Exceptions are objects that can be created and
thrown at points in the program where the executing code cannot handle the error or other exceptional
condition that has arisen. Other parts of the program, higher in the call stack, implement catch
blocks that catch the exception and take appropriate action.
Exceptions are normal, user-created objects, and as such may be passed by value or by reference.
They may contain data and methods, and the catch block may use that data to decide how to deal
with the exception.
It is possible to create multiple catch blocks, but once an exception matches a catch block's
signature, it is considered to be handled and is not given to the subsequent catch blocks. It is
important to order the catch blocks appropriately, so that more specific catch blocks have first
chance and more general catch blocks handle those not otherwise handled.This chapter also examined some of the fundamentals of symbolic debuggers, including using watch
points, breakpoints, and so forth. These tools can help you zero in on the part of your program that is
causing the error, and let you see the value of variables as they change during the course of the
execution of the program.
Q&A
Q. Why bother with raising exceptions? Why not handle the error right where it
happens?
A. Often, the same error can be generated in a number of different parts of the code.
Exceptions let you centralize the handling of errors. Additionally, the part of the code that
generates the error may not be the best place to determine how to handle the error.
Q. Why generate an object? Why not just pass an error code?
A. Objects are more flexible and powerful than error codes. They can convey more
information, and the constructor/destructor mechanisms can be used for the creation and
removal of resources that may be required to properly handle the exceptional condition.
Q. Why not use exceptions for non-error conditions? Isn't it convenient to be able to
express-train back to previous areas of the code, even when non-exceptional conditions
exist?
A. Yes, some C++ programmers use exceptions for just that purpose. The danger is that
exceptions might create memory leaks as the stack is unwound and some objects are
inadvertently left in the free store. With careful programming techniques and a good compiler,
this can usually be avoided. Otherwise, it is a matter of personal aesthetic; some programmers
feel that by their nature exceptions should not be used for routine conditions.
Q. Does an exception have to be caught in the same place where the try block created the
exception?
A. No, it is possible to catch an exception anywhere in the call stack. As the stack is unwound,
the exception is passed up the stack until it is handled.
Q. Why use a debugger when you can use cout with conditional (#ifdef debug) compiling?
A. The debugger provides a much more powerful mechanism for stepping through your code
and watching values change without having to clutter your code with thousands of debugging
statements.
Workshop
The Workshop contains quiz questions to help solidify your understanding of the material covered and
exercises to provide you with experience in using what you've learned. Try to answer the quiz andexercise questions before checking the answers in Appendix D, and make sure you understand the
answers before going to the next chapter.
Quiz
1. What is an exception?
2. What is a try block?
3. What is a catch statement?
4. What information can an exception contain?
5. When are exception objects created?
6. Should you pass exceptions by value or by reference?
7. Will a catch statement catch a derived exception if it is looking for the base class?
8. If there are two catch statements, one for base and one for derived, which should come
first?
9. What does catch(...) mean?
10. What is a breakpoint?
Exercises
1. Create a try block, a catch statement, and a simple exception.
2. Modify the answer from Exercise 1, put data into the exception, along with an accessor
function, and use it in the catch block.
3. Modify the class from Exercise 2 to be a hierarchy of exceptions. Modify the catch block
to use the derived objects and the base objects.
4. Modify the program from Exercise 3 to have three levels of function calls.
5. BUG BUSTERS: What is wrong with the following code?
class xOutOfMemory
{
public:
xOutOfMemory( const String& message ) : itsMsg( message ){}
~xOutOfMemory(){}
virtual const String& Message(){ return itsMsg};
private:
String itsMsg;}
main()
{
try {
char *var = new char;
if ( var == 0 )
throw xOutOfMemory();
}
catch( xOutOfMemory& theException )
{
cout << theException.Message() << "\n";
}
}
Whats Next
Congratulations! You are nearly done with a full three-week intensive introduction to C++. By now
you should have a solid understanding of C++, but in modern programming there is always more to
learn. This chapter will fill in some missing details and then set the course for continued study.
Today you will learn
Every implementation of C++ includes the standard libraries, and most include additional libraries as
well. Libraries are sets of functions that can be linked into your code. You've already used a number
of standard library functions and classes, most notably from the iostreams library.
To use a library, you typically include a header file in your source code, much as you did by writing
#include <iostream.h> in many of the examples in this book. The angle brackets around the
filename are a signal to the compiler to look in the directory where you keep the header files for your
compiler's standard libraries.There are dozens of libraries, covering everything from file manipulation to setting the date and time
to math functions. Today I will review just a few of the most popular functions and classes in the
standard library that have not yet been covered in this book.
String
The most popular library is almost certainly the string library, with perhaps the function strlen()
called most often. strlen() returns the length of a null-terminated string. Listing 21.1 illustrates its
use.
Listing 21.1. strlen().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16: }
#include <iostream.h>
#include <string.h>
int main()
{
char buffer80];
do
{
cout << "Enter a string up to 80 characters: ";
cin.getline(buffer,80);
cout << "Your string is " << strlen(buffer);
cout << " characters long." << endl;
}
while (strlen(buffer));
cout << "\nDone." << endl;
return 0;
Output: Enter a string up to 80 characters: This sentence has 31
characters
Your string is 31 characters long.
Enter a string up to 80 characters: This sentence no verb
Your string is 21 characters long.
Enter a string up to 80 characters:
Your string is 0 characters long.
Done.
Analysis: On line 6, a character buffer is created, and on line 9 the user is prompted to enter a string.
As long as the user enters a string, the length of the string is reported on line 11.
Note the test in the do...while() statement: while (strlen(buffer)). Since strlen()
will return 0 when the buffer is empty, and since 0 evaluates FALSE, this while loop will continue
as long as there are any characters in the buffer.strcpy() and strncpy()
The second most popular function in string.h probably was strcpy(), which copied one string
to another. This may now be diminished somewhat as C-style null-terminated strings have become
less important in C++; typically, string manipulation is done from within a vendor-supplied or user-
written string class. Nonetheless, your string class must support an assignment operator and a
copy constructor, and often these are implemented using strcpy(), as illustrated in Listing 21.2.
Listing 21.2. Using strcpy.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28: }
#include <iostream.h>
#include <string.h>
int main()
{
char stringOne80];
char stringTwo80];
stringOne0]='\0';
stringTwo0]='\0';
cout << "String One: " << stringOne << endl;
cout << "String Two: " << stringTwo << endl;
cout << "Enter a string: ";
cin.getline(stringOne,80);
cout << "\nString One: " << stringOne << endl;
cout << "String Two: " << stringTwo << endl;
cout << "copying..." << endl;
strcpy(stringTwo,stringOne);
cout
cout
cout
return
<< "\nString One: " << stringOne << endl;
<< "String Two: " << stringTwo << endl;
<< "\nDone " << endl;
0;
Output: String One:
String Two:
Enter a string: Test of strcpy()
String One:
String Two:
Test of strcpy()copying...
String One:
String Two:
Test of strcpy()
Test of strcpy()
Done
Analysis: Two C-style null-terminated strings are declared on lines 6 and 7. They are initialized to
empty on lines 9 and 10, and their values are printed on lines 12 and 13. The user is prompted to enter
a string, and the result is put in stringOne; the two strings are printed again, and only stringOne
has the input. Strcpy() is then called, and stringOne is copied into stringTwo.
Note that the syntax of strcpy() can be read as "copy into the first parameter the string in the
second parameter." What happens if the target string (stringTwo) is too small to hold the copied
string? This problem and its solution are illustrated in Listing 21.3.
Listing 21.3. Using strncpy().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
#include <iostream.h>
#include <string.h>
int main()
{
char stringOne[80];
char stringTwo[10];
char stringThree[80];
stringOne[0]='\0';
stringTwo[0]='\0';
stringThree[0]='\0';
cout << "String One: " << stringOne << endl;
cout << "String Two: " << stringTwo << endl;
cout << "String Three: " << stringThree << endl;
cout << "Enter a long string: ";
cin.getline(stringOne,80);
strcpy(stringThree,stringOne);
//
strcpy(stringTwo,stringOne);
cout << "\nString One: " << stringOne << endl;
cout << "String Two: " << stringTwo << endl;
cout << "String Three: " << stringThree << endl;
strncpy(stringTwo,stringOne,9);29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40: }
cout << "\nString One: " << stringOne << endl;
cout << "String Two: " << stringTwo << endl;
cout << "String Three: " << stringThree << endl;
stringTwo[9]='\0';
cout
cout
cout
cout
return
<<
<<
<<
<<
0;
"\nString One: " << stringOne << endl;
"String Two: " << stringTwo << endl;
"String Three: " << stringThree << endl;
"\nDone." << endl;
Output: String One:
String Two:
String Three:
Enter a long string: Now is the time for all...
String One: Now is the time for all...
String Two:
String Three: Now is the time for all...
String One: Now is the time for all...
String Two: Now is th_+||
String Three: Now is the time for all...
String One: Now is the time for all...
String Two: Now is th
String Three: Now is the time for all...
Done.
Analysis: On lines 6, 7, and 8, three string buffers are declared. Note that stringTwo is declared to
be only 10 characters, while the others are 80. All three are initialized to zero length on lines 10 to 12
and are printed on lines 14 to 16.
The user is prompted to enter a string, and that string is copied to string three on line 20. Line 21 is
commented out; copying this long string to stringTwo caused a crash on my computer because it
wrote into memory that was critical to the program.
The standard function strcpy() starts copying at the address pointed to by the first parameter (the
array name), and it copies the entire string without ensuring that you've allocated room for it!
The standard library offers a second, safer function, strncpy(), which copies only a specified
number of characters to the target string. The n in the middle of the function name strncpy()
stands for number. This is a convention used throughout the standard libraries.On line 27, the first nine characters of stringOne are copied to stringTwo and the result is
printed. Because strncpy() does not put a null at the end of the copied string, the result is not what
was intended. Note that strcpy() does null-terminate the copied string, but strncpy() does not,
just to keep life interesting.
The null is added on line 33, and the strings are then printed a final time.
strcat() and strncat()
Related to strcpy() and strncpy() are the standard functions strcat() and strncat().
The former concatenates one string to another; that is, it appends the string it takes as its second
parameter to the end of the string it takes as its first parameter. strncat(), as you might expect,
appends the first n characters of one string to the other. Listing 21.4 illustrates their use.
Listing 21.4. Using strcat() and strncat().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29: }
#include <iostream.h>
#include <string.h>
int main()
{
char stringOne[255];
char stringTwo[255];
stringOne[0]='\0';
stringTwo[0]='\0';
cout << "Enter a string: ";
cin.getline(stringOne,80);
cout << "Enter a second string: ";
cin.getline(stringTwo,80);
cout << "String One: " << stringOne << endl;
cout << "String Two: " << stringTwo << endl;
strcat(stringOne," ");
strncat(stringOne,stringTwo,10);
cout << "String One: " << stringOne << endl;
cout << "String Two: " << stringTwo << endl;
return 0;Output: Enter a string: Oh beautiful
Enter a second string: for spacious skies for amber waves of grain
String One: Oh beautiful
String Two: for spacious skies for amber waves of grain
String One: Oh beautiful for spacio
String Two: for spacious skies for amber waves of grain
Analysis: On lines 7 and 8, two character arrays are created, and the user is prompted for two strings,
which are put into the two arrays.
A space is appended to stringOne on line 22, and on line 23, the first ten characters of
stringTwo are appended to stringOne. The result is printed on lines 25 and 26.
Other String Functions
The string library provides a number of other string functions, including those used to find
occurrences of various characters or "tokens" within a string. If you need to find a comma or a
particular word as it occurs in a string, look to the string library to see whether the function you need
already exists.
Time and Date
The time library provides a number of functions for obtaining a close approximation of the current
time and date, and for comparing times and dates to one another.
The center of this library is a structure, tm, which consists of nine integer values for the second,
minute, hour, day of the month, number of the month (where January=0), the number of years since
1900, the day (where Sunday=0), the day of the year (0-365), and a Boolean value establishing
whether daylight saving time is in effect. (This last may not be supported on some systems.)
Most time functions expect a variable of type time_t or a pointer to a variable of this type. There
are conversion routines to turn such a variable into a tm data structure.
The standard library supplies the function time(), which takes a pointer to a time_t variable and
fills it with the current time. It also provides ctime(), which takes the time_t variable filled by
time() and returns an ASCII string that can be used for printing. If you need more control over the
output, however, you can pass the time_t variable to local_time(), which will return a pointer
to a tm structure. Listing 21.5 illustrates these various time functions.
Listing 21.5. Using ctime().
1:
2:
3:
#include <time.h>
#include <iostream.h>4:
int main()
5:
{
6:
time_t currentTime;
7:
8:
// get and print the current time
9:
time (&currentTime); // fill now with the current time
10:
cout << "It is now " << ctime(&currentTime) << endl;
11:
12:
struct tm * ptm= localtime(&currentTime);
13:
14:
cout << "Today is " << ((ptm->tm_mon)+1) << "/";
15:
cout << ptm->tm_mday << "/";
16:
cout << ptm->tm_year << endl;
17:
18:
cout << "\nDone.";
19:
return 0;
20: }
Output: It is now Mon Mar 31 13:50:10 1997
Today is 3/31/97
Done.
Analysis: On line 6, CurrentTime is declared to be a variable of type time_t. The address of this
variable is passed to the standard time library function time(), and the variable currentTime is
set to the current date and time. The address of this variable is then passed to ctime(), which
returns an ASCII string that is in turn passed to the cout statement on line 12.The address of
currentTime is then passed to the standard time library function localtime(), and a pointer to
a tm structure is returned, which is used to initialize the local variable ptm. The member data of this
structure is then accessed to print the current month, day of the month, and year.
stdlib
stdlib is something of a miscellaneous collection of functions that did not fit into the other
libraries. It includes simple integer math functions, sorting functions (including qsort(), one of the
fastest sorts available), and text conversions for moving from ASCII text to integers, long, float,
and so forth.
The functions in stdlib you are likely to use most often include atoi(), itoa(), and the family
of related functions. atoi() provides ASCII to integer conversion. atoi() takes a single
argument: a pointer to a constant character string. It returns an integer (as you might expect). Listing
21.6 illustrates its use.
Listing 21.6. Using atoi() and related functions.1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19: }
#include <stdlib.h>
#include <iostream.h>
int main()
{
char buffer[80];
cout << "Enter a number: ";
cin >> buffer;
int number;
// number = buffer; compile error
number = atoi(buffer);
cout << "Here's the number: " << number << endl;
// int sum = buffer + 5;
int sum = atoi(buffer) + 5;
cout << "Here's sum: " << sum << endl;
return 0;
Output: Enter a number: 9
Here's the number: 9
Here's sum: 14
Analysis: On line 6 of this simple program, an 80-character buffer is allocated, and on line 7 the user
is prompted for a number. The input is taken as text and written into the buffer.
On line 10, an int variable, number, is declared, and on line 11 the program attempts to assign the
contents of the buffer to the int variable. This generates a compile-time error and is commented out.
On line 12, the problem is solved by invoking the standard library function atoi(), passing in the
buffer as the parameter. The return value, the integer value of the text string, is assigned to the integer
variable number and printed on line 13.
On line 15, a new integer variable, sum, is declared, and an attempt is made to assign to it the result of
adding the integer constant 5 to the buffer. This, too, fails and is solved by calling the standard
function atoi().
NOTE: Some compilers implement standard conversion procedures (such as atoi())
using macros. You can usually use these functions without worrying about how they are
implemented. Check your compiler's documentation for details.
qsort()
At times you may want to sort a table or an array; qsort() provides a quick and easy way to do so.The hard part of using qsort() is setting up the structures to pass in.
qsort() takes four arguments. The first is a pointer to the start of the table to be sorted (an array
name works just fine), the second is the number of elements in the table, the third is the size of each
element, and the fourth is a pointer to a comparison function.
The comparison function must return an int, and must take as its parameters two constant void
pointers. void pointers aren't used very often in C++, as they diminish the type checking, but they
have the advantage that they can be used to point to items of any type. If you were writing your own
qsort() function, you might consider using templates instead. Listing 21.7 illustrates how to use
the standard qsort() function.
Listing 21.7. Using qsort().
1:
/* qsort example */
2:
3:
#include <iostream.h>
4:
#include <stdlib.h>
5:
6:
// form of sort_function required by qsort
7:
int sortFunction( const void *intOne, const void *intTwo);
8:
9:
const int TableSize = 10; // array size
10:
11:
int main(void)
12:
{
13:
int i,table[TableSize];
14:
15:
// fill the table with values
16:
for (i = 0; i<TableSize; i++)
17:
{
18:
cout << "Enter a number: ";
19:
cin >> table[i];
20:
}
21:
cout << "\n";
22:
23:
// sort the values
24:
qsort((void *)table, TableSize, sizeof(table[0]),
sortFunction);
25:
26:
// print the results
27:
for (i = 0; i < TableSize; i++)
28:
cout << "Table [" << i << "]: " << table[i] << endl;
29:
30:
cout << "Done." << endl;31:
return 0;
32:
}
33:
34:
int sortFunction( const void *a, const void *b)
35:
{
36:
int intOne = *((int*)a);
37:
int intTwo = *((int*)b);
38:
if (intOne < intTwo)
39:
return -1;
40:
if (intOne == intTwo)
41:
return 0;
42:
return 1;
43: }
Output: Enter a number: 2
Enter a number: 9
Enter a number: 12
Enter a number: 873
Enter a number: 0
Enter a number: 45
Enter a number: 93
Enter a number: 2
Enter a number: 66
Enter a number: 1
Table[0]:
Table[1]:
Table[2]:
Table[3]:
Table[4]:
Table[5]:
Table[6]:
Table[7]:
Table[8]:
Table[9]:
Done.
0
1
2
2
9
12
45
66
93
873
Analysis: On line 4, the standard library header is included, which is required by the qsort()
function. On line 7, the function sortFunction() is declared, which takes the required four
parameters.
An array is declared on line 13 and filled by user input on lines 16-20. qsort() is called on line 24,
casting the address of the array name table to be a void*.
Note that the parameters for sortFunction are not passed to the call to qsort(). The name of
the sortFunction, which is itself a pointer to that function, is the parameter to qsort().Once qsort() is running, it will fill the constant void pointers a and b with each value of the
array. If the first value is smaller than the second, the comparison function must return -1. If it is
equal, the comparison function must return 0. Finally, if the first value is greater than the second
value, the comparison function must return 1. This is reflected in the sortFunction(), as shown
on lines 34 to 43.
Other Libraries
Your C++ compiler supplies a number of other libraries, among them the standard input and output
libraries and the stream libraries that you've been using throughout this book. It is well worth your
time and effort to explore the documentation that came with your compiler to find out what these
libraries have to offer.
Bit Twiddling
Often you will want to set flags in your objects to keep track of the state of your object. (Is it in
AlarmState? Has this been initialized yet? Are you coming or going?)
You can do this with user-defined Booleans, but when you have many flags, and when storage size is
an issue, it is convenient to be able to use the individual bits as flags.
Each byte has eight bits, so in a four-byte long you can hold 32 separate flags. A bit is said to be
"set" if its value is 1, and clear if its value is 0. When you set a bit, you make its value 1, and when
you clear it, you make its value 0. (Set and clear are both adjectives and verbs). You can set and clear
bits by changing the value of the long, but that can be tedious and confusing.
NOTE: Appendix C, "Binary and Hexadecimal," provides valuable additional
information about binary and hexadecimal manipulation.
C++ provides bitwise operators that act upon the individual bits.These look like, but are different
from, the logical operators, so many novice programmers confuse them. The bitwise operators are
presented in Table 21.1.
Table 21.1. The Bitwise Operators.
symbol
&
|
^
~
operator
AND
OR
exclusive
OR
complementOperator AND
The AND operator (&) is a single ampersand, as opposed to the logical AND, which is two ampersands.
When you AND two bits, the result is 1 if both bits are 1, but 0 if either or both bits are 0. The way to
think of this is: The result is 1 if bit 1 is set and if bit 2 is set.
Operator OR
The second bitwise operator is OR (|). Again, this is a single vertical bar, as opposed to the logical
OR, which is two vertical bars. When you OR two bits, the result is 1 if either bit is set or if both are.
Operator Exclusive OR
The third bitwise operator is exclusive OR (^). When you exclusive OR two bits, the result is 1 if the
two bits are different.
The Complement Operator
The complement operator (~) clears every bit in a number that is set and sets every bit that is clear. If
the current value of the number is 1010 0011, the complement of that number is 0101 1100.
Setting Bits
When you want to set or clear a particular bit, you use masking operations. If you have a 4-byte flag
and you want to set bit 8 TRUE, you need to OR the flag with the value 128. Why? 128 is 1000
0000 in binary; thus the value of the eighth bit is 128. Whatever the current value of that bit (set or
clear), if you OR it with the value 128 you will set that bit and not change any of the other bits.
Let's assume that the current value of the 8 bits is 1010 0110 0010 0110. ORing 128 to it looks
like this:
9 8765 4321
1010 0110 0010 0110
// bit 8 is clear
|
0000 0000 1000 0000
// 128
----------------------
1010 0110 1010 0110
// bit 8 is set
There are a few things to note. First, as usual, bits are counted from right to left. Second, the value
128 is all zeros except for bit 8, the bit you want to set. Third, the starting number 1010 0110
0010 0110 is left unchanged by the OR operation, except that bit 8 was set. Had bit 8 already been
set, it would have remained set, which is what you want.
Clearing Bits
If you want to clear bit 8, you can AND the bit with the complement of 128. The complement of 128 isthe number you get when you take the bit pattern of 128 (1000 0000), set every bit that is clear, and
clear every bit that is set (0111 1111). When you AND these numbers, the original number is
unchanged, except for the eighth bit, which is forced to zero.
1010 0110 1010 0110 // bit 8 is set
& 1111 1111 0111 1111 // ~128
----------------------
1010 0110 0010 0110 // bit 8 cleared
To fully understand this solution, do the math yourself. Each time both bits are 1, write 1 in the
answer. If either bit is 0, write 0 in the answer. Compare the answer with the original number. It
should be the same except that bit 8 was cleared.
Flipping Bits
Finally, if you want to flip bit 8, no matter what its state, you exclusive OR the number with 128.
Thus:
1010 0110 1010 0110 // number
^ 0000 0000 1000 0000 // 128
----------------------
1010 0110 0010 0110 // bit flipped
^ 0000 0000 1000 0000 // 128
----------------------
1010 0110 1010 0110 // flipped back
DO set bits by using masks and the OR operator. DO clear bits by using masks and the
AND operator. DO flip bits using masks and the exclusive OR operator.
Bit Fields
There are circumstances under which every byte counts, and saving six or eight bytes in a class can
make all the difference. If your class or structure has a series of Boolean variables, or variables that
can have only a very small number of possible values, you may save some room using bit fields.
Using the standard C++ data types, the smallest type you can use in your class is a type char, which
is one byte. You will usually end up using an int, which is two, or more often four, bytes. By using
bit fields, you can store eight binary values in a char and 32 such values in a long.
Here's how bit fields work: bit fields are named and accessed like any class member. Their type is
always declared to be unsigned int. After the bit field name, write a colon followed by a number.
The number is an instruction to the compiler as to how many bits to assign to this variable. If you
write 1, the bit will represent either the value 0 or 1. If you write 2, the bit can represent 0, 1, 2, or 3,a total of four values. A three-bit field can represent eight values, and so forth. Appendix C reviews
binary numbers. Listing 21.8 illustrates the use of bit fields.
Listing 21.8. Using bit fields.
0:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
#include <iostream.h>
#include <string.h>
enum
enum
enum
enum
STATUS { FullTime, PartTime } ;
GRADLEVEL { UnderGrad, Grad } ;
HOUSING { Dorm, OffCampus };
FOODPLAN { OneMeal, AllMeals, WeekEnds, NoMeals };
class student
{
public:
student():
myStatus(FullTime),
myGradLevel(UnderGrad),
myHousing(Dorm),
myFoodPlan(NoMeals)
{}
~student(){}
STATUS GetStatus();
void SetStatus(STATUS);
unsigned GetPlan() { return myFoodPlan; }
private:
unsigned
unsigned
unsigned
unsigned
};
myStatus : 1;
myGradLevel: 1;
myHousing : 1;
myFoodPlan : 2;
STATUS student::GetStatus()
{
if (myStatus)
return FullTime;
else
return PartTime;
}
void student::SetStatus(STATUS theStatus)
{
myStatus = theStatus;
}41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
break;
66:
67:
break;
68:
69:
70:
71: }
int main()
{
student Jim;
if (Jim.GetStatus()== PartTime)
cout << "Jim is part time" << endl;
else
cout << "Jim is full time" << endl;
Jim.SetStatus(PartTime);
if (Jim.GetStatus())
cout << "Jim is part time" << endl;
else
cout << "Jim is full time" << endl;
cout << "Jim is on the " ;
char Plan[80];
switch (Jim.GetPlan())
{
case OneMeal: strcpy(Plan,"One meal"); break;
case AllMeals: strcpy(Plan,"All meals"); break;
case WeekEnds: strcpy(Plan,"Weekend meals");
case NoMeals: strcpy(Plan,"No Meals");break;
default : cout << "Something bad went wrong!\n";
}
cout << Plan << " food plan." << endl;
return 0;
Output: Jim is part time
Jim is full time
Jim is on the No Meals food plan.
Analysis: On lines 3 to 7, several enumerated types are defined. These serve to define the possible
values for the bit fields within the student class.
Student is declared in lines 8-27. While this is a trivial class, it is interesting in that all the data is
packed into five bits. The first bit represents the student's status, full-time or part-time. The second bit
represents whether or not this is an undergraduate. The third bit represents whether or not the student
lives in a dorm. The final two bits represent the four possible food plans.The class methods are written as for any other class, and are in no way affected by the fact that these
are bit fields and not integers or enumerated types.
The member function GetStatus() reads the Boolean bit and returns an enumerated type, but this
is not necessary. It could just as easily have been written to return the value of the bit field directly.
The compiler would have done the translation.
To prove that to yourself, replace the GetStatus() implementation
with this code:
STATUS student::GetStatus()
{
return myStatus;
}
There should be no change whatsoever to the functioning of the program. It is a matter of clarity when
reading the code; the compiler isn't particular.
Note that the code on line 46 must check the status and then print the meaningful message. It is
tempting to write this:
cout << "Jim is " << Jim.GetStatus() << endl;
That will simply print this:
Jim is 0
The compiler has no way to translate the enumerated constant PartTime into meaningful text.
On line 61, the program switches on the food plan, and for each possible value it puts a reasonable
message into the buffer, which is then printed on line 69. Note again that the switch statement could
have been written as follows:
case
case
case
case
0:
1:
2:
3:
strcpy(Plan,"One meal"); break;
strcpy(Plan,"All meals"); break;
strcpy(Plan,"Weekend meals"); break;
strcpy(Plan,"No Meals");break;
The most important thing about using bit fields is that the client of the class need not worry about the
data storage implementation. Because the bit fields are private, you can feel free to change them later
and the interface will not need to change.
StyleAs stated elsewhere in this book, it is important to adopt a consistent coding style, though in many
ways it doesn't matter which style you adopt. A consistent style makes it easier to guess what you
meant by a particular part of the code, and you avoid having to look up whether you spelled the
function with an initial cap or not the last time you invoked it.
The following guidelines are arbitrary; they are based on the guidelines used in projects I've worked
on in the past, and they've worked well. You can just as easily make up your own, but these will get
you started.
As Emerson said, "Foolish consistency is the hobgoblin of small minds," but having some consistency
in your code is a good thing. Make up your own, but then treat it as if it were dispensed by the
programming gods.
Indenting
Tab size should be four spaces. Make sure your editor converts each tab to four spaces.
Braces
How to align braces can be the most controversial topic between C and C++ programmers. Here are
the tips I suggest:
.)(
,**
*!'
Matching braces should be aligned vertically.
The outermost set of braces in a definition or declaration should be at the left margin.
Statements within should be indented. All other sets of braces should be in line with their
leading statements.
No code should appear on the same line as a brace. For example:
if (condition==true)
{
j = k;
SomeFunction();
}
m++;
Long Lines
Keep lines to the width displayable on a single screen. Code that is off to the right is easily
overlooked, and scrolling horizontally is annoying. When a line is broken, indent the following lines.
Try to break the line at a reasonable place, and try to leave the intervening operator at the end of the
previous line (as opposed to the beginning of the following line) so that it is clear that the line does
not stand alone and that there is more coming.In C++, functions tend to be far shorter than they were in C, but the old, sound advice still applies. Try
to keep your functions short enough to print the entire function on one page.
switch Statements
Indent switches as follows to conserve horizontal space:
switch(variable)
{
case ValueOne:
ActionOne();
break;
case ValueTwo:
ActionTwo();
break;
default:
assert("bad Action");
break;
}
Program Text
There are several tips you can use to create code that is easy to read. Code that is easy to read is easy
to maintain.
/(!
,'(
(#+
)''
Use whitespace to help readability.
Objects and arrays are really referring to one thing. Don't use spaces within object references
(., ->, []).
Unary operators are associated with their operands, so don't put a space between them. Do put
a space on the side away from the operand. Unary operators include !, ~, ++, --, -, * (for
pointers), & (casts), sizeof.
Binary operators should have spaces on both sides: +, =, *, /, %, >>, <<, <, >, ==, !=, &, |,
&&, ||, ?:, =, +=, and so on.
",+ Don't use lack of spaces to indicate precedence (4+ 3*2).
*$+ Put a space after commas and semicolons, not before.
!,& Parentheses should not have spaces on either side.
)"& Keywords, such as if, should be set off by a space: if (a == b).!&/ The body of a comment should be set off from the // with a space.
#// Place the pointer or reference indicator next to the type name, not the variable name:
char* foo;
int& theInt;
!/.
rather than
char *foo;
int &theInt;
(+%
Do not declare more than one variable on the same line.
Identifier Names
Here are some guidelines for working with identifiers.
!+' Identifier names should be long enough to be descriptive.
#+. Avoid cryptic abbreviations.
)-" Take the time and energy to spell things out.
+'%
&.)
Do not use Hungarian notation. C++ is strongly typed and there is no reason to put the type
into the variable name. With user-defined types (classes), Hungarian notation quickly breaks
down. The exceptions to this may be to use a prefix for pointers (p) and references (r), as well
as for class member variables (its).
Short names (i, p, x, and so on) should only be used where their brevity makes the code more
readable and where the usage is so obvious that a descriptive name is not needed.
#'" The length of a variable's name should be proportional to its scope.
(.' Make sure identifiers look and sound different from one another to minimize confusion.
'!.
Function (or method) names are usually verbs or verb-noun phrases: Search(), Reset(),
FindParagraph(), ShowCursor(). Variable names are usually abstract nouns, possibly
with an additional noun: count, state, windSpeed, windowHeight. Boolean variables
should be named appropriately: windowIconized, fileIsOpen.
Spelling and Capitalization of NamesSpelling and capitalization should not be overlooked when creating your own style. Some tips for
these areas include the following:
-(-
+!/
/("
Use all uppercase and underscore to separate the logical words of names, such as
SOURCE_FILE_TEMPLATE. Note, however, that these are rare in C++. Consider using
constants and templates in most cases.
All other identifiers should use mixed case--no underscores. Function names, methods, class,
typedef, and struct names should begin with a capitalized letter. Elements such as data
members or locals should begin with a lowercase letter.
Enumerated constants should begin with a few lowercase letters as an abbreviation for the
enum. For example:
enum TextStyle
{
tsPlain,
tsBold,
tsItalic,
tsUnderscore,
};
Comments
Comments can make it much easier to understand a program. Sometimes you will not work on a
program for several days or even months. In this time you can forget what certain code does or why it
has been included. Problems in understanding code can also occur when someone else reads your
code. Comments that are applied in a consistent, well thought out style can be well worth the effort.
There are several tips to remember concerning comments:
.*-
$#*
Wherever possible, use C++ // comments rather than the /* */ style.
Higher-level comments are infinitely more important than process details. Add value; do not
merely restate the code.
n++; // n is incremented by one
,&(
)#-
This comment isn't worth the time it takes to type it in. Concentrate on the semantics of
functions and blocks of code. Say what a function does. Indicate side effects, types of
parameters, and return values. Describe all assumptions that are made (or not made), such as
"assumes n is non-negative" or "will return -1 if x is invalid".
Within complex logic, use comments to indicate the conditions that exist at that point in the
code.
Use complete English sentences with appropriate punctuation and capitalization. The extratyping is worth it. Don't be overly cryptic and don't abbreviate. What seems exceedingly clear
to you as you write code will be amazingly obtuse in a few months.
"&+
Use blank lines freely to help the reader understand what is going on. Separate statements into
logical groups.
Access
The way you access portions of your program should also be consistent. Some tips for access include
these:
*-)
)%"
'")
+%!
*+(
Always use public:, private:, and protected: labels; don't rely on the defaults.
List the public members first, then protected, then private. List the data members in a group
after the methods.
Put the constructor(s) first in the appropriate section, followed by the destructor. List
overloaded methods with the same name adjacent to each other. Group accessor functions
together when possible.
Consider alphabetizing the method names within each group and alphabetizing the member
variables. Be sure to alphabetize the filenames in include statements.
Even though the use of the virtual keyword is optional when overriding, use it anyway; it
helps to remind you that it is virtual, and also keeps the declaration consistent.
Class Definitions
Try to keep the definitions of methods in the same order as the declarations. It makes things easier to
find.
When defining a function, place the return type and all other modifiers on a previous line so that the
class name and function name begin on the left margin. This makes it much easier to find functions.
include Files
Try as hard as you can to keep from including files into header files. The ideal minimum is the header
file for the class this one derives from. Other mandatory includes will be those for objects that are
members of the class being declared. Classes that are merely pointed to or referenced only need
forward references of the form.
Don't leave out an include file in a header just because you assume that whatever CPP file includes
this one will also have the needed include.TIP: All header files should use inclusion guards.
assert()
Use assert() freely. It helps find errors, but it also greatly helps a reader by making it clear what
the assumptions are. It also helps to focus the writer's thoughts around what is valid and what isn't.
const
Use const wherever appropriate: for parameters, variables, and methods. Often there is a need for
both a const and a non-const version of a method; don't use this as an excuse to leave one out. Be
very careful when explicitly casting from const to non-const and vice versa (there are times when
this is the only way to do something), but be certain that it makes sense, and include a comment.
Next Steps
You've spent three long, hard weeks working at C++, and you are now a competent C++ programmer,
but you are by no means finished. There is much more to learn and many more places you can get
valuable information as you move from novice C++ programmer to expert.
The following sections recommend a number of specific sources of information, and these
recommendations reflect only my personal experience and opinions. There are dozens of books on
each of these topics, however, so be sure to get other opinions before purchasing.
Where to Get Help and Advice
The very first thing you will want to do as a C++ programmer will be to tap into one or another C++
conference on an online service. These groups supply immediate contact with hundreds or thousands
of C++ programmers who can answer your questions, offer advice, and provide a sounding board for
your ideas.
I participate in the C++ Internet newsgroups (comp.lang.c++ and
comp.lang.c++.moderated), and I recommend them as excellent sources of information and
support.
Also, you may want to look for local user groups. Many cities have C++ interest groups where you
can meet other programmers and exchange ideas.
Required Reading
The very next book I'd run out and buy and read is
Meyers, Scott. Effective C++ (ISBN: 0-201-56364-9). Addison-Wesley Publishing, 1993.This is by far the most useful book I've ever read, and I've read it three times.
Magazines
There is one more thing you can do to strengthen your skills: subscribe to a good magazine on C++
programming. The absolute best magazine of this kind, I believe, is C++ Report from SIGS
Publications. Every issue is packed with useful articles. Save them; what you don't care about today
will become critically important tomorrow.
You can reach C++ Report at SIGS Publications, P.O. Box 2031, Langhorne, PA 19047-9700. I have
no affiliation with the magazine (I work for two other publishers!), but their magazine is the best, bar
none.
Staying in Touch
If you have comments, suggestions, or ideas about this book or other books, I'd love to hear them.
Please write to me at jliberty@libertyassociates.com, or check out my Web site:
www.libertyassociates.com. I look forward to hearing from you.
DO look at other books. There's plenty to learn and no single book can teach you
everything you need to know. DON'T just read code! The best way to learn C++ is to
write C++ programs. DO subscribe to a good C++ magazine and join a good C++ user
group.
Summary
Today you saw how some of the standard libraries shipped with your C++ compiler can be used to
manage some routine tasks. Strcpy(), strlen(), and related functions can be used to manipulate
null-terminated strings. Although these won't work with the string classes you create, you may find
that they provide functionality essential to implementing your own classes.
The time and date functions allow you to obtain and manipulate time structures. These can be used to
provide access to the system time for your programs, or they can be used to manipulate time and date
objects you create.
You also learned how to set and test individual bits, and how to allocate a limited number of bits to
class members.
Finally, C++ style issues were addressed, and resources were provided for further study.
Q&AQ. Why are the standard libraries included with C++ compilers, and when would you use
them?
A. They are included for backwards-compatibility with C. They are not type-safe, and they
don't work well with user-created classes, so their use is limited. Over time, you might expect
all of their functionality to be migrated into C++ specific libraries, at which time the standard
C libraries would become obsolete.
Q. When would you use bit structures rather than simply using integers?
A. When the size of the object is crucial. If you are working with limited memory or with
communications software, you may find that the savings offered by these structures is essential
to the success of your product.
Q. Why do style wars generate so much emotion?
A. Programmers become very attached to their habits. If you are used to this indentation,
if (SomeCondition){
// statements
}
// closing brace
it is a difficult transition to give it up. New styles look wrong and create confusion. If you get
bored, try logging onto a popular online service and asking which indentation style works best,
which editor is best for C++, or which product is the best word processor. Then sit back and
watch as ten thousand messages are generated, all contradicting one another.
Q. What is the very next thing to read?
A. Tough question. If you want to review the fundamentals, read one of the other primers. If
you want to hone C++, run out and get Scott Meyers' Effective C++. Finally, if you want to
write for Windows or the Mac, it might make sense to pick up a primer on the
platform.
Q. Is that it?
A. Yes! You've learned C++, but...no. Ten years ago it was possible for one person to learn all
there was to know about microcomputers, or at least to feel pretty confident that he was close.
Today it is out of the question: You can't possibly catch up, and even as you try the industry is
changing. Be sure to keep reading, and stay in touch with the resources that will keep you up
with the latest changes: magazines and online services.
Quiz
1. What is the difference between strcpy() and strncpy()?2. What does ctime() do?
3. What is the function to call to turn an ASCII string into a long?
4. What does the complement operator do?
5. What is the difference between OR and exclusive OR?
6. What is the difference between & and &&?
7. What is the difference between | and ||?
Exercises
1. Write a program to safely copy the contents of a 20-byte string to a 10-byte string,
truncating whatever won't fit.
2. Write a program that tells the current date in the form 7/28/94.
3. Write a program that creates 26 flags (labeled a-z). Prompt the user to enter a sentence, and
then quickly report on which letters were used by setting and then reading the flags.
4. Write a program that adds two numbers without using the addition operator (+). Hint: use
the bit operators!In Review
The following program brings together many of the advanced techniques you've learned during the
past three weeks of hard work. Week 3 in Review provides a template-based linked list with exception
handling. Examine it in detail; if you understand it fully, you are a C++ programmer.
WARNING: If your compiler does not support templates, or if your compiler does not
support try and catch, you will not be able to compile or run this listing.
Listing R3.1. Week 3 in Review listing.
0:
// **************************************************
1:
//
2:
// Title:
Week 3 in Review
3:
//
4:
// File:
Week3
5:
//
6:
// Description:
Provide a template-based linked list
7:
//
demonstration program with exception
handling
8:
//
9:
// Classes:
PART - holds part numbers and potentially other
10:
//
information about parts. This will be
the
11:
//
example class for the list to hold
12:
//
Note use of operator<< to print the
13:
//
information about a part based on its
14:
//
runtime type.
15:
//
16:
//
Node - acts as a node in a List
17:
//
18:
//
List - template-based list which provides
the
19:
//
mechanisms for a linked list
20:
//
21:
//
22:
// Author:
Jesse Liberty (jl)
23:
//24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
type
68:
//
//
//
//
//
//
//
Developed:
Target:
Pentium 200 Pro. 128MB RAM MVC 5.0
Platform independent
Rev History:
9/94 - First release (jl)
4/97 - Updated (jl)
**************************************************
#include <iostream.h>
// exception classes
class Exception {};
class OutOfMemory :
public Exception{};
class NullNode :
public Exception{};
class EmptyList :
public Exception {};
class BoundsError :
public Exception {};
// **************** Part ************
// Abstract base class of parts
class Part
{
public:
Part():itsObjectNumber(1) {}
Part(int ObjectNumber):itsObjectNumber(ObjectNumber){}
virtual ~Part(){};
int GetObjectNumber() const { return itsObjectNumber; }
virtual void Display() const =0; // must be overridden
private:
int itsObjectNumber;
};
// implementation of pure virtual function so that
// derived classes can chain up
void Part::Display() const
{
cout << "\nPart Number: " << itsObjectNumber << endl;
}
//
//
//
//
this one operator<< will be called for all part objects.
It need not be a friend as it does not access private data
It calls Display() which uses the required polymorphism
We'd like to be able to override this based on the real
// of thePart, but C++ does not support contravariance69:
ostream& operator<<( ostream& theStream,Part& thePart)
70:
{
71:
thePart.Display(); // virtual contravariance!
72:
return theStream;
73:
}
74:
75:
// **************** Car Part ************
76:
class CarPart : public Part
77:
{
78:
public:
79:
CarPart():itsModelYear(94){}
80:
CarPart(int year, int partNumber);
81:
int GetModelYear() const { return itsModelYear; }
82:
virtual void Display() const;
83:
private:
84:
int itsModelYear;
85:
};
86:
87:
CarPart::CarPart(int year, int partNumber):
88:
itsModelYear(year),
89:
Part(partNumber)
90:
{}
91:
92:
void CarPart::Display() const
93:
{
94:
Part::Display();
95:
cout << "Model Year: " << itsModelYear << endl;
96:
}
97:
98:
// **************** AirPlane Part ************
99:
class AirPlanePart : public Part
100:
{
101:
public:
102:
AirPlanePart():itsEngineNumber(1){};
103:
AirPlanePart(int EngineNumber, int PartNumber);
104:
virtual void Display() const;
105:
int GetEngineNumber()const { return itsEngineNumber; }
106:
private:
107:
int itsEngineNumber;
108:
};
109:
110:
AirPlanePart::AirPlanePart(int EngineNumber, int
PartNumber):
111:
itsEngineNumber(EngineNumber),
112:
Part(PartNumber)
113:
{}114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
void AirPlanePart::Display() const
{
Part::Display();
cout << "Engine No.: " << itsEngineNumber << endl;
}
// forward declaration of class List
template <class T>
class List;
// **************** Node ************
// Generic node, can be added to a list
// ************************************
template <class T>
class Node
{
public:
friend class List<T>;
Node (T*);
~Node();
void SetNext(Node * node) { itsNext = node; }
Node * GetNext() const;
T * GetObject() const;
private:
T* itsObject;
Node * itsNext;
};
// Node Implementations...
template <class T>
Node<T>::Node(T* pOjbect):
itsObject(pOjbect),
itsNext(0)
{}
template <class T>
Node<T>::~Node()
{
delete itsObject;
itsObject = 0;
delete itsNext;
itsNext = 0;
}160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
// Returns NULL if no next Node
template <class T>
Node<T> * Node<T>::GetNext() const
{
return itsNext;
}
template <class T>
T * Node<T>::GetObject() const
{
if (itsObject)
return itsObject;
else
throw NullNode();
}
// **************** List ************
// Generic list template
// Works with any numbered object
// ***********************************
template <class T>
class List
{
public:
List();
~List();
T*
Find(int & position, int ObjectNumber)
T*
GetFirst() const;
void
Insert(T *);
T*
operator[](int) const;
int
GetCount() const { return itsCount; }
private:
Node<T> * pHead;
int
itsCount;
};
// Implementations for Lists...
template <class T>
List<T>::List():
pHead(0),
itsCount(0)
{}
template <class T>
const;206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
(id)
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
List<T>::~List()
{
delete pHead;
}
template <class T>
T*
List<T>::GetFirst() const
{
if (pHead)
return pHead->itsObject;
else
throw EmptyList();
}
template <class T>
T * List<T>::operator[](int offSet) const
{
Node<T>* pNode = pHead;
if (!pHead)
throw EmptyList();
if (offSet > itsCount)
throw BoundsError();
for (int i=0;i<offSet; i++)
pNode = pNode->itsNext;
return
}
pNode->itsObject;
// find a given object in list based on its unique number
template <class T>
T*
List<T>::Find(int & position, int ObjectNumber) const
{
Node<T> * pNode = 0;
for (pNode = pHead, position = 0;
pNode!=NULL;
pNode = pNode->itsNext, position++)
{
if (pNode->itsObject->GetObjectNumber() == ObjectNumber)
break;
}
if (pNode == NULL)
return NULL;251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
else
return pNode->itsObject;
}
// insert if the number of the object is unique
template <class T>
void List<T>::Insert(T* pObject)
{
Node<T> * pNode = new Node<T>(pObject);
Node<T> * pCurrent = pHead;
Node<T> * pNext = 0;
int New = pObject->GetObjectNumber();
int Next = 0;
itsCount++;
if (!pHead)
{
pHead = pNode;
return;
}
// if this one is smaller than head
// this one is the new head
if (pHead->itsObject->GetObjectNumber() > New)
{
pNode->itsNext = pHead;
pHead = pNode;
return;
}
for (;;)
{
// if there is no next, append this new one
if (!pCurrent->itsNext)
{
pCurrent->itsNext = pNode;
return;
}
// if this goes after this one and before the next
// then insert it here, otherwise get the next
pNext = pCurrent->itsNext;
Next = pNext->itsObject->GetObjectNumber();
if (Next > New)
{
pCurrent->itsNext = pNode;
pNode->itsNext = pNext;
return;
}
pCurrent = pNext;
}
}
int main()
{
List<Part> theList;
int choice;
int ObjectNumber;
int value;
Part * pPart;
while (1)
{
cout << "(0)Quit (1)Car (2)Plane: ";
cin >> choice;
if (!choice)
break;
cout << "New PartNumber?: ";
cin >> ObjectNumber;
if (choice == 1)
{
cout << "Model Year?: ";
cin >> value;
try
{
pPart = new CarPart(value,ObjectNumber);
}
catch (OutOfMemory)
{
cout << "Not enough memory; Exiting..." << endl;
return 1;
}
}
else
{
cout << "Engine Number?: ";
cin >> value;
try343:
{
344:
pPart = new AirPlanePart(value,ObjectNumber);
345:
}
346:
catch (OutOfMemory)
347:
{
348:
cout << "Not enough memory; Exiting..." << endl;
349:
return 1;
350:
}
351:
}
352:
try
353:
{
354:
theList.Insert(pPart);
355:
}
356:
catch (NullNode)
357:
{
358:
cout << "The list is broken, and the node is null!"
<< endl;
359:
return 1;
360:
}
361:
catch (EmptyList)
362:
{
363:
cout << "The list is empty!" << endl;
364:
return 1;
365:
}
366:
}
367:
try
368:
{
369:
for (int i = 0; i < theList.GetCount(); i++ )
370:
cout << *(theList[i]);
371:
}
372:
catch (NullNode)
373:
{
374:
cout << "The list is broken, and the node is null!"
<< endl;
375:
return 1;
376:
}
377:
catch (EmptyList)
378:
{
379:
cout << "The list is empty!" << endl;
380:
return 1;
381:
}
382:
catch (BoundsError)
383:
{
384:
cout << "Tried to read beyond the end of the list!"
<< endl;
385:
return 1;386:
}
387:
return 0;
388: }
Output: (0)Quit (1)Car (2)Plane: 1
New PartNumber?: 2837
Model Year? 90
(0)Quit (1)Car (2)Plane: 2
New PartNumber?: 378
Engine Number?: 4938
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 4499
Model Year? 94
(0)Quit (1)Car (2)Plane: 1
New PartNumber?: 3000
Model Year? 93
(0)Quit (1)Car (2)Plane: 0
Part Number: 378
Engine No. 4938
Part Number: 2837
Model Year: 90
Part Number: 3000
Model Year: 93
Part Number 4499
Model Year: 94
Analysis: The Week 3 in Review listing modifies the program provided in Week 2 to add templates,
ostream processing, and exception handling. The output is identical.
On lines 35-39, a number of exception classes are declared. In the somewhat primitive exception
handling provided by this program, no data or methods are required of these exceptions; they serve as
flags to the catch statements, which print out a very simple warning and then exit. A more robust
program might pass these exceptions by reference and then extract context or other data from the
exception objects in an attempt to recover from the problem.
On line 44, the abstract base class Part is declared exactly as it was in Week 2. The only interesting
change here is in the non-class member operator<<(), which is declared on lines 69-73. Note that
this is neither a member of Part nor a friend of part, it simply takes a Part reference as one of its
arguments.You might want to have operator<< take a CarPart and an AirPlanePart in the hopes that
the correct operator<< would be called, based on whether a car part or an airplane part is passed.
Since the program passes a pointer to a part, however, and not a pointer to a car part or an airplane
part, C++ would have to call the right function based on the real type of one of the arguments to the
function. This is called contravariance and is not supported in C++.
There are only two ways to achieve polymorphism in C++: function polymorphism and virtual
functions. Function polymorphism won't work here because in every case you are matching the same
signature: the one taking a reference to a Part.
Virtual functions won't work here because operator<< is not a member function of Part. You
can't make operator<< a member function of Part because you want to invoke
cout << thePart
and that means that the actual call would be to cout.operator<<(Part&), and cout does not
have a version of operator<< that takes a Part reference!
To get around this limitation, the Week 3 program uses just one operator<<, taking a reference to
a Part. This then calls Display(), which is a virtual member function, and thus the right version
is called.
On lines 129-142, Node is defined as a template. It serves the same function as Node did in the Week
2 Review program, but this version of Node is not tied to a Part object. It can, in fact, be the node
for any type of object.
Note that if you try to get the object from Node, and there is no object, this is considered an
exception, and the exception is thrown on line 174.
On lines 181-197, a generic List class template is defined. This List class can hold nodes of any
objects that have unique identification numbers, and it keeps them sorted in ascending order. Each of
the list functions checks for exceptional circumstances and throws the appropriate exceptions as
required.
On lines 306-388, the driver program creates a list of two types of Part objects and then prints out
the values of the objects in the list by using the standard streams mechanism.Appendix A
Operator Precedence
It is important to understand that operators have a precedence, but it is not essential to memorize the
precedence.
New Term: Precedence is the order in which a program performs the operations in a formula.
If one operator has precedence over another operator, it is evaluated first.
Higher precedence operators "bind tighter" than lower precedence operators; thus, higher precedence
operators are evaluated first. The lower the rank in the following chart, the higher the precedence.
Table A.1. Operator Precedence .
Rank Name
Operator
1
scope resolution
::
2
member selection, subscripting,
. ->
function calls, postfix increment
()
and decrement
++ --
3
sizeof, prefix increment and decrement,
++ --
complement, and, not, unary minus and plus, ^ !
address of and dereference, new, new[], delete, - +
delete[], casting, sizeof(),
& *
()
member selection for pointer
4
.* ->*
5
multiply, divide, modulo
* / %
add, subtract
6
+ -
7
shift
<< >>
8
inequality relational
< <= > >=
9
equality, inequality
== !=
10
bitwise AND
&
11
bitwise exclusive OR
^12
13
14
15
16 bitwise OR
logical AND
logical OR
conditional
assignment operators
17
18 throw operator
comma
|
&&
||
?:
= *= /= %=
+= -= <<= >>=
&= |= ^=
throw
,Appendix B
C++ Keywords
Keywords are reserved to the compiler for use by the language. You cannot define classes, variables,
or functions that have these keywords as their names. The list is a bit arbitrary, as some of the
keywords are specific to a given compiler. Your mileage may vary slightly:
auto
break
case
catch
char
class
const
continue
default
delete
do
double
else
enum
extern
float
for
friend
goto
if
int
long
mutable
new
operator
private
protected
public
register
return
short
signedsizeof
static
struct
switch
template
this
throw
typedef
union
unsigned
virtual
void
volatile
whileAppendix C
Binary and Hexadecimal
You learned the fundamentals of arithmetic so long ago, it is hard to imagine what it would be like without that knowledge. When you look at the number
145 you instantly see "one hundred and forty-five" without much reflection.
Understanding binary and hexadecimal requires that you re-examine the number 145 and see it not as a number, but as a code for a number.
Start small: Examine the relationship between the number three and "3." The numeral 3 is a squiggle on a piece of paper; the number three is an idea. The
numeral is used to represent the number.
The distinction can be made clear by realizing that three, 3, |||, III, and *** all can be used to represent the same idea of three.
In base 10 (decimal) math you use the numerals 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 to represent all numbers. How is the number ten represented?
One can imagine that we would have evolved a strategy of using the letter A to represent ten; or we might have used IIIIIIIIII to represent that idea. The
Romans used X. The Arabic system, which we use, makes use of position in conjunction with numerals to represent values. The first (right-most) column is
used for "ones," and the next column is used for tens. Thus, the number fifteen is represented as 15 (read "one, five"); that is, 1 ten and 5 ones.
Certain rules emerge, from which some generalizations can be made:
1. Base 10 uses the digits 0-9.
2. The columns are powers of ten: 1s, 10s, 100s, and so on.
3. If the third column is 100, the largest number you can make with two columns is 99. More generally, with n columns you can represent 0 to (10 n -1).
Thus, with 3 columns you can represent 0 to (10 3 -1) or 0-999.
Other Bases
It is not a coincidence that we use base 10; we have 10 fingers. One can imagine a different base, however. Using the rules found in base 10, you can describe
base 8:
1. The digits used in base 8 are 0-7.
2. The columns are powers of 8: 1s, 8s, 64, and so on.
3. With n columns you can represent 0 to 8 n -1.
To distinguish numbers written in each base, write the base as a subscript next to the number. The number fifteen in base 10 would be written as 15 10 and
read as "one, five, base ten."
Thus, to represent the number 15 10 in base 8 you would write 17 8 . This is read "one, seven, base eight." Note that it can also be read "fifteen" as that is the
number it continues to represent.
Why 17? The 1 means 1 eight, and the 7 means 7 ones. One eight plus seven ones equals fifteen. Consider fifteen asterisks:
*****
*****
*****
The natural tendency is to make two groups, a group of ten asterisks and another of five. This would be represented in decimal as 15 (1 ten and 5 ones). You
can also group the asterisks as
****
*******
****
That is, eight asterisks and seven. That would be represented in base eight as 17 8 . That is, one eight and seven ones.
Around the BasesYou can represent the number fifteen in base ten as 15, in base nine as 16 9 , in base 8 as 17 8 , in base 7 as 21 7 . Why 21 7 ? In base 7 there is no numeral 8. In
order to represent fifteen, you will need two sevens and one 1.
How do you generalize the process? To convert a base ten number to base 7, think about the columns: in base 7 they are ones, sevens, forty-nines, three-
hundred forty-threes, and so on. Why these columns? They represent 7 0 , 7 1 , 7 2 , 7 4 and so forth. Create a table for yourself:
4 3 2 1
7 3 7 2 7 1 7 0
343
49
7
1
The first row represents the column number. The second row represents the power of 7. The third row represents the decimal value of each number in that
row.
To convert from a decimal value to base 7, here is the procedure: Examine the number and decide which column to use first. If the number is 200, for
example, you know that column 4 (343) is 0, and you don't have to worry about it.
To find out how many 49s there are, divide 200 by 49. The answer is 4, so put 4 in column 3 and examine the remainder: 4. There are no 7s in 4, so put a zero
in the sevens column. There are 4 ones in 4, so put a 4 in the 1s column. The answer is 404 7 .
To convert the number 968 to base 6:
5 4 3 2 1
6 4 6 3 6 2 6 1 6 0
1296
216
36
6
1
There are no 1296s in 968, so column 5 has 0. Dividing 968 by 216 yields 4 with a remainder of 104. Column 4 is 4. Dividing 104 by 36 yields 2 with a
remainder of 32. Column 3 is 2. Dividing 32 by 6 yields 5 with a remainder of 2. The answer therefore is 4252 6 .
5 4 3 2 1
6 4 6 3 6 2 6 1 1296 216 36 6 6 0
1
0
4
2
5
2
There is a shortcut when converting from one base to another base (such as 6) to base 10. You can multiply:
4 * 216
= 864
2 * 36
= 72
5 * 6
= 30
2 * 1
=2
968
Binary
Base 2 is the ultimate extension of this idea. There are only two digits: 0 and 1. The columns are:
Col: 8 7 6 5 4 3 2 1
Power: 2 7 2 6 2 5 2 4 2 3 2 2 2 1 2 0
Value:
128
64
32
16
8
4
2
1
To convert the number 88 to base 2, you follow the same procedure: There are no 128s, so column 8 is 0.
There is one 64 in 88, so column 7 is 1 and 24 is the remainder. There are no 32s in 24 so column 6 is 0.
There is one 16 in 24 so column 5 is 1. The remainder is 8. There is one 8 in 8, and so column 4 is 1. There is no remainder, so the rest of the columns are 0.
0
1
To test this answer, convert it back:
1
0
1
1
0
0
* 64 =
* 32 =
* 16 =
* 8 =
* 4 =
* 2 =
64
0
16
8
0
0
0
1
1
0
0
00 *
1 =
0
88
Why Base 2?
The power of base 2 is that it corresponds so cleanly to what a computer needs to represent. Computers do not really know anything at all about letters,
numerals, instructions, or programs. At their core they are just circuitry, and at a given juncture there either is a lot of power or there is very little.
To keep the logic clean, engineers do not treat this as a relative scale (a little power, some power, more power, lots of power, tons of power), but rather as a
binary scale ("enough power" or "not enough power"). Rather than saying "enough" or "not enough," they simplify it to "yes" or "no." Yes or no, or true or
false, can be represented as 1 or 0. By convention, 1 means true or Yes, but that is just a convention; it could just as easily have meant false or no.
Once you make this great leap of intuition, the power of binary becomes clear: With 1s and 0s you can represent the fundamental truth of every circuit (there
is power or there isn't). All a computer ever knows is, "Is you is, or is you ain't?" Is you is = 1; is you ain't = 0.
Bits, Bytes, and Nybbles
Once the decision is made to represent truth and falsehood with 1s and 0s, binary digits (or bits) become very important. Since early computers could send 8
bits at a time, it was natural to start writing code using 8-bit numbers--called bytes.
NOTE: Half a byte (4 bits) is called a nybble!
With 8 binary digits you can represent up to 256 different values. Why? Examine the columns: If all 8 bits are set (1), the value is 255. If none is set (all the
bits are clear or zero) the value is 0. 0-255 is 256 possible states.
Whats a KB?
It turns out that 2 10 (1,024) is roughly equal to 10 3 (1,000). This coincidence was too good to miss, so computer scientists started referring to 2 10 bytes as 1KB
or 1 kilobyte, based on the scientific prefix of kilo for thousand.
Similarly, 1024 * 1024 (1,048,576) is close enough to one million to receive the designation 1MB or 1 megabyte, and 1,024 megabytes is called 1 gigabyte
(giga implies thousand-million or billion).
Binary Numbers
Computers use patterns of 1s and 0s to encode everything they do. Machine instructions are encoded as a series of 1s and 0s and interpreted by the
fundamental circuitry. Arbitrary sets of 1s and 0s can be translated back into numbers by computer scientists, but it would be a mistake to think that these
numbers have intrinsic meaning.
For example, the Intel 80x6 chip set interprets the bit pattern 1001 0101 as an instruction. You certainly can translate this into decimal (149), but that number
per se has no meaning.
Sometimes the numbers are instructions, sometimes they are values, and sometimes they are codes. One important standardized code set is ASCII. In ASCII
every letter and punctuation is given a 7-digit binary representation. For example, the lowercase letter "a" is represented by 0110 0001. This is not a number,
although you can translate it to the number 97 (64 + 32 + 1). It is in this sense that people say that the letter "a" is represented by 97 in ASCII; but the truth is
that the binary representation of 97, 01100001, is the encoding of the letter "a," and the decimal value 97 is a human convenience.
Hexadecimal
Because binary numbers are difficult to read, a simpler way to represent the same values is sought. Translating from binary to base 10 involves a fair bit of
manipulation of numbers; but it turns out that translating from base 2 to base 16 is very simple, because there is a very good shortcut.
To understand this, you must first understand base 16, which is known as hexadecimal. In base 16 there are sixteen numerals: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B,
C, D, E, and F. The last six are arbitrary; the letters A-F were chosen because they are easy to represent on a keyboard. The columns in hexadecimal are
4 3 2 1
16 3 16 2 16 1 16 0
4096
256
16
1
To translate from hexadecimal to decimal, you can multiply. Thus, the number F8C represents:
F * 256 = 15 * 256 = 3840
8 * 16 =
128
C * 1 = 12 * 1 = 12
3980
Translating the number FC to binary is best done by translating first to base 10, and then to binary:F * 16 = 15 * 16 =
C * 1 = 12 * 1 =
252
240
12
Converting 252 10 to binary requires the chart:
Col:
Power:
Value:
9
28
256
8
27
128
There are no 256s.
1 128 leaves 124
1 64 leaves 60
1 32 leaves 28
1 16 leaves 12
1 8 leaves 4
1 4 leaves 0
0
0
1
1
1
1
7
26
64
1
6
25
32 5
24
16 4
23
8
1 0 0
3
22
4
2
21
2
1
20
1
Thus, the answer in binary is 1111 1100.
Now, it turns out that if you treat this binary number as two sets of 4 digits, you can do a magical transformation.
The right set is 1100. In decimal that is 12, or in hexadecimal it is C.
The left set is 1111, which in base 10 is 15, or in hex is F.
Thus, you have:
1111 1100
F
C
Putting the two hex numbers together is FC, which is the real value of 1111 1100. This shortcut always works. You can take any binary number of any
length, and reduce it to sets of 4, translate each set of four to hex, and put the hex numbers together to get the result in hex. Here's a much larger number:
1011 0001 1101 0111
The columns are 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, and 32768.
1
1
1
0 x
x
x
x 1 =
2=
4 =
8 =
1
1
0
1
1 x
x
x
x 16 =
32 =
64 =
128 = 16
0
64
128
1
0
0
0 x
x
x
x 256 =
512 =
1024 =
2048 = 256
0
0
0
2
4
0
1 x 4096 =
4,096
1 x 8192 =
8,192
0 x 16384 = 0
1 x 32768 = 32,768
Total:
45,527
Converting this to hexadecimal requires a chart with the hexadecimal values.
65535
4096
256
16
1
There are no 65,536s in 45,527 so the first column is 4096. There are 11 4096s (45,056), with a remainder of 471. There is one 256 in 471 with a remainder
of 215. There are 13 16s (208) in 215 with a remainder of 7. Thus, the hexadecimal number is B1D7.
Checking the math:B (11) * 4096 = 45,056
1 * 256 =
256
D (13) * 16 = 208
7 * 1 =
7
Total
45,527
The shortcut version would be to take the original binary number,
1011000111010111,
and break it into groups of 4: 1011 0001 1101 0111. Each of the
four then
is evaluated as a hexadecimal number:
1011 =
1 x 1 =1
1 x 2 =2
0 x 4 =0
1 x 8 =8
Total 11
Hex: B
0001 =
1 x 1 =1
0 x 2 =0
0 x 4 =0
0 * 8 =0
Total 1
Hex: 1
1101 =
1 x 1 =1
0 x 2 =0
1 x 4 =4
1 x 8 =8
Total 13
Hex = D
0111 =
1 x 1 =1
1 x 2 =2
1 x 4 =40 x 8 =0
Total 7
Hex: 7
Total Hex: B1D7Appendix D
Answers
Day 1
Quiz
1. What is the difference between interpreters and compilers?
Interpreters read through source code and translate a program, turning the programmer's code,
or program instructions, directly into actions. Compilers translate source code into an
executable program that can be run at a later time.
2. How do you compile the source code with your compiler?
Every compiler is different. Be sure to check the documentation that came with your compiler.
3. What does the linker do?
The linker's job is to tie together your compiled code with the libraries supplied by your
compiler vendor and other sources. The linker lets you build your program in pieces and then
link together the pieces into one big program.
4. What are the steps in the development cycle?
Edit source code, compile, link, test, repeat.
Exercises
1. Initializes two integer variables and then prints out their sum and their product.
2. See your compiler manual.
3. You must put a # symbol before the word include on the first line.
4. This program prints the words Hello World to the screen, followed by a new line
(carriage return).
Day 2Quiz
1. What is the difference between the compiler and the preprocessor?
Each time you run your compiler, the preprocessor runs first. It reads through your source code
and includes the files you've asked for, and performs other housekeeping chores. The
preprocessor is discussed in detail on Day 18, "Object-Oriented Analysis and Design."
2. Why is the function main() special?
main() is called automatically, each time your program is executed.
3. What are the two types of comments, and how do they differ?
C++-style comments are two slashes (//), and they comment out any text until the end of the
line. C-style comments come in pairs (/* */), and everything between the matching pairs is
commented out. You must be careful to ensure you have matched pairs.
4. Can comments be nested?
Yes, C++-style comments can be nested within C-style comments. You can, in fact, nest C-
style comments within C++-style comments, as long as you remember that the C++-style
comments end at the end of the line.
5. Can comments be longer than one line?
C-style comments can. If you want to extend C++-style comments to a second line, you must
put another set of double slashes (//).
Exercises
1. Write a program that writes I love C++ to the screen.
1:
2:
3:
4:
5:
6:
7:
#include <iostream.h>
int main()
{
cout << "I love C++\n";
return 0;
}
2. Write the smallest program that can be compiled, linked, and run.
int main(){}
3. BUG BUSTERS: Enter this program and compile it. Why does it fail? How can you fix it?1:
2:
3:
4:
5:
#include <iostream.h>
main()
{
cout << Is there a bug here?";
}
Line 4 is missing an opening quote for the string.
4. Fix the bug in Exercise 3 and recompile, link, and run it.
1:
2:
3:
4:
5:
#include <iostream.h>
main()
{
cout << "Is there a bug here?";
}
Day 3
Quiz
1. What is the difference between an integral variable and a floating-point variable?
Integer variables are whole numbers; floating-point variables are "reals" and have a "floating"
decimal point. Floating-point numbers can be represented using a mantissa and an exponent.
2. What are the differences between an unsigned short int and a long int?
The keyword unsigned means that the integer will hold only positive numbers. On most
computers, short integers are 2 bytes and long integers are 4.
3. What are the advantages of using a symbolic constant rather than a literal?
A symbolic constant explains itself; the name of the constant tells what it is for. Also, symbolic
constants can be redefined at one location in the source code, rather than the programmer
having to edit the code everywhere the literal is used.
4. What are the advantages of using the const keyword rather than #define?
const variables are "typed;" thus the compiler can check for errors in how they are used.
Also, they survive the preprocessor; thus the name is available in the debugger.
5. What makes for a good or bad variable name?
A good variable name tells you what the variable is for; a bad variable name has no
information. myAge and PeopleOnTheBus are good variable names, but xjk and prndl
are probably less useful.6. Given this enum, what is the value of Blue?
enum COLOR { WHITE, BLACK = 100, RED, BLUE, GREEN = 300 };
BLUE = 102
7. Which of the following variable names are good, which are bad, and which are invalid?
a. Age
Good
b. !ex
Not legal
c. R79J
Legal, but a bad choice
d. TotalIncome
Good
e. __Invalid
Legal, but a bad choice
Exercises
1. What would be the correct variable type in which to store the following information?
a. Your age.
Unsigned short integer
b. The area of your backyard.
Unsigned long integer or unsigned float
c. The number of stars in the galaxy.
Unsigned double
d. The average rainfall for the month of January.
Unsigned short integer
2. Create good variable names for this information.
a. myAge
b. backYardArea
c. StarsInGalaxy
d. averageRainFall3. Declare a constant for pi as 3.14159.
const float PI = 3.14159;
4. Declare a float variable and initialize it using your pi constant.
float myPi = PI;
Day 4
Quiz
1. What is an expression?
Any statement that returns a value.
2. Is x = 5 + 7 an expression? What is its value?
Yes. 12
3. What is the value of 201 / 4?
50
4. What is the value of 201 % 4?
1
5. If myAge, a, and b are all int variables, what are their values after:
myAge = 39;
a = myAge++;
b = ++myAge;
myAge: 41, a: 39, b: 41
6. What is the value of 8+2*3?
14
7. What is the difference between if(x = 3) and if(x == 3)?
The first one assigns 3 to x and returns true. The second one tests whether x is equal to 3; it
returns true if the value of x is equal to 3 and false if it is not.8. Do the following values evaluate to TRUE or FALSE?
a. 0
FALSE
b. 1
TRUE
c. -1
TRUE
d. x = 0
FALSE
e. x == 0 // assume that x has the value of 0
TRUE
Exercises
1. Write a single if statement that examines two integer variables and changes the larger to
the smaller, using only one else clause.
if (x > y)
x = y;
else
y = x;
// y > x || y == x
2. Examine the following program. Imagine entering three numbers, and write what output you
expect.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14
15:
16:
17:
15:
#include <iostream.h>
int main()
{
int a, b, c;
cout << "Please enter three numbers\n";
cout << "a: ";
cin >> a;
cout << "\nb: ";
cin >> b;
cout << "\nc: ";
cin >> c;
if (c = (a-b))
{
cout << "a: " << a << " minus b: ";
cout << b << " _equals c: " << c;
}
else16:
17:
18:
cout << "a-b does not equal c: ";
return 0;
}
3. Enter the program from Exercise 2; compile, link, and run it. Enter the numbers 20, 10, and
50. Did you get the output you expected? Why not?
Enter 20, 10, 50.
Get back a: 20 b: 30 c: 10.
Line 13 is assigning, not testing for equality.
4. Examine this program and anticipate the output:
1:
2:
3:
4:
5:
6:
7:
#include <iostream.h>
int main()
{
int a = 2, b = 2, c;
if (c = (a-b))
cout << "The value of c is: " << c;
return 0;
8:
}
5. Enter, compile, link, and run the program from Exercise 4. What was the output? Why?
Because line 5 is assigning the value of a-b to c, the value of the assignment is a (1) minus b
(1), or 0. Because 0 is evaluated as FALSE, the if fails and nothing is printed.
Day 5
Quiz
1. What are the differences between the function prototype and the function defi-nition?
The function prototype declares the function; the definition defines it. The prototype ends with
a semicolon; the definition need not. The declaration can include the keyword inline and
default values for the parameters; the definition cannot. The declaration need not include
names for the parameters; the definition must.
2. Do the names of parameters have to agree in the prototype, definition, and call to the
function?
No. All parameters are identified by position, not name.3. If a function doesn't return a value, how do you declare the function?
Declare the function to return void.
4. If you don't declare a return value, what type of return value is assumed?
Any function that does not explicitly declare a return type returns int.
5. What is a local variable?
A local variable is a variable passed into or declared within a block, typically a function. It is
visible only within the block.
6. What is scope?
Scope refers to the visibility and lifetime of local and global variables. Scope is usually
established by a set of braces.
7. What is recursion?
Recursion generally refers to the ability of a function to call itself.
8. When should you use global variables?
Global variables are typically used when many functions need access to the same data. Global
variables are very rare in C++; once you know how to create static class variables, you will
almost never create global variables.
9. What is function overloading?
Function overloading is the ability to write more than one function with the same name,
distinguished by the number or type of the parameters.
10. What is polymorphism?
Polymorphism is the ability to treat many objects of differing but related types without regard
to their differences. In C++, polymorphism is accomplished by using class derivation and
virtual functions.
Exercises
1. Write the prototype for a function named Perimeter, which returns an unsigned
long int and which takes two parameters, both unsigned short ints.
unsigned long int Perimeter(unsigned short int, unsigned short
int);
2. Write the definition of the function Perimeter as described in Exercise 1. The two
parameters represent the length and width of a rectangle and have the function return theperimeter (twice the length plus twice the width).
unsigned long int Perimeter(unsigned short int length, unsigned
short int width)
{
return 2*length + 2*width;
}
3. BUG BUSTERS: What is wrong with the function?
#include <iostream.h>
void myFunc(unsigned short int x);
int main()
{
unsigned short int x, y;
y = myFunc(int);
cout << "x: " << x << " y: " << y << "\n";
return 0;
}
void myFunc(unsigned short int x)
{
return (4*x);
}
The function is declared to return void and it cannot return a value.
4. BUG BUSTERS: What is wrong with the function?
#include <iostream.h>
int myFunc(unsigned short int x);
int main()
{
unsigned short int x, y;
y = myFunc(int);
cout << "x: " << x << " y: " << y << "\n";
return 0;
}
int myFunc(unsigned short int x)
{
return (4*x);
}
This function would be fine, but there is a semicolon at the end of the function definition'sheader.
5. Write a function that takes two unsigned short int arguments and returns the result
of dividing the first by the second. Do not do the division if the second number is 0, but do
return -1.
short int Divider(unsigned short int valOne, unsigned short int
valTwo)
{
if (valTwo == 0)
return -1;
else
return valOne / valTwo;
}
6. Write a program that asks the user for two numbers and calls the function you wrote in
Exercise 5. Print the answer, or print an error message if you get -1.
#include <iostream.h>
typedef unsigned short int USHORT;
typedef unsigned long int ULONG;
short int Divider(
unsigned short int valone,
unsigned short int valtwo);
int main()
{
USHORT one, two;
short int answer;
cout << "Enter two numbers.\n Number one: ";
cin >> one;
cout << "Number two: ";
cin >> two;
answer = Divider(one, two);
if (answer > -1)
cout << "Answer: " << answer;
else
cout << "Error, can't divide by zero!";
return 0;
}
7. Write a program that asks for a number and a power. Write a recursive function that takes
the number to the power. Thus, if the number is 2 and the power is 4, the function will return
16.
#include <iostream.h>
typedef unsigned short USHORT;typedef unsigned long ULONG;
ULONG GetPower(USHORT n, USHORT power);
int main()
{
USHORT number, power;
ULONG answer;
cout << "Enter a number: ";
cin >> number;
cout << "To what power? ";
cin >> power;
answer = GetPower(number,power);
cout << number << " to the " << power << "th power is " <<
answer << endl;
return 0;
}
ULONG GetPower(USHORT n, USHORT power)
{
if(power == 1)
return n;
else
return (n * GetPower(n,power-1));
}
Day 6
Quiz
1. What is the dot operator, and what is it used for?
The dot operator is the period (.). It is used to access the members of the class.
2. Which sets aside memory--declaration or definition?
Definitions of variables set aside memory. Declarations of classes don't set aside memory.
3. Is the declaration of a class its interface or its implementation?
The declaration of a class is its interface; it tells clients of the class how to interact with the
class. The implementation of the class is the set of member functions stored--usually in a
related CPP file.
4. What is the difference between public and private data members?
Public data members can be accessed by clients of the class. Private data members can be
accessed only by member functions of the class.5. Can member functions be private?
Yes. Both member functions and member data can be private.
6. Can member data be public?
Although member data can be public, it is good programming practice to make it private and to
provide public accessor functions to the data.
7. If you declare two Cat objects, can they have different values in their itsAge
member data?
Yes. Each object of a class has its own data members.
8. Do class declarations end with a semicolon? Do class method definitions?
Declarations end with a semicolon after the closing brace; function definitions do not.
9. What would the header for a Cat function, Meow, that takes no parameters and
returns void look like?
The header for a Cat function, Meow(), that takes no parameters and returns void looks like
this:
void Cat::Meow()
10. What function is called to initialize a class?
The constructor is called to initialize a class.
Exercises
1. Write the code that declares a class called Employee with these data members: age,
yearsOfService, and Salary.
class Employee
{
int Age;
int YearsOfService;
int Salary;
};
2. Rewrite the Employee class to make the data members private, and provide public
accessor methods to get and set each of the data members.
class Employee
{public:
int GetAge() const;
void SetAge(int age);
int GetYearsOfService()const;
void SetYearsOfService(int years);
int GetSalary()const;
void SetSalary(int salary);
private:
int Age;
int YearsOfService;
int Salary;
};
3. Write a program with the Employee class that makes two Employees; sets their age,
YearsOfService, and Salary; and prints their values.
main()
{
Employee John;
Employee Sally;
John.SetAge(30);
John.SetYearsOfService(5);
John.SetSalary(50000);
Sally.SetAge(32);
Sally.SetYearsOfService(8);
Sally.SetSalary(40000);
cout << "At AcmeSexist company, John and Sally have the same
job.\n";
cout << "John is " << John.GetAge() << " years old and he has
been with";
cout << "the firm for " << John.GetYearsOfService << "
years.\n";
cout << "John earns $" << John.GetSalary << " dollars per
year.\n\n";
cout << "Sally, on the other hand is " << Sally.GetAge() << "
years old and has";
cout << "been with the company " << Sally.GetYearsOfService;
cout << " years. Yet Sally only makes $" << Sally.GetSalary();
cout << " dollars per year! Something here is unfair.";
4. Continuing from Exercise 3, provide a method of Employee that reports how many
thousands of dollars the employee earns, rounded to the nearest 1,000.float Employee:GetRoundedThousands()const
{
return Salary / 1000;
}
5. Change the Employee class so that you can initialize age, YearsOfService, and
Salary when you create the employee.
class Employee
{
public:
Employee(int age, int yearsOfService, int salary);
int GetAge()const;
void SetAge(int age);
int GetYearsOfService()const;
void SetYearsOfService(int years);
int GetSalary()const;
void SetSalary(int salary);
private:
int Age;
int YearsOfService;
int Salary;
};
6. BUG BUSTERS: What is wrong with the following declaration?
class Square
{
public:
int Side;
}
Class declarations must end with a semicolon.
7. BUG BUSTERS: Why isn't the following class declaration very useful?
class Cat
{
int GetAge()const;
private:
int itsAge;
};
The accessor GetAge() is private. Remember: All class members are private unless you sayotherwise.
8. BUG BUSTERS: What three bugs in this code will the compiler find?
class TV
{
public:
void SetStation(int Station);
int GetStation() const;
private:
int itsStation;
};
main()
{
TV myTV;
myTV.itsStation = 9;
TV.SetStation(10);
TV myOtherTv(2);
}
You can't access itsStation directly. It is private.
You can't call SetStation() on the class. You can call SetStation() only on objects.
You can't initialize itsStation because there is no matching constructor.
Day 7
Quiz
1. How do I initialize more than one variable in a for loop?
Separate the initializations with commas, such as
for (x = 0, y = 10; x < 100; x++, y++)
2. Why is goto avoided?
goto jumps in any direction to any arbitrary line of code. This makes for source code that is
difficult to understand and therefore difficult to maintain.
3. Is it possible to write a for loop with a body that is never executed?
Yes, if the condition is FALSE after the initialization, the body of the for loop will never
execute. Here's an example:
for (int x = 100; x < 100; x++)4. Is it possible to nest while loops within for loops?
Yes. Any loop can be nested within any other loop.
5. Is it possible to create a loop that never ends? Give an example.
Yes. Following are examples for both a for loop and a while loop:
for(;;)
{
// This for loop never ends!
}
while(1)
{
// This while loop never ends!
}
6. What happens if you create a loop that never ends?
Your program hangs, and you usually must reboot the computer.
Exercises
1. What is the value of x when the for loop completes?
for (int x = 0; x < 100; x++)
100
2. Write a nested for loop that prints a 10x10 pattern of 0s.
for (int i = 0; i< 10; i++)
{
for ( int j = 0; j< 10; j++)
cout << "0";
cout << "\n";
}
3. Write a for statement to count from 100 to 200 by 2s.
for (int x = 100; x<=200; x+=2)
4. Write a while loop to count from 100 to 200 by 2s.int x = 100;
while (x <= 200)
x+= 2;
5. Write a do...while loop to count from 100 to 200 by 2s.
int x = 100;
do
{
x+=2;
} while (x <= 200);
6. BUG BUSTERS: What is wrong with this code?
int counter = 0
while (counter < 10)
{
cout << "counter: " << counter;
counter++;
}
counter is never incremented and the while loop will never terminate.
7. BUG BUSTERS: What is wrong with this code?
for (int counter = 0; counter < 10; counter++);
cout << counter << "\n";
There is a semicolon after the loop, and the loop does nothing. The programmer may have
intended this, but if counter was supposed to print each value, it won't.
8. BUG BUSTERS: What is wrong with this code?
int counter = 100;
while (counter < 10)
{
cout << "counter now: " << counter;
counter--;
}
counter is initialized to 100, but the test condition is that if it is less than 10, the test will
fail and the body will never be executed. If line 1 were changed to int counter = 5;, the
loop would not terminate until it had counted down past the smallest possible int. Because
int is signed by default, this would not be what was intended.9. BUG BUSTERS: What is wrong with this code?
cout << "Enter a number
cin >> theNumber;
switch (theNumber)
{
case 0:
doZero();
case 1:
case 2:
case 3:
case 4:
case 5:
doOneToFive();
break;
default:
doDefault();
break;
}
between 0 and 5: ";
//
//
//
//
fall
fall
fall
fall
through
through
through
through
Case 0 probably needs a break statement. If it does not, it should be documented with a
comment.
Day 8
Quiz
1. What operator is used to determine the address of a variable?
The address of operator (&) is used to determine the address of any variable.
2. What operator is used to find the value stored at an address held in a pointer?
The dereference operator (*) is used to access the value at an address in a pointer.
3. What is a pointer?
A pointer is a variable that holds the address of another variable.
4. What is the difference between the address stored in a pointer and the value at that
address?
The address stored in the pointer is the address of another variable. The value stored at that
address is any value stored in any variable. The indirection operator (*) returns the value
stored at the address, which itself is stored in the pointer.5. What is the difference between the indirection operator and the address of oper-ator?
The indirection operator returns the value at the address stored in a pointer. The address of
operator (&) returns the memory address of the variable.
6. What is the difference between const int * ptrOne and int * const
ptrTwo?
The const int * ptrOne declares that ptrOne is a pointer to a constant integer. The
integer itself cannot be changed using this pointer.
The int * const ptrTwo declares that ptrTwo is a constant pointer to an integer. Once
it is initialized, this pointer cannot be reassigned.
Exercises
1. What do these declarations do?
a. int * pOne;
b. int vTwo;
c. int * pThree = &vTwo;
a. int * pOne; declares a pointer to an integer.
b. int vTwo; declares an integer variable.
c. int * pThree = &vTwo; declares a pointer to an integer and initializes it with
the address of another variable.
2. If you have an unsigned short variable named yourAge, how would you declare a
pointer to manipulate yourAge?
unsigned short *pAge = &yourAge;
3. Assign the value 50 to the variable yourAge by using the pointer that you declared in
Exercise 2.
*pAge = 50;
4. Write a small program that declares an integer and a pointer to integer. Assign the address of
the integer to the pointer. Use the pointer to set a value in the integer variable.
int theInteger;
int *pInteger = &theInteger;
*pInteger = 5;
5. BUG BUSTERS: What is wrong with this code?
#include <iostream.h>int main()
{
int *pInt;
*pInt = 9;
cout << "The value at pInt: " << *pInt;
return 0;
}
pInt should have been initialized. More importantly, because it was not initialized and was
not assigned the address of any memory, it points to a random place in memory. Assigning 9
to that random place is a dangerous bug.
6. BUG BUSTERS: What is wrong with this code?
int main()
{
int SomeVariable = 5;
cout << "SomeVariable: " << SomeVariable << "\n";
int *pVar = & SomeVariable;
pVar = 9;
cout << "SomeVariable: " << *pVar << "\n";
return 0;
}
Presumably, the programmer meant to assign 9 to the value at pVar. Unfortunately, 9 was
assigned to be the value of pVar because the indirection operator (*) was left off. This will
lead to disaster if pVar is used to assign a value.
Day 9
Quiz
1. What is the difference between a reference and a pointer?
A reference is an alias, and a pointer is a variable that holds an address. References cannot be
null and cannot be assigned to.
2. When must you use a pointer rather than a reference?
When you may need to reassign what is pointed to, or when the pointer may be null.
3. What does new return if there is insufficient memory to make your new object?
A null pointer (0).
4. What is a constant reference?This is a shorthand way of saying "a reference to a constant object."
5. What is the difference between passing by reference and passing a reference?
Passing by reference means not making a local copy. It can be accomplished by passing a
reference or by passing a pointer.
Exercises
1. Write a program that declares an int, a reference to an int, and a pointer to an int. Use
the pointer and the reference to manipulate the value in the int.
int main()
{
int varOne;
int& rVar = varOne;
int* pVar = &varOne;
rVar = 5;
*pVar = 7;
return 0;
}
2. Write a program that declares a constant pointer to a constant integer. Initialize the pointer
to an integer variable, varOne. Assign 6 to varOne. Use the pointer to assign 7 to varOne.
Create a second integer variable, varTwo. Reassign the pointer to varTwo.
int main()
{
int varOne;
const int * const pVar = &varOne;
*pVar = 7;
int varTwo;
pVar = &varTwo;
return 0;
}
3. Compile the program in Exercise 2. What produces errors? What produces warnings?
You can't assign a value to a constant object, and you can't reassign a constant pointer.
4. Write a program that produces a stray pointer.
int main()
{
int * pVar;
*pVar = 9;return 0;
}
5. Fix the program from Exercise 4.
int main()
{
int VarOne;
int * pVar = &varOne;
*pVar = 9;
return 0;
}
6. Write a program that produces a memory leak.
int FuncOne();
int main()
{
int localVar = FunOne();
cout << "the value of localVar is: " << localVar;
return 0;
}
int FuncOne()
{
int * pVar = new int (5);
return *pVar;
}
7. Fix the program from Exercise 6.
void FuncOne();
int main()
{
FuncOne();
return 0;
}
void FuncOne()
{
int * pVar = new int (5);
cout << "the value of *pVar is: " << *pVar ;
}
8. BUG BUSTERS: What is wrong with this program?1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
#include <iostream.h>
class CAT
{
public:
CAT(int age) { itsAge = age; }
~CAT(){}
int GetAge() const { return itsAge;}
private:
int itsAge;
};
CAT & MakeCat(int age);
int main()
{
int age = 7;
CAT Boots = MakeCat(age);
cout << "Boots is " << Boots.GetAge() << " years old\n";
return 0;
}
CAT & MakeCat(int age)
{
CAT * pCat = new CAT(age);
return *pCat;
}
MakeCat returns a reference to the CAT created on the free store. There is no way to free that
memory, and this produces a memory leak.
9. Fix the program from Exercise 8.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
#include <iostream.h>
class CAT
{
public:
CAT(int age) { itsAge = age; }
~CAT(){}
int GetAge() const { return itsAge;}
private:
int itsAge;
};
CAT * MakeCat(int age);
int main()15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
{
int age = 7;
CAT * Boots = MakeCat(age);
cout << "Boots is " << Boots->GetAge() << " years old\n";
delete Boots;
return 0;
}
CAT * MakeCat(int age)
{
return new CAT(age);
}
Day 10
Quiz
1. When you overload member functions, in what ways must they differ?
Overloaded member functions are functions in a class that share a name but differ in the
number or type of their parameters.
2. What is the difference between a declaration and a definition?
A definition sets aside memory, but a declaration does not. Almost all declarations are
definitions; the major exceptions are class declarations, function prototypes, and typedef
statements.
3. When is the copy constructor called?
Whenever a temporary copy of an object is created. This happens every time an object is
passed by value.
4. When is the destructor called?
The destructor is called each time an object is destroyed, either because it goes out of scope or
because you call delete on a pointer pointing to it.
5. How does the copy constructor differ from the assignment operator (=)?
The assignment operator acts on an existing object; the copy constructor creates a new one.
6. What is the this pointer?
The this pointer is a hidden parameter in every member function that points to the object
itself.
7. How do you differentiate between overloading the prefix and postfix increments?The prefix operator takes no parameters. The postfix operator takes a single int parameter,
which is used as a signal to the compiler that this is the postfix variant.
8. Can you overload the operator+ for short integers?
No, you cannot overload any operator for built-in types.
9. Is it legal in C++ to overload operator++ so that it decrements a value in your class?
It is legal, but it is a bad idea. Operators should be overloaded in a way that is likely to be
readily understood by anyone reading your code.
10. What return value must conversion operators have in their declaration?
None. Like constructors and destructors, they have no return values.
Exercises
1. Write a SimpleCircle class declaration (only) with one member variable: itsRadius.
Include a default constructor, a destructor, and accessor methods for itsRadius.
class SimpleCircle
{
public:
SimpleCircle();
~SimpleCircle();
void SetRadius(int);
int GetRadius();
private:
int itsRadius;
};
2. Using the class you created in Exercise 1, write the implementation of the default
constructor, initializing itsRadius with the value 5.
SimpleCircle::SimpleCircle():
itsRadius(5)
{}
3. Using the same class, add a second constructor that takes a value as its parameter and
assigns that value to itsRadius.
SimpleCircle::SimpleCircle(int radius):
itsRadius(radius)
{}4. Create a prefix and postfix increment operator for your SimpleCircle class that
increments itsRadius.
const SimpleCircle& SimpleCircle::operator++()
{
++(itsRadius);
return *this;
}
// Operator ++(int) postfix.
// Fetch then increment
const SimpleCircle SimpleCircle::operator++ (int)
{
// declare local SimpleCircle and initialize to value of *this
SimpleCircle temp(*this);
++(itsRadius);
return temp;
}
5. Change SimpleCircle to store itsRadius on the free store, and fix the existing
methods.
class SimpleCircle
{
public:
SimpleCircle();
SimpleCircle(int);
~SimpleCircle();
void SetRadius(int);
int GetRadius();
const SimpleCircle& operator++();
const SimpleCircle operator++(int);
private:
int *itsRadius;
};
SimpleCircle::SimpleCircle()
{itsRadius = new int(5);}
SimpleCircle::SimpleCircle(int radius)
{itsRadius = new int(radius);}
const SimpleCircle& SimpleCircle::operator++()
{
++(itsRadius);return *this;
}
// Operator ++(int) postfix.
// Fetch then increment
const SimpleCircle SimpleCircle::operator++ (int)
{
// declare local SimpleCircle and initialize to value of *this
SimpleCircle temp(*this);
++(itsRadius);
return temp;
}
6. Provide a copy constructor for SimpleCircle.
SimpleCircle::SimpleCircle(const SimpleCircle & rhs)
{
int val = rhs.GetRadius();
itsRadius = new int(val);
}
7. Provide an operator= for SimpleCircle.
SimpleCircle& SimpleCircle::operator=(const SimpleCircle & rhs)
{
if (this == &rhs)
return *this;
delete itsRadius;
itsRadius = new int;
*itsRadius = rhs.GetRadius();
return *this;
}
8. Write a program that creates two SimpleCircle objects. Use the default constructor on
one and instantiate the other with the value 9. Call increment on each and then print their
values. Finally, assign the second to the first and print its values.
#include <iostream.h>
class SimpleCircle
{
public:
// constructors
SimpleCircle();
SimpleCircle(int);
SimpleCircle(const SimpleCircle &);~SimpleCircle() {}
// accessor functions
void SetRadius(int);
int GetRadius()const;
// operators
const SimpleCircle& operator++();
const SimpleCircle operator++(int);
SimpleCircle& operator=(const SimpleCircle &);
private:
int *itsRadius;
};
SimpleCircle::SimpleCircle()
{itsRadius = new int(5);}
SimpleCircle::SimpleCircle(int radius)
{itsRadius = new int(radius);}
SimpleCircle::SimpleCircle(const SimpleCircle & rhs)
{
int val = rhs.GetRadius();
itsRadius = new int(val);
}
SimpleCircle& SimpleCircle::operator=(const SimpleCircle & rhs)
{
if (this == &rhs)
return *this;
*itsRadius = rhs.GetRadius();
return *this;
}
const SimpleCircle& SimpleCircle::operator++()
{
++(itsRadius);
return *this;
}
// Operator ++(int) postfix.
// Fetch then increment
const SimpleCircle SimpleCircle::operator++ (int)
{
// declare local SimpleCircle and initialize to value of *this
SimpleCircle temp(*this);
++(itsRadius);return temp;
}
int SimpleCircle::GetRadius() const
{
return *itsRadius;
}
int main()
{
SimpleCircle CircleOne, CircleTwo(9);
CircleOne++;
++CircleTwo;
cout << "CircleOne: " << CircleOne.GetRadius()
cout << "CircleTwo: " << CircleTwo.GetRadius()
CircleOne = CircleTwo;
cout << "CircleOne: " << CircleOne.GetRadius()
cout << "CircleTwo: " << CircleTwo.GetRadius()
return 0;
}
<< endl;
<< endl;
<< endl;
<< endl;
9. BUG BUSTERS: What is wrong with this implementation of the assignment operator?
SQUARE SQUARE ::operator=(const SQUARE & rhs)
{
itsSide = new int;
*itsSide = rhs.GetSide();
return *this;
}
You must check to see whether rhs equals this, or the call to a = a will crash your
program.
10. BUG BUSTERS: What is wrong with this implementation of operator+?
VeryShort VeryShort::operator+ (const VeryShort& rhs)
{
itsVal += rhs.GetItsVal();
return *this;
}
This operator+ is changing the value in one of the operands, rather than creating a new
VeryShort object with the sum. The right way to do this is as follows:
VeryShort VeryShort::operator+ (const VeryShort& rhs)
{
return VeryShort(itsVal + rhs.GetItsVal());}
Day 11
Quiz
1. What are the first and last elements in SomeArray[25]?
SomeArray[0], SomeArray[24]
2. How do you declare a multidimensional array?
Write a set of subscripts for each dimension. For example, SomeArray[2][3][2] is a
three-dimensional array. The first dimension has two elements, the second has three, and
the third has two.
3. Initialize the members of the array in Question 2.
SomeArray[2][3][2] = { { {1,2},{3,4},{5,6} } , {
{7,8},{9,10},{11,12} } };
4. How many elements are in the array SomeArray[10][5][20]?
10x5x20=1,000
5. What is the maximum number of elements that you can add to a linked list?
There is no fixed maximum. It depends on how much memory you have available.
6. Can you use subscript notation on a linked list?
You can use subscript notation on a linked list only by writing your own class to contain the
linked list and overloading the subscript operator.
7. What is the last character in the string "Brad is a nice guy"?
The null character.
Exercises
1. Declare a two-dimensional array that represents a tic-tac-toe game board.
int GameBoard[3][3];
2. Write the code that initializes all the elements in the array you created in Exercise 1 to the
value 0.int GameBoard[3][3] = { {0,0,0},{0,0,0},{0,0,0} }
3. Write the declaration for a Node class that holds unsigned short integers.
class Node
{
public:
Node ();
Node (int);
~Node();
void SetNext(Node * node) { itsNext = node; }
Node * GetNext() const { return itsNext; }
int GetVal() const { return itsVal; }
void Insert(Node *);
void Display();
private:
int itsVal;
Node * itsNext;
};
4. BUG BUSTERS: What is wrong with this code fragment?
unsigned short SomeArray[5][4];
for (int i = 0; i<4; i++)
for (int j = 0; j<5; j++)
SomeArray[i][j] = i+j;
The array is 5 elements by 4 elements, but the code initializes 4x5.
5. BUG BUSTERS: What is wrong with this code fragment?
unsigned short SomeArray[5][4];
for (int i = 0; i<=5; i++)
for (int j = 0; j<=4; j++)
SomeArray[i][j] = 0;
You wanted to write i<5, but you wrote i<=5 instead. The code will run when i == 5 and
j == 4, but there is no such element as SomeArray[5][4].
Day 12
Quiz
1. What is a v-table?A v-table, or virtual function table, is a common way for compilers to manage virtual functions
in C++. The table keeps a list of the addresses of all the virtual functions and, depending on the
runtime type of the object pointed to, invokes the right function.
2. What is a virtual destructor?
A destructor of any class can be declared to be virtual. When the pointer is deleted, the runtime
type of the object will be assessed and the correct derived destructor invoked.
3. How do you show the declaration of a virtual constructor?
There are no virtual constructors.
4. How can you create a virtual copy constructor?
By creating a virtual method in your class, which itself calls the copy constructor.
5. How do you invoke a base member function from a derived class in which you've
overridden that function?
Base::FunctionName();
6. How do you invoke a base member function from a derived class in which you have not
overridden that function?
FunctionName();
7. If a base class declares a function to be virtual, and a derived class does not use the
term virtual when overriding that class, is it still virtual when inherited by a third-
generation class?
Yes, the virtuality is inherited and cannot be turned off.
8. What is the protected keyword used for?
protected members are accessible to the member functions of derived objects.
Exercises
1. Show the declaration of a virtual function taking an integer parameter and returning void.
virtual void SomeFunction(int);
2. Show the declaration of a class Square, which derives from Rectangle, which in turn
derives from Shape.class Square : public Rectangle
{};
3. If, in Exercise 2, Shape takes no parameters, Rectangle takes two (length and
width), and Square takes only one (length), show the constructor initialization for
Square.
Square::Square(int length):
Rectangle(length, length){}
4. Write a virtual copy constructor for the class Square (from the preceding question).
class Square
{
public:
// ...
virtual Square * clone() const { return new Square(*this);
}
// ...
};
5. BUG BUSTERS: What is wrong with this code snippet?
void SomeFunction (Shape);
Shape * pRect = new Rectangle;
SomeFunction(*pRect);
Perhaps nothing. SomeFunction expects a Shape object. You've passed it a Rectangle
"sliced" down to a Shape. As long as you don't need any of the Rectangle parts, this will
be fine. If you do need the Rectangle parts, you'll need to change SomeFunction to take
a pointer or a reference to a Shape.
6. BUG BUSTERS: What is wrong with this code snippet?
class Shape()
{
public:
Shape();
virtual ~Shape();
virtual Shape(const Shape&);
};
You can't declare a copy constructor to be virtual.
Day 13Quiz
1. What is a down cast?
A down cast (also called "casting down") is a declaration that a pointer to a base class is to be
treated as a pointer to a derived class.
2. What is the v-ptr?
The v-ptr, or virtual-function pointer, is an implementation detail of virtual functions. Each
object in a class with virtual functions has a v-ptr, which points to the virtual function table for
that class.
3. If a round rectangle has straight edges and rounded corners, your RoundRect class
inherits both from Rectangle and from Circle, and they in turn both inherit from
Shape, how many Shapes are created when you create a RoundRect?
If neither class inherits using the keyword virtual, two Shapes are created: one for
Rectangle and one for Shape. If the keyword virtual is used for both classes, only one
shared Shape is created.
4. If Horse and Bird inherit virtual public from Animal, do their constructors
initialize the Animal constructor? If Pegasus inherits from both Horse and Bird,
how does it initialize Animal's constructor?
Both Horse and Bird initialize their base class, Animal, in their constructors. Pegasus
does as well, and when a Pegasus is created, the Horse and Bird initializations of
Animal are ignored.
5. Declare a class Vehicle and make it an abstract data type.
class Vehicle
{
virtual void Move() = 0;
}
6. If a base class is an ADT, and it has three pure virtual functions, how many of these
functions must be overridden in its derived classes?
None must be overridden unless you want to make the class non-abstract, in which case all
three must be overridden.
Exercises
1. Show the declaration for a class JetPlane, which inherits from Rocket and Airplane.class JetPlane : public Rocket, public Airplane
2. Show the declaration for 747, which inherits from the JetPlane class described in
Exercise 1.
class 747 : public JetPlane
3. Show the declarations for the classes Car and Bus, which each derive from the class
Vehicle. Make Vehicle an ADT with two pure virtual functions. Make Car and Bus not
be ADTs.
class Vehicle
{
virtual void Move() = 0;
virtual void Haul() = 0;
};
class Car : public Vehicle
{
virtual void Move();
virtual void Haul();
};
class Bus : public Vehicle
{
virtual void Move();
virtual void Haul();
};
4. Modify the program in Exercise 1 so that Car is an ADT, and derive SportsCar and
Coupe from Car. In the Car class, provide an implementation for one of the pure virtual
functions in Vehicle and make it non-pure.
class Vehicle
{
virtual void Move() = 0;
virtual void Haul() = 0;
};
class Car : public Vehicle
{
virtual void Move();
};
class Bus : public Vehicle
{virtual void Move();
virtual void Haul();
};
class SportsCar : public Car
{
virtual void Haul();
};
class Coupe : public Car
{
virtual void Haul();
};
Day 14
Quiz
1. Can static member variables be private?
Yes. They are member variables, and their access can be controlled like any other. If they are
private, they can be accessed only by using member functions or, more commonly, static
member functions.
2. Show the declaration for a static member variable.
static int itsStatic;
3. Show the declaration for a static function pointer.
static int SomeFunction();
4. Show the declaration for a pointer to function returning long and taking an integer
parameter.
long (* function)(int);
5. Modify the pointer in Exercise 4 to be a pointer to member function of class Car
long ( Car::*function)(int);
6. Show the declaration for an array of 10 pointers as defined in Exercise 5.
(long ( Car::*function)(int) theArray [10];Exercises
1. Write a short program declaring a class with one member variable and one static member
variable. Have the constructor initialize the member variable and increment the static member
variable. Have the destructor decrement the member variable.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
class myClass
{
public:
myClass();
~myClass();
private:
int itsMember;
static int itsStatic;
};
myClass::myClass():
itsMember(1)
{
itsStatic++;
}
myClass::~myClass()
{
itsStatic--;
}
int myClass::itsStatic = 0;
int main()
{}
2. Using the program from Exercise 1, write a short driver program that makes three objects
and then displays their member variables and the static member variable. Then destroy each
object and show the effect on the static member variable.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
#include <iostream.h>
class myClass
{
public:
myClass();
~myClass();
void ShowMember();
void ShowStatic();
private:11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
endl;
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
int itsMember;
static int itsStatic;
};
myClass::myClass():
itsMember(1)
{
itsStatic++;
}
myClass::~myClass()
{
itsStatic--;
cout << "In destructor. ItsStatic: " << itsStatic <<
}
void myClass::ShowMember()
{
cout << "itsMember: " << itsMember << endl;
}
void myClass::ShowStatic()
{
cout << "itsStatic: " << itsStatic << endl;
}
int myClass::itsStatic = 0;
int main()
{
myClass obj1;
obj1.ShowMember();
obj1.ShowStatic();
myClass obj2;
obj2.ShowMember();
obj2.ShowStatic();
myClass obj3;
obj3.ShowMember();
obj3.ShowStatic();
return 0;
}
3. Modify the program from Exercise 2 to use a static member function to access the static
member variable. Make the static member variable private.1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
endl;
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
#include <iostream.h>
class myClass
{
public:
myClass();
~myClass();
void ShowMember();
static int GetStatic();
private:
int itsMember;
static int itsStatic;
};
myClass::myClass():
itsMember(1)
{
itsStatic++;
}
myClass::~myClass()
{
itsStatic--;
cout << "In destructor. ItsStatic: " << itsStatic <<
}
void myClass::ShowMember()
{
cout << "itsMember: " << itsMember << endl;
}
int myClass::itsStatic = 0;
void myClass::GetStatic()
{
return itsStatic;
}
int main()
{
myClass obj1;
obj1.ShowMember();
cout << "Static: " << myClass::GetStatic() << endl;45:
46:
47:
48:
49:
50:
51:
52:
53:
myClass obj2;
obj2.ShowMember();
cout << "Static: " << myClass::GetStatic() << endl;
myClass obj3;
obj3.ShowMember();
cout << "Static: " << myClass::GetStatic() << endl;
return 0;
}
4. Write a pointer to a member function to access the non-static member data in the program in
Exercise 3, and use that pointer to print the value of that data.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
endl;
25:
26:
27:
28:
29:
30:
31:
32:
#include <iostream.h>
class myClass
{
public:
myClass();
~myClass();
void ShowMember();
static int GetStatic();
private:
int itsMember;
static int itsStatic;
};
myClass::myClass():
itsMember(1)
{
itsStatic++;
}
myClass::~myClass()
{
itsStatic--;
cout << "In destructor. ItsStatic: " << itsStatic <<
}
void myClass::ShowMember()
{
cout << "itsMember: " << itsMember << endl;
}
int myClass::itsStatic = 0;33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
int myClass::GetStatic()
{
return itsStatic;
}
int main()
{
void (myClass::*PMF) ();
PMF=myClass::ShowMember;
myClass obj1;
(obj1.*PMF)();
cout << "Static: " << myClass::GetStatic() << endl;
myClass obj2;
(obj2.*PMF)();
cout << "Static: " << myClass::GetStatic() << endl;
myClass obj3;
(obj3.*PMF)();
cout << "Static: " << myClass::GetStatic() << endl;
return 0;
}
5. Add two more member variables to the class from the previous questions. Add accessor
functions that get the value of this data and give all the member functions the same return
values and signatures. Use the pointer to the member function to access these functions.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
#include <iostream.h>
class myClass
{
public:
myClass();
~myClass();
void ShowMember();
void ShowSecond();
void ShowThird();
static int GetStatic();
private:
int itsMember;
int itsSecond;
int itsThird;
static int itsStatic;17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
endl;
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
};
myClass::myClass():
itsMember(1),
itsSecond(2),
itsThird(3)
{
itsStatic++;
}
myClass::~myClass()
{
itsStatic--;
cout << "In destructor. ItsStatic: " << itsStatic <<
}
void myClass::ShowMember()
{
cout << "itsMember: " << itsMember << endl;
}
void myClass::ShowSecond()
{
cout << "itsSecond: " << itsSecond << endl;
}
void myClass::ShowThird()
{
cout << "itsThird: " << itsThird << endl;
}
int myClass::itsStatic = 0;
int myClass::GetStatic()
{
return itsStatic;
}
int main()
{
void (myClass::*PMF) ();
myClass obj1;
PMF=myClass::ShowMember;
(obj1.*PMF)();
PMF=myClass::ShowSecond;62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
(obj1.*PMF)();
PMF=myClass::ShowThird;
(obj1.*PMF)();
cout << "Static: " << myClass::GetStatic() << endl;
myClass obj2;
PMF=myClass::ShowMember;
(obj2.*PMF)();
PMF=myClass::ShowSecond;
(obj2.*PMF)();
PMF=myClass::ShowThird;
(obj2.*PMF)();
cout << "Static: " << myClass::GetStatic() << endl;
myClass obj3;
PMF=myClass::ShowMember;
(obj3.*PMF)();
PMF=myClass::ShowSecond;
(obj3.*PMF)();
PMF=myClass::ShowThird;
(obj3.*PMF)();
cout << "Static: " << myClass::GetStatic() << endl;
return 0;
}
Day 15
Quiz
1. How do you establish an is-a relationship?
With public inheritance.
2. How do you establish a has-a relationship?
With containment; that is, one class has a member that is an object of another type.
3. What is the difference between containment and delegation?
Containment describes the idea of one class having a data member that is an object of another
type. Delegation expresses the idea that one class uses another class to accomplish a task or
goal. Delegation is usually accomplished by containment.
4. What is the difference between delegation and implemented-in-terms-of?
Delegation expresses the idea that one class uses another class to accomplish a task or goal.
Implemented-in-terms-of expresses the idea of inheriting implementation from another class.5. What is a friend function?
A friend function is a function declared to have access to the protected and private members of
your
class.
6. What is a friend class?
A friend class is a class declared so that all its member functions are friend functions of your
class.
7. If Dog is a friend of Boy, is Boy a friend of Dog?
No, friendship is not commutative.
8. If Dog is a friend of Boy, and Terrier derives from Dog, is Terrier a friend of
Boy?
No, friendship is not inherited.
9. If Dog is a friend of Boy and Boy is a friend of House, is Dog a friend of House?
No, friendship is not associative.
10. Where must the declaration of a friend function appear?
Anywhere within the class declaration. It makes no difference whether you put the declaration
within the public:, protected:, or private: access areas.
Exercises
1. Show the declaration of a class Animal that contains a data member that is a String
object.
class Animal:
{
private:
String itsName;
};
2. Show the declaration of a class BoundedArray that is an array.
class boundedArray : public Array
{
//...
}3. Show the declaration of a class Set that is declared in terms of an array.
class Set : private Array
{
// ...
}
4. Modify Listing 15.1 to provide the String class with an extraction operator (>>).
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
}
26:
27:
28:
29:
30:
31:
32:
33
34:
35:
#include <iostream.h>
#include <string.h>
class String
{
public:
// constructors
String();
String(const char *const);
String(const String &);
~String();
// overloaded operators
char & operator[](int offset);
char operator[](int offset) const;
String operator+(const String&);
void operator+=(const String&);
String & operator= (const String &);
friend ostream& operator<<
( ostream&
_theStream,String& theString);
friend istream& operator>>
( istream& _theStream,String& theString);
// General accessors
int GetLen()const { return itsLen; }
const char * GetString() const { return itsString;
// static int ConstructorCount;
private:
String (int);
// private constructor
char * itsString;
unsigned short itsLen;
};
ostream& operator<<( ostream& theStream,String&theString)
36:
{
37:
theStream << theString.GetString();
38:
return theStream;
39:
}
40:
41:
istream& operator>>( istream& theStream,String&
theString)
42:
{
43:
theStream >> theString.GetString();
44:
return theStream;
45:
}
46:
47:
int main()
48:
{
49:
String theString("Hello world.");
50:
cout << theString;
51:
return 0;
52:
}
5. BUG BUSTERS: What is wrong with this program?
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
#include <iostream.h>
class Animal;
void setValue(Animal& , int);
class Animal
{
public:
int GetWeight()const { return itsWeight; }
int GetAge() const { return itsAge; }
private:
int itsWeight;
int itsAge;
};
void setValue(Animal& theAnimal, int theWeight)
{
friend class Animal;
theAnimal.itsWeight = theWeight;
}
int main()25:
26:
27:
28:
29:
{
Animal peppy;
setValue(peppy,5);
return 0;
}
You can't put the friend declaration into the function. You must declare the function to be a
friend in the class.
6. Fix the listing in Exercise 5 so that it will compile.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
#include <iostream.h>
class Animal;
void setValue(Animal& , int);
class Animal
{
public:
friend void setValue(Animal&, int);
int GetWeight()const { return itsWeight; }
int GetAge() const { return itsAge; }
private:
int itsWeight;
int itsAge;
};
void setValue(Animal& theAnimal, int theWeight)
{
theAnimal.itsWeight = theWeight;
}
int main()
{
Animal peppy;
setValue(peppy,5);
return 0;
}
7. BUG BUSTERS: What is wrong with this code?
1:
2:
3:
#include <iostream.h>
class Animal;4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
void setValue(Animal& , int);
void setValue(Animal& ,int,int);
class Animal
{
friend void setValue(Animal& ,int); // here's the change!
private:
int itsWeight;
int itsAge;
};
void setValue(Animal& theAnimal, int theWeight)
{
theAnimal.itsWeight = theWeight;
}
void setValue(Animal& theAnimal, int theWeight, int theAge)
{
theAnimal.itsWeight = theWeight;
theAnimal.itsAge = theAge;
}
int main()
{
Animal peppy;
setValue(peppy,5);
setValue(peppy,7,9);
return 0;
}
The function setValue(Animal&,int) was declared to be a friend, but the overloaded
function setValue(Animal&,int,int) was not declared to be a friend.
8. Fix Exercise 7 so it compiles.
1:
2:
3:
4:
5:
6:
7:
8:
9:
#include <iostream.h>
class Animal;
void setValue(Animal& , int);
void setValue(Animal& ,int,int); // here's the change!
class Animal
{10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
friend void setValue(Animal& ,int);
friend void setValue(Animal& ,int,int);
private:
int itsWeight;
int itsAge;
};
void setValue(Animal& theAnimal, int theWeight)
{
theAnimal.itsWeight = theWeight;
}
void setValue(Animal& theAnimal, int theWeight, int theAge)
{
theAnimal.itsWeight = theWeight;
theAnimal.itsAge = theAge;
}
int main()
{
Animal peppy;
setValue(peppy,5);
setValue(peppy,7,9);
return 0;
}
Day 16
Quiz
1. What is the insertion operator and what does it do?
The insertion operator (<<) is a member operator of the ostream object and is used for
writing to the output device.
2. What is the extraction operator and what does it do?
The extraction operator (>>) is a member operator of the istream object and is used for
writing to your program's variables.
3. What are the three forms of cin.get() and what are their differences?
The first form of get() is without parameters. This returns the value of the character found,
and will return EOF (end of file) if the end of the file is reached.
The second form of cin.get() takes a character reference as its parameter; that character isfilled with the next character in the input stream. The return value is an iostream object.
The third form of cin.get() takes an array, a maximum number of characters to get, and a
terminating character. This form of get() fills the array with up to one fewer characters than
the maximum (appending null) unless it reads the terminating character, in which case it
immediately
writes a null and leaves the terminating character in the buffer.
4. What is the difference between cin.read() and cin.getline()?
cin.read() is used for reading binary data structures.
getline() is used to read from the istream's buffer.
5. What is the default width for ouputting a long integer using the insertion operator?
Wide enough to display the entire number.
6. What is the return value of the insertion operator?
A reference to an istream object.
7. What parameter does the constructor to an ofstream object take?
The filename to be opened.
8. What does the ios::ate argument do?
ios::ate places you at the end of the file, but you can write data anywhere in the file.
Exercises
1. Write a program that writes to the four standard iostream objects: cin, cout, cerr,
and clog.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
#include <iostream.h>
int main()
{
int x;
cout << "Enter a number: ";
cin >> x;
cout << "You entered: " << x << endl;
cerr << "Uh oh, this to cerr!" << endl;
clog << "Uh oh, this to clog!" << endl;
return 0;
}
2. Write a program that prompts the user to enter her full name and then displays it on the
screen.1:
2:
3:
4:
5:
6:
7:
8:
9:
#include <iostream.h>
int main()
{
char name[80];
cout << "Enter your full name: ";
cin.getline(name,80);
cout << "\nYou entered: " << name << endl;
return 0;
}
3. Rewrite Listing 16.9 to do the same thing, but without using putback() or ignore().
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
// Listing
#include <iostream.h>
int main()
{
char ch;
cout << "enter a phrase: ";
while ( cin.get(ch) )
{
switch (ch)
{
case `!':
cout << `$';
break;
case `#':
break;
default:
cout << ch;
break;
}
}
return 0;
}
4. Write a program that takes a filename as a parameter and opens the file for reading. Read
every character of the file and display only the letters and punctuation to the screen. (Ignore all
non-printing characters.) Then close the file and exit.
1:
2:
3:
4:
5:
#include <fstream.h>
enum BOOL { FALSE, TRUE };
int main(int argc, char**argv)
{
// returns 1 on error6:
7:
if (argc != 2)
8:
{
9:
cout << "Usage: argv[0] <infile>\n";
10:
return(1);
11:
}
12:
13:
// open the input stream
14:
ifstream fin (argv[1],ios::binary);
15:
if (!fin)
16:
{
17:
cout << "Unable to open " << argv[1] << " for
reading.\n";
18:
return(1);
19:
}
20:
21:
char ch;
22:
while ( fin.get(ch))
23:
if ((ch > 32 && ch < 127) || ch == `\n' || ch == `\t')
24:
cout << ch;
25:
fin.close();
26:
}
5. Write a program that displays its command-line arguments in reverse order and does not
display the program name.
1:
2:
3:
4:
5:
6:
7:
#include <fstream.h>
int main(int argc, char**argv)
// returns 1 on error
{
for (int ctr = argc; ctr ; ctr--)
cout << argv[ctr] << " ";
}
Day 17
Quiz
1. What is an inclusion guard?
Inclusion guards are used to protect a header file from being included into a program more than
once.
2. How do you instruct your compiler to print the contents of the intermediate file
showing the effects of the preprocessor?This quiz question must be answered by you, depending on the compiler you are using.
3. What is the difference between #define debug 0 and #undef debug?
#define debug 0 defines the term debug to equal 0 (zero). Everywhere the word debug
is found, the character 0 will be substituted. #undef debug removes any definition of
debug; when the word debug is found in the file, it will be left unchanged.
4. Name four predefined macros.
__DATE__, __TIME__, __FILE__, __LINE__
5. Why can't you call invariants() as the first line of your constructor?
The job of your constructor is to create the object. The class invariants cannot and should not
exist before the object is fully created, so any meaningful use of invariants() will return
false until the constructor is finished.
Exercises
1. Write the inclusion guard statements for the header file STRING.H.
#ifndef STRING_H
#define STRING_H
...
#endif
2. Write an assert() macro that prints an error message and the file and line number if
debug level is 2, prints just a message (without file and line number) if the level is 1, and does
nothing if the level is 0.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
#include <iostream.h>
#ifndef DEBUG
#define ASSERT(x)
#elif DEBUG == 1
#define ASSERT(x) \
if (! (x)) \
{ \
cout << "ERROR!! Assert " << #x << " failed\n"; \
}
#elif DEBUG == 2
#define ASSERT(x) \
if (! (x) ) \
{ \
cout << "ERROR!! Assert " << #x << " failed\n"; \16:
17:
18:
19:
cout << " on line " << __LINE__ << "\n"; \
cout << " in file " << __FILE__ << "\n"; \
}
#endif
3. Write a macro DPrint that tests whether debug is defined, and if it is, prints the value
passed in as a parameter.
#ifndef DEBUG
#define DPRINT(string)
#else
#define DPRINT(STRING) cout << #STRING ;
#endif
4. Write a function that prints an error message. The function should print the line number and
filename where the error occurred. Note that the line number and filename are passed in to this
function.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
#include <iostream.h>
void ErrorFunc(
int LineNumber,
const char * FileName)
{
cout << "An error occurred in file ";
cout << FileName;
cout << " at line "
cout << LineNumber << endl;
}
5. How would you call the preceding error function?
1:
2:
3:
4:
5:
6:
7:
// driver program to exercise ErrorFunc
int main()
{
cout << "An error occurs on next line!";
ErrorFunc(__LINE__, __FILE__);
return 0;
}
Note that the __LINE__ and __FILE__ macros are used at the point of the error, and not in
the error function. If you used them in the error function, they would report the line and file for
the error function itself.
6. Write an assert() macro that uses the error function from Exercise 4, and write a driverprogram that calls that assert() macro.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
#include <iostream.h>
#define DEBUG // turn error handling on
#ifndef DEBUG
#define ASSERT(x)
#else
#define ASSERT(X) \
if (! (X)) \
{
\
ErrorFunc(__LINE__, __FILE__); \
}
#endif
void ErrorFunc(int LineNumber, const char * FileName)
{
cout << "An error occurred in file ";
cout << FileName;
cout << " at line ";
cout << LineNumber << endl;
}
// driver program to exercise ErrorFunc
int main()
{
int x = 5;
ASSERT(x >= 5); // no error
x = 3;
ASSERT(x >= 5); // error!
return 0;
}
Note that in this case, the __LINE__ and __FILE__ macros can be called in the assert()
macro and will still give the correct line (line 29). This is because the assert() macro is
expanded in place, where it is called. Therefore, this program is evaluated exactly as if
main() were written as
1:
2:
3:
4:
5:
6:
7:
// driver program to exercise ErrorFunc
int main()
{
int x = 5;
if (! (x >= 5)) {ErrorFunc(__LINE__, __FILE__);}
x = 3;
if (! (x >= 5)) {ErrorFunc(__LINE__, __FILE__);}8:
9:
return 0;
}
Day 18
Quiz
1. What is the difference between object-oriented programming and procedural
programming?
Procedural programming focuses on functions separate from data. Object-oriented
programming ties data and functionality together into objects, and focuses on the interaction
among the objects.
2. To what does "event-driven" refer?
Event-driven programs are distinguished by the fact that action is taken only in response to
some form of (usually external) simulation, such as a user's keyboard or mouse input.
3. What are the stages in the development cycle?
Typically, the development cycle includes analysis, design, coding, testing, programming, and
interaction and feedback among these stages.
4. What is a rooted hierarchy?
A rooted hierarchy is one in which all the classes in the program derive directly or indirectly
from a single base class.
5. What is a driver program?
A driver program is simply a function that is designed to exercise whatever objects and
functions you are currently programming.
6. What is encapsulation?
Encapsulation refers to the (desirable) trait of bringing together in one class all the data and
functionality of one discrete entity.
Exercises
1. Suppose you had to simulate the intersection of Massachusetts Avenue and Vassar Street--
two typical two-lane roads with traffic lights and crosswalks. The purpose of the simulation is
to determine whether the timing of the traffic signal allows for a smooth flow of traffic.
What kinds of objects should be modeled in the simulation? What should be the classes defined
for the simulation?Cars, motorcycles, trucks, bicycles, pedestrians, and emergency vehicles all use the
intersection. In addition, there is a traffic signal with Walk/Don't Walk lights.
Should the road surface be included in the simulation?
Certainly, road quality can have an effect on the traffic, but for a first design, it may be simpler
to leave this consideration aside. The first object is probably the intersection itself. Perhaps the
intersection object maintains lists of cars waiting to pass through the signal in each direction,
as well as lists of people waiting to cross at the crosswalks. It will need methods to choose
which and how many cars and people go through the intersection.
There will be only one intersection, so you may want to consider how you will ensure that only
one object is instantiated (hint: think about static methods and protected access).
People and cars are both clients of the intersection. They share a number of characteristics:
they can appear at any time, there can be any number of them, and they both wait at the signal
(although in different lines). This suggests that you will want to consider a common base class
for pedestrians and cars.
The classes would therefore include
class Entity;
// a client of the intersection
// the root of all cars, trucks, bicycles and emergency vehicles.
class Vehicle : Entity ...;
// the root of all People
class Pedestrian : Entity...;
class
class
class
class
class
Car : public Vehicle...;
Truck : public Vehicle...;
Motorcycle : public Vehicle...;
Bicycle : public Vehicle...;
Emergency_Vehicle : public Vehicle...;
// contains lists of cars and people waiting to pass
class Intersection;
2. Suppose the intersections from Exercise 1 were in a suburb of Boston, which has arguably
the unfriendliest streets in the United States. At any time, there are three kinds of Boston
drivers:
Locals, who continue to drive through intersections after the light turns red
Tourists, who drive slowly and cautiously (in a rental car, typically)Taxis, which have a wide variation of driving patterns, depending on the kinds of
passengers in the cabs
Also, Boston has two kinds of pedestrians:
Locals, who cross the street whenever they feel like it and seldom use the crosswalk
buttons
Tourists, who always use the crosswalk buttons and only cross when the Walk/Don't
Walk light permits.
Finally, Boston has bicyclists who never pay attention to stoplights
How do these considerations change the model?
A reasonable start on this would be to create derived objects that model the refinements
suggested by the problem:
class Local_Car
class
class
class
Pedestrian...;
class
Pedestrian...;
class
: public Car...;
Tourist_Car : public Car...;
Taxi : public Car...;
Local_Pedestrian : public
Tourist_Pedestrian : public
Boston_Bicycle : public Bicycle...;
By using virtual methods, each class can modify the generic behavior to meet its own
specifications. For example, the Boston driver can react to a red light differently than a tourist
does, while still inheriting the generic behaviors that continue to apply.
3. You are asked to design a group scheduler. The software allows you to arrange meetings
among individuals or groups, and to reserve a limited number of conference rooms. Identify
the principal subsystems.
Two discrete programs need to be written for this project: the client, which the users run; and
the server, which would run on a separate machine. In addition, the client machine would have
an administrative component to enable a system administrator to add new people and rooms.
If you decide to implement this as a client/server model, the client would accept input from
users and generate a request to the server. The server would service the request and send back
the results to the client. With this model, many people can schedule meetings at the same time.
On the client's side, there are two major subsystems in addition to the administrative module:
the user interface and the communications subsystem. The server's side consists of three main
subsystems: communications, scheduling, and a mail interface that would announce to the user
when changes have occurred in the schedule.4. Design and show the interfaces to the classes in the room-reservation portion of the program
discussed in Exercise 3.
A meeting is defined as a group of people reserving a room for a certain amount of time. The
person making the schedule might want a specific room, or a specified time; but the scheduler
must always be told how long the meeting will last and who is required to attend.
The objects will probably include the users of the system as well as the conference rooms.
Don't forget to include classes for the calendar, and perhaps a Meeting class that
encapsulates all that is known about a particular event.
The prototypes for the classes might include:
class Calendar_Class;
// forward reference
class Meeting;
// forward reference
class Configuration
{
public:
Configuration();
~Configuration();
Meeting Schedule( ListOfPerson&, Delta Time
duration );
Meeting Schedule( ListOfPerson&, Delta Time
duration, Time );
Meeting Schedule( ListOfPerson&, Delta Time
duration, Room );
ListOfPerson&
People();
// public
accessors
ListOfRoom&
Rooms();
// public accessors
protected:
ListOfRoom
rooms;
ListOfPerson
people;
};
typedef long
Room_ID;
class Room
{
public:
Room( String name, Room_ID id, int capacity,
String directions = "", String description = "" );
~Room();
Calendar_Class Calendar();
protected:
Calendar_Class
calendar;
int
capacity;
Room_ID
id;
String
name;String
directions;
// where is
this room?
String
description;
};
typedef long Person_ID;
class Person
{
public:
Person( String name, Person_ID id );
~Person();
Calendar_Class Calendar();
// the access
point to add meetings
protected:
Calendar_Class
calendar;
Person_ID
id;
String
name;
};
class Calendar_Class
{
public:
Calendar_Class();
~Calendar_Class();
void Add( const Meeting& );
meeting to the calendar
void Delete( const Meeting& );
Meeting* Lookup( Time );
there is a meeting at the
// add a
// see if
// given time
Block( Time, Duration, String reason = "" );
// allocate time to yourself...
protected:
OrderedListOfMeeting meetings;
};
class Meeting
{
public:
Meeting( ListOfPerson&, Room room,
Time when, Duration duration, String purpose
= "" );
~Meeting();
protected:
ListOfPerson
people;
Room
room;
Time
when;Duration
String
duration;
purpose;
};
Day 19
Quiz
1. What is the difference between a template and a macro?
Templates are built into the C++ language and are type-safe. Macros are implemented by the
preprocessor and are not type-safe.
2. What is the difference between the parameter to a template and the parameter to a
function?
The parameter to the template creates an instance of the template for each type. If you create
six template instances, six different classes or functions are created. The parameters to the
function change the behavior or data of the function, but only one function is created.
3. What is the difference between a type-specific template friend class and a general
template friend class?
The general template friend function creates one function for every type of the parameterized
class; the type-specific function creates a type-specific instance for each instance of the
parameterized class.
4. Is it possible to provide special behavior for one instance of a template but not for
other instances?
Yes, create a specialized function for the particular instance. In addition to creating
Array<t>::SomeFunction(), also create Array<int>::SomeFunction() to
change the behavior for integer arrays.
5. How many static variables are created if you put one static member into a template
class definition?
One for each instance of the class.
Exercises
1. Create a template based on this List class:
class List
{
private:public:
List():head(0),tail(0),theCount(0) {}
virtual ~List();
void insert( int value );
void append( int value );
int is_present( int value ) const;
int is_empty() const { return head == 0; }
int count() const { return theCount; }
private:
class ListCell
{
public:
ListCell(int value, ListCell *cell =
0):val(value),next(cell){}
int val;
ListCell *next;
};
ListCell *head;
ListCell *tail;
int theCount;
};
Here is one way to implement this template:
template <class Type>
class List
{
public:
List():head(0),tail(0),theCount(0) { }
virtual ~List();
void insert( Type value );
void append( Type value );
int is_present( Type value ) const;
int is_empty() const { return head == 0; }
int count() const { return theCount; }
private:
class ListCell
{
public:
ListCell(Type value, ListCell *cell =
0):val(value),next(cell){}
Type val;
ListCell *next;};
ListCell *head;
ListCell *tail;
int theCount;
};
2. Write the implementation for the List class (non-template) version.
void List::insert(int value)
{
ListCell *pt = new ListCell( value, head );
assert (pt != 0);
// this line added to handle tail
if ( head == 0 ) tail = pt;
head = pt;
theCount++;
}
void List::append( int value )
{
ListCell *pt = new ListCell( value );
if ( head == 0 )
head = pt;
else
tail->next = pt;
tail = pt;
theCount++;
}
int List::is_present( int value ) const
{
if ( head == 0 ) return 0;
if ( head->val == value || tail->val == value )
return 1;
ListCell *pt = head->next;
for (; pt != tail; pt = pt->next)
if ( pt->val == value )
return 1;
return 0;
}3. Write the template version of the implementations.
template <class Type>
List<Type>::~List()
{
ListCell *pt = head;
while ( pt )
{
ListCell *tmp = pt;
pt = pt->next;
delete tmp;
}
head = tail = 0;
}
template <class Type>
void List<Type>::insert(Type value)
{
ListCell *pt = new ListCell( value, head );
assert (pt != 0);
// this line added to handle tail
if ( head == 0 ) tail = pt;
head = pt;
theCount++;
}
template <class Type>
void List<Type>::append( Type value )
{
ListCell *pt = new ListCell( value );
if ( head == 0 )
head = pt;
else
tail->next = pt;
tail = pt;
theCount++;
}
template <class Type>
int List<Type>::is_present( Type value ) const
{
if ( head == 0 ) return 0;
if ( head->val == value || tail->val == value )return 1;
ListCell *pt = head->next;
for (; pt != tail; pt = pt->next)
if ( pt->val == value )
return 1;
return 0;
}
4. Declare three List objects: a list of strings, a list of Cats and a list of ints.
List<String> string_list;
List<Cat> Cat_List;
List<int> int_List;
5. BUG BUSTERS: What is wrong with the following code? (Assume the List template is
defined, and Cat is the class defined earlier in the book.)
List<Cat> Cat_List;
Cat Felix;
CatList.append( Felix );
cout << "Felix is " <<
( Cat_List.is_present( Felix ) ) ? "" : "not " << "present\n";
Hint: (this is tough) What makes Cat different from int?
Cat doesn't have operator == defined; all operations that compare the values in the List
cells, such as is_present, will result in compiler errors. To reduce the chance of this, put
copious comments before the template definition stating what operations must be defined for
the instantiation to compile.
6. Declare friend operator == for List.
friend int operator==( const Type& lhs, const Type& rhs );
7. Implement friend operator == for List.
template <class Type>
int List<Type>::operator==( const Type& lhs, const Type& rhs )
{
// compare lengths first
if ( lhs.theCount != rhs.theCount )
return 0;
// lengths differ
ListCell *lh = lhs.head;ListCell *rh = rhs.head;
for(; lh != 0; lh = lh.next, rh = rh.next )
if ( lh.value != rh.value )
return 0;
return 1;
// if they don't differ, they must match
}
8. Does operator== have the same problem as in Exercise 4?
Yes, because comparing the array involves comparing the elements, operator!= must be
defined for the elements as well.
9. Implement a template function for swap, which exchanges two variables.
// template swap:
// must have assignment and the copy constructor defined for the
Type.
template <class Type>
void swap( Type& lhs, Type& rhs)
{
Type temp( lhs );
lhs = rhs;
rhs = temp;
}
Day 20
Quiz
1. What is an exception?
An exception is an object that is created as a result of invoking the keyword throw. It is used
to signal an exceptional condition, and is passed up the call stack to the first catch statement
that handles its type.
2. What is a try block?
A try block is a set of statements that might generate an exception.
3. What is a catch statement?
A catch statement has a signature of the type of exception it handles. It follows a try block
and acts as the receiver of exceptions raised within the try block.4. What information can an exception contain?
An exception is an object and can contain any information that can be defined within a user-
created class.
5. When are exception objects created?
Exception objects are created when you invoke the keyword throw.
6. Should you pass exceptions by value or by reference?
In general, exceptions should be passed by reference. If you don't intend to modify the contents
of the exception object, you should pass a const reference.
7. Will a catch statement catch a derived exception if it is looking for the base class?
Yes, if you pass the exception by reference.
8. If there are two catch statements, one for base and one for derived, which should
come first?
catch statements are examined in the order they appear in the source code. The first catch
statement whose signature matches the exception is used.
9. What does catch(...) mean?
catch(...) will catch any exception of any type.
10. What is a breakpoint?
A breakpoint is a place in the code where the debugger will stop execution.
Exercises
1. Create a try block, a catch statement, and a simple exception.
#include <iostream.h>
class OutOfMemory {};
int main()
{
try
{
int *myInt = new int;
if (myInt == 0)
throw OutOfMemory();
}
catch (OutOfMemory){
cout << "Unable to allocate memory!\n";
}
return 0;
}
2. Modify the answer from Exercise 1, put data into the exception along with an accessor
function, and use it in the catch block.
#include <iostream.h>
#include <stdio.h>
#include <string.h>
class OutOfMemory
{
public:
OutOfMemory(char *);
char* GetString() { return itsString; }
private:
char* itsString;
};
OutOfMemory::OutOfMemory(char * theType)
{
itsString = new char[80];
char warning[] = "Out Of Memory! Can't allocate room for: ";
strncpy(itsString,warning,60);
strncat(itsString,theType,19);
}
int main()
{
try
{
int *myInt = new int;
if (myInt == 0)
throw OutOfMemory("int");
}
catch (OutOfMemory& theException)
{
cout << theException.GetString();
}
return 0;
}
3. Modify the class from Exercise 2 to be a hierarchy of exceptions. Modify the catch blockto use the derived objects and the base objects.
1:
#include <iostream.h>
2:
3:
// Abstract exception data type
4:
class Exception
5:
{
6:
public:
7:
Exception(){}
8:
virtual ~Exception(){}
9:
virtual void PrintError() = 0;
10:
};
11:
12:
// Derived class to handle memory problems.
13:
// Note no allocation of memory in this class!
14:
class OutOfMemory : public Exception
15:
{
16:
public:
17:
OutOfMemory(){}
18:
~OutOfMemory(){}
19:
virtual void PrintError();
20:
private:
21:
};
22:
23:
void OutOfMemory::PrintError()
24:
{
25:
cout << "Out of Memory!!\n";
26:
}
27:
28:
// Derived class to handle bad numbers
29:
class RangeError : public Exception
30:
{
31:
public:
32:
RangeError(unsigned long number){badNumber = number;}
33:
~RangeError(){}
34:
virtual void PrintError();
35:
virtual unsigned long GetNumber() { return badNumber; }
36:
virtual void SetNumber(unsigned long number) {badNumber =
$)number;}
37:
private:
38:
unsigned long badNumber;
39:
};
40:
41:
void RangeError::PrintError()
42:
{
43:
cout << "Number out of range. You used " << GetNumber()<<
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
the
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
"!"!!\n";
}
void MyFunction();
// func. prototype
int main()
{
try
{
MyFunction();
}
// Only one catch required, use virtual functions to do
// right thing.
catch (Exception& theException)
{
theException.PrintError();
}
return 0;
}
void MyFunction()
{
unsigned int *myInt = new unsigned int;
long testNumber;
if (myInt == 0)
throw OutOfMemory();
cout << "Enter an int: ";
cin >> testNumber;
// this weird test should be replaced by a series
// of tests to complain about bad user input
if (testNumber > 3768 || testNumber < 0)
throw RangeError(testNumber);
*myInt = testNumber;
cout << "Ok. myInt: " << *myInt;
delete myInt;
}
4. Modify the program from Exercise 3 to have three levels of function calls.
1:
2:
3:
4:
5:
#include <iostream.h>
// Abstract exception data type
class Exception
{6:
public:
7:
Exception(){}
8:
virtual ~Exception(){}
9:
virtual void PrintError() = 0;
10:
};
11:
12:
// Derived class to handle memory problems.
13:
// Note no allocation of memory in this class!
14:
class OutOfMemory : public Exception
15:
{
16:
public:
17:
OutOfMemory(){}
18:
~OutOfMemory(){}
19:
virtual void PrintError();
20:
private:
21:
};
22:
23:
void OutOfMemory::PrintError()
24:
{
25:
cout << "Out of Memory!!\n";
26:
}
27:
28:
// Derived class to handle bad numbers
29:
class RangeError : public Exception
30:
{
31:
public:
32:
RangeError(unsigned long number){badNumber = number;}
33:
~RangeError(){}
34:
virtual void PrintError();
35:
virtual unsigned long GetNumber() { return badNumber; }
36:
virtual void SetNumber(unsigned long number) {badNumber =
,,number;}
37:
private:
38:
unsigned long badNumber;
39:
};
40:
41:
void RangeError::PrintError()
42:
{
43:
cout << "Number out of range. You used " << GetNumber()
<<
")"!!\n";
44:
}
45:
46:
// func. prototypes
47:
void MyFunction();
48:
unsigned int * FunctionTwo();
49:
void FunctionThree(unsigned int *);50:
51:
52:
53:
54:
55:
56:
57:
the
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
int main()
{
try
{
MyFunction();
}
// Only one catch required, use virtual functions to do
// right thing.
catch (Exception& theException)
{
theException.PrintError();
}
return 0;
}
unsigned int * FunctionTwo()
{
unsigned int *myInt = new unsigned int;
if (myInt == 0)
throw OutOfMemory();
return myInt;
}
void MyFunction()
{
unsigned int *myInt = FunctionTwo();
FunctionThree(myInt);
cout << "Ok. myInt: " << *myInt;
delete myInt;
}
void FunctionThree(unsigned int *ptr)
{
long testNumber;
cout << "Enter an int: ";
cin >> testNumber;
// this weird test should be replaced by a series
// of tests to complain about bad user input
if (testNumber > 3768 || testNumber < 0)
throw RangeError(testNumber);
*ptr = testNumber;
}5. BUG BUSTERS: What is wrong with the following code?
#include "stringc.h"
// our string class
class xOutOfMemory
{
public:
xOutOfMemory( const String& where ) : location( where ){}
~xOutOfMemory(){}
virtual String where(){ return location };
private:
String location;
}
main()
{
try {
char *var = new char;
if ( var == 0 )
throw xOutOfMemory();
}
catch( xOutOfMemory& theException )
{
cout << "Out of memory at " << theException.location() <<
"\n";
}
}
In the process of handling an "out of memory" condition, a string object is created by the
constructor of xOutOfMemory. This exception can only be raised when the program is out of
memory, so this allocation must fail.
It is possible that trying to create this string will raise the same exception, creating an infinite
loop until the program crashes. If this string is really required, you can allocate the space in a
static buffer before beginning the program, and then use it as needed when the exception is
thrown.
Day 21
Quiz
1. What is the difference between strcpy() and strncpy()?
strcpy(char* destination, char* source) copies source to destination,
and puts a null at the end of destination. destination must be large enough to
accommodate source, or strcpy() will simply write past the end of the array.strncpy(char* destination char* source, int howmany) will write
howmany bytes of source to destination, but will not put a terminating null.
2. What does ctime() do?
ctime() takes a time_t variable and returns an ASCII string with the current time. The
time_t variable is typically filled by passing its address to time().
3. What is the function to call to turn an ASCII string into a long?
atol()
4. What does the complement operator do?
It flips every bit in a number.
5. What is the difference between OR and exclusive OR?
OR returns TRUE if either or both bits are set; exclusive OR returns TRUE only if one, but not
both, is set.
6. What is the difference between & and &&?
& is the bitwise AND operator, and && is the logical AND operator.
7. What is the difference between | and ||?
| is the bitwise OR operator, and || is the logical OR operator.
Exercises
1. Write a program to safely copy the contents of a 20-byte string into a 10-byte string,
truncating whatever won't fit.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
#include <iostream.h>
#include <string.h>
int main()
{
char bigString[21] = "12345678901234567890";
char smallString[10];
strncpy(smallString,bigString,9);
smallString[9]='\0';
cout << "BigString: " << bigString << endl;
cout << "smallString: " << smallString << endl;
return 0;13:
}
2. Write a program that tells the current date in the form 7/28/94.
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
#include <iostream.h>
#include <time.h>
int main()
{
time_t currentTime;
struct tm *timeStruct;
time (&currentTime);
timeStruct = localtime(&currentTime);
cout << timeStruct->tm_mon+1 << "/";
cout << timeStruct->tm_mday << "/";
cout << timeStruct->tm_year << " ";
return 0;
}
3. Write the definition of a class that uses bit fields to store whether the computer is
monochrome or color, a PC or Macintosh, a laptop or a desktop, and whether it has a CD-
ROM.
#include <iostream.h>
enum Boolean { FALSE = 0, TRUE = 1 };
class Computer
{
public: // types
enum Machine { Mac = 0, PC };
public: // methods
Computer( Boolean color, Boolean laptop, Machine kind, Boolean
cdrom )
: Color( color ), Laptop( laptop ), Kind( kind ), CDRom(
cdrom ){}
~Computer(){}
friend ostream& operator<<( ostream& os, const Computer&
computer );
private:
Boolean Color : 1;
Boolean Laptop : 1;
Machine Kind : 1;Boolean CDRom : 1;
};
ostream&
operator<<( ostream& os, const Computer& computer )
{
os << "[";
( computer.Color ) ? os << "color" : os << "monochrome";
os << ", ";
( computer.Laptop ) ? os << "laptop" : os << "desktop";
os << ", ";
( computer.Kind ) ? os << "PC" : os << "Mac";
os << ", ";
( computer.CDRom ) ? os << "" : os << "no ";
os << "CD-Rom";
os << "]";
return os;
}
int main()
{
Computer pc( TRUE, TRUE, Computer :: PC, TRUE );
cout << pc << `\n';
return 0;
}
4. Write a program that creates a 26-bit mask. Prompt the user to enter a word, and then
quickly report on which letters were used in setting and reading the bits (one bit per character).
The program should treat upper- and lowercase letters as the same.
#include <ctype.h>
#include <iostream.h>
#include <string.h>
class Bits
{
public:
enum { BITS_PER_INT = 16 };
Bits( int cnt );
virtual ~Bits();
void clear();
void set( int position );
void reset( int position );
int is_set( int position );
private:
unsigned int * bits;int count;
int Ints_Needed;
};
class AlphaBits : private Bits
{
public:
AlphaBits() : Bits( 26 ){}
~AlphaBits(){}
void clear() { Bits::clear(); }
void set( char );
void reset( char );
int is_set( char );
};
Bits :: Bits( int cnt ) : count( cnt )
{
Ints_Needed = count / BITS_PER_INT;
// if there is a remainder, you need one more member in array
if ( 0 != count % BITS_PER_INT )
Ints_Needed++;
// create an array of ints to hold all the bits
bits = new unsigned int[ Ints_Needed ];
clear();
}
Bits :: ~Bits()
{
delete [] bits;
}
void Bits :: clear()
{
// clear the bits
for ( int i = 0; i < Ints_Needed; i++ )
bits[ i ] = 0;
}
void Bits :: set( int position )
{
// find the bit to set
int Int_Number = position / BITS_PER_INT;
int Bit_Number = position % BITS_PER_INT;// create mask with that one bit set
unsigned int mask = 1 << Bit_Number;
// set the bit
bits[ Int_Number ] |= mask;
}
// clear the bit
void Bits :: reset( int position )
{
int Int_Number = position / BITS_PER_INT;
int Bit_Number = position % BITS_PER_INT;
unsigned int mask = ~( 1 << Bit_Number );
bits[ Int_Number ] &= mask;
}
int Bits :: is_set( int position )
{
int Int_Number = position / BITS_PER_INT;
int Bit_Number = position % BITS_PER_INT;
unsigned int mask = 1 << Bit_Number;
return ( 0 != ( bits[ Int_Number ] & mask ) );
}
void AlphaBits :: set( char s )
{
// make sure the requested character is an alphabetic
character
// if so, force it to lower case, then subtract the ascii
value
// of `a' to get its ordinal (where a = 0, b =1) and set that
bit
if ( isalpha( s ) )
Bits :: set( tolower( s ) - `a' );
}
void AlphaBits :: reset( char s )
{
if ( isalpha( s ) )
Bits :: reset( tolower( s ) - `a' );
}int AlphaBits :: is_set( char s )
{
if ( isalpha( s ) )
return Bits :: is_set( tolower( s ) - `a' );
else
return 0;
}
int main()
{
AlphaBits letters;
char buffer[512];
for (;;)
{
cout << "\nPlease type a word (0 to quit): ";
cin >> buffer;
if (strcmp(buffer,"0") == 0)
break;
// set the bits
for ( char *s = buffer; *s; s++ )
letters.set( *s );
// print the results
cout << "The letters used were: ";
for ( char c = `a'; c <= `z'; c++ )
if ( letters.is_set( c ) )
cout << c << ` `;
cout << `\n';
// clear the bits
letters.clear();
}
return 0;
5. Write a program that sorts the command-line parameters. If the user enters SortFunc
cat bird fish dog, the program prints bird cat dog fish.
#include <string.h>
#include <iostream.h>
void swap ( char* &s, char* &t )
{char* temp = s;
s = t;
t = temp;
}
int main( int argc, char* argv[] )
{
// Since argv[0] is the program name,
//we don't want to sort or print it;
// we start sorting at element 1 (not 0).
// a "Bubble
items.
int i,j;
for ( i = 1;
for ( j
if
Sort" is used because of the small number of
i < argc; i++ )
= i + 1; j < argc; j++ )
( 0 < strcmp( argv[i], argv[j] ) )
swap( argv[i], argv[j] );
for ( i = 1; i < argc; i++ )
cout << argv[i] << ` `;
cout << `\n';
return 0;
}
6. Write a program that adds two numbers without using the addition operator (+), subtraction
operator (-), increment (++), or decrement (--). Hint: Use the bit operators!
If you take a look at the addition of two bits, you'll notice the answer will contain two bits: the
result bit and the carry bit. Thus, adding 1 and 1 in binary results in 1 with a carry of 1. If we
add 101 to 001, here are the results:
101
001
110
// 5
//1
//6
If you add two "set" bits (each is valued as one), the result is that the result bit is 0 but the carry
bit is 1. If you add two clear bits, both the result and the carry are 0. If you add two bits with
one set and the other clear, the result bit is 1, but the carry bit is 0. Here is a table that
summarizes these rules:
lhs
rhs
|
carry
result
0
0
|
0
0
0
1
|
0
11
1
0
1
|
|
0
1
1
0
Examine the logic of the carry bit. If both bits to be added (lhs and rhs) are 0 or either side
is 0, the answer is 0. Only if both bits are 1 is the answer 1. This is exactly the same as the AND
operator (&).
In the same way, the result is an XOR (^) operation: if either bit is 1 (but not both), the answer
is 1; otherwise, the answer is 0.
When you get a carry, it is added to the next most significant (leftmost) bit. This implies either
iterating through each bit or recursion.
#include <iostream.h>
unsigned int add( unsigned int lhs, unsigned int rhs )
{
unsigned int result, carry;
while ( 1 )
{
result = lhs ^ rhs;
carry = lhs & rhs;
if ( carry == 0 )
break;
lhs = carry << 1;
rhs = result;
};
return result;
}
int main()
{
unsigned long a, b;
for (;;)
{
cout << "Enter two numbers. (0 0 to stop): ";
cin >> a >> b;
if (!a && !b)
break;
cout <<a << " + " << b << " = " << add(a,b) << endl;
}
return 0;
}Alternatively, you can solve this problem with recursion:
#include <iostream.h>
unsigned int add( unsigned int lhs, unsigned int rhs )
{
unsigned int carry = lhs & rhs;
unsigned int result = lhs ^ rhs;
if ( carry )
return add( result, carry << 1 );
else
return result;
}
int main()
{
unsigned long a, b;
for (;;)
{
cout << "Enter two numbers. (0 0 to stop): ";
cin >> a >> b;
if (!a && !b)
break;
cout <<a << " + " << b << " = " << add(a,b) << endl;
}
return 0;
}