Miskolci Egyetem ltalnos Informatikai Tanszk

Bevezets a C programozsi nyelvbe Az ltalnos Informatikai Tanszk C nyelvi kdolsi szabvnya

Oktatsi segdletek a levelez mszaki informatikus hallgatk szmra

Ksztette: Ficsor Lajos

Miskolc 2000
1. BEVEZETS.....................................................................................................................6 2. A C PROGRAMOZSI NYELV TRTNETE..................................................................7 1

3. A C NYELV ALAPVET TULAJDONSGAI:..................................................................7 4. A C NYELV PROGRAM FELPTSE..........................................................................8 5. SZINTAKTIKAI EGYSGEK.............................................................................................8

5.1 Azonostk.....................................................................................................................................................................8 5.2 Kulcsszavak..................................................................................................................................................................8 5.3 llandk........................................................................................................................................................................9 5.3.1 Egsz llandk ......................................................................................................................................................9 5.3.2 Karakterlland ....................................................................................................................................................9 5.3.3 Lebegpontos lland .........................................................................................................................................10 5.3.4 Karakterlnc ........................................................................................................................................................10 5.3.5 Opertorok ..........................................................................................................................................................10 5.3.6 Egyb elvlasztk ................................................................................................................................................10 5.3.7 Megjegyzsek ......................................................................................................................................................10

6. A C NYELV ALAPTPUSAI.............................................................................................11
6.1 Integrlis tpusok.......................................................................................................................................................11 6.2 Lebegpontos tpusok................................................................................................................................................11 6.3. A void tpusnv..........................................................................................................................................................12

7. KIFEJEZSEK S OPERTOROK...............................................................................12
7.1 A balrtk fogalma....................................................................................................................................................12 7.2 Kifejezsek s kirtkelsk.....................................................................................................................................12 7.3 Opertorok.................................................................................................................................................................12 7.3.1 Elsdleges opertorok .........................................................................................................................................12 7.3.2 Egyoperandus opertorok .................................................................................................................................13 7.3.3 Multiplikatv opertorok .....................................................................................................................................13 7.3.4 Additv opertorok ..............................................................................................................................................13 7.3.5 Lptet opertorok ..............................................................................................................................................14 7.3.6 Relcis opertorok .............................................................................................................................................14 7.3.7 Egyenlsgi opertorok .......................................................................................................................................14 7.3.8 Bitenknti S opertor ........................................................................................................................................14 7.3.9 Bitenknti kizr VAGY ....................................................................................................................................14 7.3.10 Bitenknti megenged VAGY ..........................................................................................................................14 7.3.11 Logikai S ........................................................................................................................................................14 7.3.12 Logikai VAGY ..................................................................................................................................................15 7.3.13 Feltteles opertor .............................................................................................................................................15 7.3.14 rtkad opertorok ..........................................................................................................................................15 7.3.15. Kifejezs lista....................................................................................................................................................16 7.3.16. Az opertor jelek sszefoglal tblzata..........................................................................................................16

8. LLAND KIFEJEZSEK..............................................................................................17 9 TMBK..........................................................................................................................17

9.1 Tmbdeklarci.........................................................................................................................................................17

9.2 Tmbelem - hivatkozs..............................................................................................................................................18

10. UTASTSOK...............................................................................................................18
10.1 Kifejezs utasts......................................................................................................................................................18 10.2 sszetett utasts vagy blokk..................................................................................................................................18 10.3 A feltteles utasts..................................................................................................................................................18 10.4 A while utasts........................................................................................................................................................19 10.5 A do utasts.............................................................................................................................................................19 10.6 A for utasts............................................................................................................................................................21 10.7 A switch utasts.......................................................................................................................................................21 10.8 A break utasts.......................................................................................................................................................22 10.9 A continue utasts...................................................................................................................................................22 10.10 A return utasts....................................................................................................................................................22 10.11 A goto utasts........................................................................................................................................................22 10.12 A cmkzett utasts...............................................................................................................................................22 10.13 Az res utasts......................................................................................................................................................23

11. EGYSZER INPUT-OUTPUT.......................................................................................23

11.1. Karakter beolvassa a standard inputrl.............................................................................................................23 11.2. Egy karakter kirsa a standard outputra...........................................................................................................23 11.3. Formzott kirs a standard outputra..................................................................................................................23

12. AZ ELS PLDAPROGRAMOK..................................................................................24

12.1. Pldaprogram..........................................................................................................................................................24 12.2 Pldaprogram...........................................................................................................................................................25

13. A FGGVNY...............................................................................................................26
13.1. Fggvny definci..................................................................................................................................................26 13.2. Fggvny deklarci (prototpus).........................................................................................................................26 13.3. A fggvny hvsa:..................................................................................................................................................27 13.4. Pldaprogram: faktorilis szmtsa....................................................................................................................27 13.5. Pldaprogram: egy sor beolvassa........................................................................................................................29

14. MUTATK.....................................................................................................................31
14.1 Mutatk deklarcija..............................................................................................................................................32 14.2 Cmaritmetika..........................................................................................................................................................32 14.3 Mutatk s tmbk..................................................................................................................................................34 14.4 Karakterlncok s mutatk....................................................................................................................................34 14.5 Mutat-tmbk, mutatkat cmz mutatk...........................................................................................................36 14.6 Tbbdimenzis tmbk s mutatk........................................................................................................................36 14.7. Mutat, mint fggvny argumentum....................................................................................................................37 14.8 Fggvnyeket megcmz mutatk..........................................................................................................................38 14.9. Pldaprogram: string msolsa.............................................................................................................................38 14.10 Pldaprogram: llaptsuk meg egy stringrl , hogy numerikus-e.....................................................................42 14.11 Pldaprogram: string konvertlsa egsz szmm............................................................................................45

15 OBJEKTUMOK DEKLARCIJA.................................................................................48
15.1 Definici s deklarci............................................................................................................................................48 15.2 A deklarci formja...............................................................................................................................................48 15.2.1 A tpusnv .........................................................................................................................................................49 15.2.2 A deklartor specifiktor...................................................................................................................................49 15.2.3 Trolsi osztlyok .............................................................................................................................................50 15.3 Kls s bels vltozk............................................................................................................................................50 15.4 Az rvnyessgi tartomny szablyai....................................................................................................................51 15.4.1 Lexiklis rvnyessgi tartomny .....................................................................................................................51 15.4.2 A kls azonostk rvnyessgi tartomnya ...................................................................................................51 15.5 Implicit deklarcik................................................................................................................................................53 15.6 Az inicializls.........................................................................................................................................................53 15.6.1 Kls s statikus vltozk inicializlsa ..........................................................................................................53 15.6.2 Automatikus s regiszter vltozk inicializlsa .............................................................................................54 15.6.3 Karaktertmb inicializlsa ..............................................................................................................................54

16. FOMATTLT BEOLVASS.........................................................................................54

16.1. Pldaprogam: egy vals tmb elemeinek beolvassa s rendezse....................................................................55 16.2. Pldaprogram: j elem beszrsa rendezett tmbbe..........................................................................................57

17. TBB FORRSFILE-BL LL PROGRAMOK.......................................................58

17.1. Pldaprogram: egy szveg sorainak, szavainak s karaktereinek szma........................................................59

18. A STRUKTRA S AZ UNI.......................................................................................61

18.1 A struktra deklarcija.........................................................................................................................................61 18.2 Hivatkozs a struktra elemeire............................................................................................................................62 18.3 Struktra - tmbk..................................................................................................................................................63 18.4. Uni..........................................................................................................................................................................63 18.5. Pldaprogram: sz-statisztika (1. vltozat)..........................................................................................................64

19. DINAMIKUS MEMRIA KEZELS...............................................................................69

19.1 Memriakezel fggvnyek....................................................................................................................................70 19.2. Pldaprogram: sz-statisztika (2. vltozat)..........................................................................................................70

20. PARANCSSOR-ARGUMENTUMOK............................................................................72 21. SZABVNYOS FGGVNYEK....................................................................................73

21.1. Szabvnyos header file-ok......................................................................................................................................74 21.2. String kezel fggvnyek.......................................................................................................................................74 21.2.1. Karaktertalakt fggvnyek...........................................................................................................................74 21.2.2. Tovbbi string-kezel fggvnyek:...................................................................................................................74 21.2.3 Konvertl fggvnyek......................................................................................................................................75 21.3. File kezel fggvnyek...........................................................................................................................................75 21.3.1 File megnyitsa s lezrsa................................................................................................................................75 21.3.2 rs s olvass.....................................................................................................................................................77 21.3.3 Pozicionls a file-ban.......................................................................................................................................78 21.4. Pldaprogram: string keresse file-ban................................................................................................................78

AJNLOTT IRODALOM:....................................................................................................82 KDOLSI SZABVNY.....................................................................................................83

1. Bevezets
Ez az oktatsi segdlet a Miskolci Egyetem mszaki informatikus hallgati rszre kszlt, a Software fejleszts I. cm trgy elsajttsnak megknnytsre. A jegyzet felttelezi, hogy olvasja rendelkezik alapvet programozstechnikai alapismeretekkel (alapvet vezrlsi szerkezetek, tpusok stb.), gy clja nem programozstechnikai bevezets, hanem a C programozsi nyelv ttekintse. Ugyanakkor az egyes C nyelvi szerkezetek hasznlatt igyekszik pldkkal szemlltetni, amelyek egyben az alapvet algo ritmusok ismeretnek feleleventst is segtik. A jegyzet alapja a szabvnyos (ANSI C) nyelv. Terjedelmi okok miatt nem trekedhettnk a teljessgre mr az egyes nyelvi elemek ismertetsnl sem, fleg pedig a nyelv hasznlathoz egybknt alapveten szksges szabvnyos fggvnyknyvtr esetn. A jegyzetet pldaprogramok egsztik ki. A pldaprogramok kztt megtallhat minden olyan kd, amely a szvegben szerepel, de tallunk tovbbi pldkat is.

2. A C programozsi nyelv trtnete

A C programozsi nyelvet eredetileg a UNIX opercis rendszer rszre fejlesztette ki Dennis M. Ritchie 1972-ben, az AT&T Bell Laboratories-ben, rszben a UNIX rendszerek f programozsi nyelvnek sznva, rszben magnak az opercis rendszernek s segdprogramjainak a meg rsra hasznlva. Az idk sorn ezen a szerepen messze tlnve kedvelt ltalnos cl programozsi nyelvv vlt. Brian W. Kernighan s Dennis M. Ritchie 1978-ban adtk ki a The C programming Language (A C programozsi nyelv) cm knyvket, amely hamarosa n a nyelv kvzi szabvnyv vlt. Valamennyi fordtprogram rja - s ezrt valamennyi programoz is - ezt tekintette a nyelv defincijnak. Ez volt a "K&R C". A nyelv folyamatos hasznlatnak tapasztalatait is figyelembe vve az ANSI (az amerikai szabvnygyi hivatal) 1989-ben hivatalosan is szabvnyostotta a C nyelvet. Ezt hvjuk ANSI C-nek. Ma mr valamennyi fordtprogramnak ezzel a szabvnnyal sszhangban kell kszlnie. A jegyzet tovbbi rszben C programozsi nyelv alatt mindig az ANSI C-t rtjk. A nyelv elterjedst mutatja, hogy ma valamennyi elterjedt hardware-re (mikrogpektl a nagy main-frame rendszerekig) s opercis rendszer al elksztettk a fordtprogramjt, az esetek tbbsgben tbbet is.

3. A C nyelv alapvet tulajdonsgai:

1. Viszonylag alacsony szint, ami az albbiakat jelenti egyszer alapobjektumok: karakterek, szmok, cmek nincsenek sszetett objektumokat kezel utastsok nincsenek input-output utastsok a fentiekbl kvetkezen viszonylag kicsi, s knnyen elsajtthat vgl ezek miatt kicsi s hatkony fordtprogram kszthet hozz. 2. Nem tmogatja a prhuzamos feldolgozst, a tbbprocesszoros rendszereket. 3. A C nyelven megrt program ltalban elg kicsi s hatkony gpi kdot eredmnyez, ezltal az assembly szint programozst a legtbb terleten kpes kivltani. 4. Az egsz nyelv logikja s gondolkodsmdja a gpfggetlensgre trekvsen alapul, ezltal elsegti a portbilis programok ksztst. 5. Szmos implementci (fordtprogram, fejlesztsi krnyezet) ll rendelkezsre. 6. A hatkony programozst minden fejlesztsi krnyezetben gazdag fggvnykszlet segti. A rendelkezsre ll fggvnyek az albbi f csoportra oszthatk: minden fejlesztsi krnyezetben rendelkezsre ll szabvnyos fggvnyek adott alkalmazsi terlet specilis feladatainak megoldst segt fggvnyek

gpspecifikus, de az adott hardware specilis kezelst is lehetv tev fggvnyek

A fenti fggvnyek hasznlata - a feladat jellegtl fggen - lehetv teszi a gpfggetlen programozst s az adott hardware sajtossgait maximlisan kihasznl - s ezrt nehezen hordozhat - programok rst is.

4. A C nyelv program felptse

Minden C program az albbi alapvet felptst mutatja: preprocesszor direktvk, pragmk globlis deklarcik main() { loklis deklarcik utastsok} fggvny - definicik

5. Szintaktikai egysgek
A C programok az albbi alapvet szintaktikai egysgekbl plnek fel:

azonostk kulcsszavak llandk karakterlncok opertorok egyb elvlasztk megjegyzsek

5.1 Azonostk Betk s szmjegyek sorozata, betvel vagy _ (alhzs) karakterrel kell kezddnie. A nagy- s kisbetk klnbzek. Az azonostk tetszleges hosszsgak lehetnek, de implementcitl fggen csak az els meghatrozott szm karakterk vesz rszt a megk lnbztetsben. (Pldul a BORLAND C++ 3.1 esetn alaprtelmezsben az els 32 karakter szignifikns. Ez az rtk vltoztathat.) 5.2 Kulcsszavak

Csak meghatrozott clra hasznlhat azonostk. Kisbetvel kell rni. (Teht int kulcssz, INT vagy Int ltalnos cl azonost - br nem illik hasznlni.) A hivatkozsi nyelv az albbi azonostkat tartja fenn kulcssznak: auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while

Az egyes implementcik mg jabb azonostkat is kezelhetnek fenntartott kulcsszavakknt. 5.3 llandk 5.3.1 Egsz llandk A szmjegyek sorozatt tartalmaz, nem nullval kezdd egsz szm decimlis lland. Az egsz lland megadhat mg az albbi alakokban:

oktlis, ha vezet 0-val kezddik hexadecimlis, ha 0X vagy 0x vezeti be. A 10-15-ig terjed szmjegyek jellsre az a-f vagy A-F karakterek hasznlhatk.

Ha a decimlis lland rtke az adott implementci eljeles " int" tpusnak brzolsi tartomnyn, vagy ha az oktlis illetve hexadecimlis lland az "unsigned int" tpus brzolsi tartomnyn kvl esik, az lland automatikusan "long" tpusv alakul. (Rszletesebben lsd az alaptpusok ismertetsnl.) Ha az egsz llandt l vagy L bet kveti, mindenkppen "long"- nak megfelel helyet foglal el. 5.3.2 Karakterlland Aposztrfok kztt egy karakter. rtke az adott karakter kdja. Bizonyos, nem nyomtathat karakterek helyett rhat gynevezett "Escape -szekvencia", az albbiak szerint: \n \t \v \b \r \f \a jsor(LF) vzszintes tabultor fggleges tabultor backspace (BS) kocsivissza (CR) lapdobs (FF) hangjelzs (BELL) 9

\\ \? \' \" \ooo \xhh

backslash (\) krdjel aposztrf idzjel az oktlis ooo kd karakter (ooo egy-, ktvagy hromjegy oktlis szm) a hexadecimlis hh kd karakter

Ha a \ karaktert nem a fentiek valamelyike kveti, a \ figyelmen kvl marad. 5.3.3 Lebegpontos lland Az egszrsz.trtrsz E kitev vagy egszrsz.trtrsz e kitev

alak konstans lebegpontos szmot jelent. Nem hinyozhat egyszerre az egszrsz s a trtrsz. A tizedespont vagy a kitevrsz kzl az egyik elmaradhat, de a kett egyszerre nem. A kitevrszben az e vagy E bet s az azt kvet szm csak egytt hinyozhat. Uttagknt megadhat az f vagy F, amely egyszeres pontossgot, illetve az l vagy L, amely dupla pontossgot r el. Uttag hinyban duplapontossg. 5.3.4 Karakterlnc Idzjelek kz zrt karaktersorozat. Az utols karaktere utn 0 byte kerl. Hasznlhatk az Escape-szekvencik. Karakterlncon bell idzjel \" alakban rhat. Ha tbb sorban fr ki, a sort \ -el kell zrni. A karakterlncot a fordtprogram olyan static trolsi osztly karaktertmbknt kezeli, amelyet a megadott karakterek inicializlnak. 5.3.5 Opertorok A C nyelvben nagyon sokfle opertor van, egy- kt- s hromoperandusak lehetnek. Az opertorokat teljes rszletessggel a kifejezseknl ismertetjk. 5.3.6 Egyb elvlasztk Legfontosabb a ; (pontosvessz), amely az utasts vgt jelzi, de ilyen a { s } is. 5.3.7 Megjegyzsek 10

/* -al kezdd, */ -el vgzd karaktersorozat. Nem skatulyzhat egymsba, de tetszleges hosszsg lehet.

6. A C nyelv alaptpusai
A C nyelvben elre definilt alaptpusokat, s ezekbl szrmaztatott sszetett tpusokat (aggregtumokat) hasznlhatunk. Ebben a pontban felsoroljuk az sszes elre definilt tpust s a helyfoglalsukat. 6.1 Integrlis tpusok Tpusnv char int short (int) long (int) Hossz 1 byte gpfgg, a "termszetes" hossz (szhossz) (legalbb) 16 bit (legalbb) 32 bit

A nyelv csak azt rja el, hogy a tpusok hosszra a short <= int s teljesljn. Mindegyik tpusnv el rhat egy kulcssz, ami az eljeles/eljel nlkli brzolst rja el, az albbiak szerint: signed (eljeles) - a char kivtelvel ez a default unsigned (eljel nlkli) A char tpus eljelessge gpfgg. Csak az biztos, hogy mi nden nyomtathat karakter pozitv, mint egsz szm. A char tpus a neve szerint karakterek kezelsre szolgl. Mivel azonban egy karakter trolsa a kdjnak, mint egsz szmnak a trolst jelenti, ez a tpus minden tovbbi nlkl hasznlhat rvid egsz szmknt, s alkalmazhat minden aritmetikai kifejezsben. Valjban a C nyelv teht nem tartalmaz karakter tpust. int <= long

6.2 Lebegpontos tpusok Tpusnv float double long double Hossz gpfgg (ltalban 4 byte) gpfgg (ltalban 8 byte) gpfgg (ltalban 16 byte)

11

6.3. A void tpusnv A void tpusnevet a C nyelv specilis clokra tartja fenn.

7. Kifejezsek s opertorok
7.1 A balrtk fogalma Objektumnak nevezzk a C nyelvben a memria valamely mveletekkel kezelhet rszt. A balrtk objektumra hivatkoz kifejezs. (Tulajdonkppen amelynek meghatrozott cme van a memriban.) Kzenfekv plda a vltoz, de mint ksbb ltni fogjuk - bonyolultabb szerkezet is lehet. Nevt onnan kapta, hogy llhat rtkads baloldaln. (De nem csak ott!)

7.2 Kifejezsek s kirtkelsk A kifejezs operandusok s opertorok sorozata. A kirtkels sorrendjt az opertorok precedencija hatrozza meg, s az, hogy balra vagy jobbra ktnek. A precendencia - sorrendtl eltr kirtkelsi sorrendet zrjelezssel rhatunk el. Kommutatv s asszociatv opertorokat (*, +, &, |, ~) tartalmaz kifejezsek kirtkelsi sorrendje (mg zrjelezs esetn is!) meghatrozatlan. A kirtkels sorn konverzik trtn(het)nek: ezt nevezzk szoksos aritmetikai konverzinak. A konverzi pontos szablyait a nyelv defincija rgzti (lsd pl. [2] 215. oldal), de itt nem idzzk, mert els olvassra bonyolultnak tnik. A lnyege az, hogy mindig a pontosabb szmols s az adatveszts elkerlsnek irnyba konvertldnak a tpusok. gy pldul az egsz lebegpontoss, a rvid hosszabb, az eljeles eljel nlkliv alakul, ha szksges.

7.3 Opertorok Az opertorok felsorolsa a precedencijuk cskken sorrendjben trtnik. Egy alponton bell a precedencia azonos s a felsorols teljes. 7.3.1 Elsdleges opertorok ( ) : zrjelek [ ] : indexels . : hivatkozs struktra-tagra -> : hivatkozs struktra-tagra struktra-mutatval

12

Csoportosts balrl jobbra.

7.3.2 Egyoperandus opertorok Csoportosts jobbrl balra. *kifejezs &balrtk +kifejezs -kifejezs !kifejezs ~kifejezs ++ balrtk -- balrtk (tpusnv)kifejezs sizeof kifejezs sizeof (tpusnv) indirekci (hivatkozs adott cmen lev rtkre) mutat - kpzs egyoperandus + (szimmetria okokbl) egyoperandus logikai nem: ha a kifejezs 0, az eredmny 1, ha a kifejezs nem 0, az eredmny 0. Egsz rtket ad. az egsz kifejezs rtknek 1-es komplemense. (Bitenknti negcija) inkrementls dekrementls a kifejezs a megadott tpusv alakul t ("cast") az operandus mrete byte-ban az adott tpus mrete byte-ban

A balrtk ++ s a balrtk-- specilis C nyelvi opertorok. Hatsra a balrtk rtke eggyel n vagy cskken. Ha a ++ vagy -- a balrtktl balra van, az rtk megvltozik, s ezutn ez a megvltozott rtk kerl felhasznlsra. Ha a ++ vagy -- a balrtk utn helyezkedett el, a b alrtk felhasznldik, majd utna vltozik meg az rtke. 7.3.3 Multiplikatv opertorok Csoportosts balrl jobbra. * : szorzs / : oszts % : maradkkpzs Pozitv egszek osztsa esetn az eredmny csonkul, ha valamelyik negatv, az eredmny gpfgg lehet. (ltalban az osztand s a maradk eljele megegyezik.) Az a%b az a- nak b- vel val osztsa sorn kapott maradkot jelenti. Az a-nak s b-nek itegrlis tpusnak kell lennie. Mindig igaz, hogy (a/b)*b + a%b = a (ha b # 0) 7.3.4 Additv opertorok Csoportosts balrl jobbra.

13

+ : sszeads - : kivons

7.3.5 Lptet opertorok Csoportosts balrl jobbra. a<<b az a-t, mint bitmintt balra lpteti b bittel, a jobboldalon 0 bitek lpnek be. a>>b mint fennt, de jobbra lptet. A belp bit 0, ha a unsigned, egybknt az eljel bit lp be. A mvelet vgzse eltt az elzekben emltett aritmetikai konverzik vgrehajtdnak. Az eredmny int tpus lesz. a s b csak egsz tpus lehet, b-nek pozitvnak kell lennie. Ha b negatv, vagy rtke tl nagy, az eredmny hatrozatlan. 7.3.6 Relcis opertorok Csoportosts balrl jobbra. < > <= >=

rtkk int tpus, s 0 (hamis) vagy 1 (igaz). Megjegyzs: mutatk is sszehasonlthatk! 7.3.7 Egyenlsgi opertorok Csoportosts balrl jobbra. == : egyenl != : nem egyenl rtkk int tpus, s 0 (hamis) vagy 1 (igaz). Megjegyzs: mutatk is sszehasonlthatk! 7.3.8 Bitenknti S opertor Jele: & Mindkt operandusnak integrlis tpusnak kell lennie. 7.3.9 Bitenknti kizr VAGY Jele: ^ Mindkt operandusnak integrlis tpusnak kell lennie. 7.3.10 Bitenknti megenged VAGY Jele: | Mindkt operandusnak integrlis tpusnak kell lennie. 7.3.11 Logikai S

14

Jele: && Mindkt operandusnak valamilyen alaptpusnak vagy mutatnak kell lennie. Az eredmny 0 (hamis) vagy 1 (igaz). Balrl jobbra hajtdik vgre, s a msodik operandus nem rtkeldik ki, ha az els rtke 0!

7.3.12 Logikai VAGY Jele: || Mindkt operandusnak valamelyik alaptpusnak vagy mutatnak kell lennie. Az eredmny 0 (hamis) vagy 1 (igaz). Balrl jobbra rtkeldik ki, s a msodik operandus nem rtkeldik ki, ha az els rtke nem nulla. 7.3.13 Feltteles opertor A feltteles kifejezs formja: k1 ? k2: k3 Balrl jobbra csoportost. Vgrehajtsa: kirtkeldik az els kifejezs, s ha annak rtke nem 0, az eredmny a k2 lesz, egybknt a k3. A k2 s a k3 kzl csak az egyik (a szksges) rtkeldik ki. Pldul az a = k1? k2 : k3 rtkads egyenrtk az if (k1) a=k2; else a=k3; programrszlettel. 7.3.14 rtkad opertorok Mindegyik rtkad opertor jobbrl balra csoportost. Kt fajtja van: 1. egyszer rtkad opertor Formja: balrtk = kifejezs A kifejezs kirtkeldik, a balrtk (esetleg konverzi utn) felveszi ezt az rtket, s ez lesz a mvelet rtke is. 2. sszetett rtkad opertor. Formja: balrtk x= kifejezs ahol x az albbi mveletek egyike lehet:

15

+, -, *, /, %, >>, <<, &, ^, ! Az E1 x= E2 (E1, E2 kifejezsek) hatsa ugyanaz, mint az E1=E1 x E2 kifejezsnek, de az E1 csak egyszer rtkeldik ki. Megjegyzs A C nyelvben az rtkad kifejezs ktarc: pontosvesszvel lezrva rtkad utastsknt viselkedik, de rhat brhov, ahov kifejezst lehet rni, s ilyenkor rtke a baloldal rtke. Plda: az albbi kt programrszlet egyenrtk: a=kifejezs if(a>10) utasts; if ( (a=kifejezs)>10 ) utasts; Itt az a=kifejezs krli zrjel nem flsleges, mert az = opertor precedencija kisebb, mint a > opertor. Az a=kifejezs > 10 egyenrtk az a=(kifejezs>10) alakkal, aminek hatsra a a 0 vagy 1 rtket veszi fl. 7.3.15. Kifejezs lista Formja: K1,K2 ahol K1 s K2 kifejezsek. Hatsra elbb a K1, majd a K2 kifejezs kirtkeldik. A mvelet eredmnye a K2 rtke. 7.3.16. Az opertor jelek sszefoglal tblzata A knnyebb ttekinthetsg kedvrt tblzatba foglalva megismteljk az opertor jeleket. Csoport elsdleges egyoperandus multiplikatv additv eltols relcis egyenlsg AND XOR OR Opertorok (), [], ->, . cast, sizeof, &, *, ++, --, ~ ! *, /, % +, <<, >> <, <=, >, >= ==, != & ^ | 16 Asszociativits b-j j-b b-j b-j b-j b-j b-j b-j b-j b-j

logikai AND logikai OR rtkads kif. lista

&& || =, +=, -=, /=, %=, >>=, <<=, &=, ^= , (vessz)

b-j b-j j-b b-j

8. lland kifejezsek
lland kifejezs az, amelyben

egsz llandk karakterllandk sizeof kifejezsek

valamint az albbi opertorok szerepelhetnek: + - * / % & I ^ << >> == != < > <= >=

Zrjelezs s feltteles kifejezs a fenti elemekbl megengedett. Vals konstans vagy vltoz kezdrtkadshoz vals operandusok is lehetnek. Hasznlhatk:

kezdeti rtkknt tmbdeklarciban case szerkezetben

9 Tmbk
A tmb lehetv teszi, hogy egy nv alatt sszefoglalhassunk tbb rtket. A tmb valamennyi eleme azonos tpus. Az egyes rtkekre indexelssel (vagy mutatkifejezssel) hivatkozhatunk. Az indexek szmtl fggen a tmb lehet egy- vagy tbbdimenzis. 9.1 Tmbdeklarci A tmbket deklarlni kell. A deklarciban meg kell adni a tmb nevt, indexeinek szmt s az elemek darabszmt. Az indexek als hatra 0! A deklarci formja: tipus nv[dbszm]{[dbszm]...} ahol "dbszm" az elemek szma, tetszleges lland kifejezs. Pldk: char line[80];

17

int matrix[50][60]; A tmbelemek szma inicializlssal kzvetetten is megadhat! (Rszletesen lsd ksbb!)

9.2 Tmbelem - hivatkozs A tmb egyes elemeire val hivatkozsnl minden index helyre egy egsz kifejezs rhat. A kifejezs deklarlt hatrok kz esst ltalban nem ellenrzi a program!

10. Utastsok
Az albbiakban felsoroljuk a C nyelv valamennyi utastst, szintaktikai s szemantikai lersval. Az utastsok formjnak lersnl a kulcszavakat s az utasts egyb ktelez "tartozkait" vastagtott szedssel emeljk ki. 10.1 Kifejezs utasts Formja: kifejezs; A kifejezs legtbbszr rtkads vagy fggvnyhvs.

10.2 sszetett utasts vagy blokk Formja: sszetett utasts: { utastsok } blokk: { deklarcik utastsok } sszetett utasts mindentt lehet, ahol a szintaktikban "utasts" szerepel. Lehetsges (de kerlend) az sszetett utasts belsejbe val ugrs.

10.3 A feltteles utasts

18

Formi: 1. if (kifejezs ) utasts1; 2. if ( kifejezs ) utasts1; else utasts2; Kirtkeldik a kifejezs. Ha rtke nem nulla, utasts1 hajtdik vgre. Ha a kifejezs 0, akkor a 2. formnl az utasts2 hajtdik vgre, majd mindkt formnl a kvetkez utastssal folytatdik a program. utasts1 s utasts2 jabb feltteles utastsokat tartalmazhat. Az egymsba skatulyzs szablya: egy else mindig az utoljra tallt else nlkli if-hez kapcsoldik! Specilis esete az albbi if (kif1) ut1 else if (kif2) ut2 else if (kif3) ut3 . . . else utn; felttellnc, amelyben a felttelek sorban rtkeldnek ki az els nem nulla eredmnyig. Csak az ehhez a felttelhez tartoz utasts hajtdik vgre. 10.4 A while utasts Formja: while ( kifejezs ) utasts; Az utasts mindaddig ismtldik, mg kifejezs rtke nem nulla. A kifejezs kirtkelse az utasts vgrehajtsa eltt tr tnik. 10.5 A do utasts Formja: do utasts while ( kifejezs );

19

Hasonlan mkdik, mint a while, de a vizsglat az utasts vgrehajtsa utn trtnik.

20

10.6 A for utasts Formja: for ( k1; k2; k3) utasts; Egyenrtk az albbi progr amrszlettel: k1; while (k2) { utasts; k3; } Ha k2 hinyzik, helyre 1 rdik. Ha k1 vagy k3 elmarad, a fenti kifejtsbl is elmarad. 10.7 A switch utasts Formja: switch (kif) { case (ak1): u1; case (ak2): u2; case (akn): un; default: un+1; };

<-- ez nem ktelez!

ahol kif egy int rtket ad kifejezs kell legyen, ak1, ak2 stb. lland kifejezsek, u1, u2 stb. pedig utastsok. Mkds: 1. kirtkeldik a kif 2. a program azon els case szerkezet utni utastssal folytatdik, amelyben szerepl lland kifejezs rtke egyenl kif rtkvel. 3. ha a fenti felttel egy esetben sem teljesl, a default utni utastssal folytatdik (ha van ilyen cmke). 4. minden egyb esetben a switch utastst kvet utastssal folytatdik a program.

21

10.8 A break utasts Formja: break; Hatsra befejezdik a break-et krlvev legbels while, for, do vagy switch utasts vgrehajtsa, s a vezrls taddik a kvetkez utastsra. 10.9 A continue utasts Formja: continue; Hatsra a vezrls a krlvev legbels while, do vagy for utasts ciklusvgre addik t. 10.10 A return utasts Formja: return; A fggvny vgrehajtsa befejezdik, s a hv fggvnyhez tr vissza a vezrls. A fggvny rtke definilatlan. return kifejezs; Visszatrs a hv fggvnyhez, a fggvny rtke a kifejezs lesz. (Tpuskonverzival, ha szksges.) 10.11 A goto utasts Formja: goto azonost; A vezrls az azonost cmkj utastsra kerl. 10.12 A cmkzett utasts Brmelyik utastst megelzheti az azonosit: alak cmke, s gy goto utasts clpontja lehet.

22

10.13 Az res utasts Egy magban ll pontosvessz. Legtbbszr azrt hasznljuk, mert cmkje lehet, vagy mert a ciklustrzs res.

11. Egyszer input-output

A C nyelv nem tartalmaz input-output utastsokat, ezeket szabvnyos fggvnyekkel oldja meg. Az gynevezett standard input (ami alapesetben a billentyzet) s a standard output (alapesetben a kperny) kezelsre szolgl legegyszerbb fggvnyeket ismertetjk itt, hogy a pldaprogramokban az adatkezelst meg tudjuk oldani. Az albbi fggvnyeket hasznl forrsfile elejn a #include <stdio.h> sornak (aminek jelentst majd csak ksbb tudjuk megmagyarzni ) szerepelnie kell. 11.1. Karakter beolvassa a standard inputrl A standard inputrl egy karaktert olvas be a getchar() fggvny. Visszatrsi rtke a beolvasott karakter kdja, vagy az EOF elre definilt lland, ha elrtk a file vgt. Az EOF lland rtke gpfgg, s nem biztos, hogy "belefr" a char tpusba. 11.2. Egy karakter kirsa a standard outputra Erre szolgl a putchar(char c) fggvny, amely a paramtereknt megadott karaktert a standard outputra rja. 11.3. Formzott kirs a standard outputra A printf fggvnyt hasznlhatjuk erre a clra. Formja: printf ("formtum-specifikci",arg1,arg2, ...); A fggvny az arg1, arg2, ... argumentumok rtkt az els paramternek megfelel mdon konvertlja s kirja a standard outputra. A formtum-specifikci tartalmazhat: kznsges karaktereket ezeket vltoztats nlkl kinyomtatja. Escape szekvencikat is tartalmazhat. konverzi-specifikcikat ezek a soron kvetkez argu mentum nyomtatsi formtumt hatrozzk meg.

23

A legfontosabb formtum-specifikcik: %nd Egsz rtk kirsa n karakter szles helyre, balra igaztva %d Egsz rtk kirsa a szksges szlessgben %s Karakterlnc kirs vgig (a \0-t tartalmaz byte-ig) %ns Karakterlnc els n karakternek kirsa, ha kell, balra igaztva %n.mf Lebegpontos szm fixpontos kirsa n szlessgben, m tizedesjeggyel %n.me Lebegpontos szm kirsa lebegpontos formban, n szlessgben, a karakterisztikban m tizedesjegyet hasznlva A fggvny az argumentumok szmt az els paramterbl hatrozza meg. Ha ez az ltalunk megadott paramterek szmval nem egyezik meg, a program viselkedsi kiszmthatatlan! Hasonl problmt okozhat egy karaktertmb kirsa a %s formtummal, ha nem gondoskodtunk a zr 0 byte-rl. Egyszer pldk: printf ("Egy egy szveg\n"); int a; int i; float b; char c,ch[5]; a=1; b=2; c='A'; for (i=0; i<5; i++) ch[i] = 'a' + i; ch[5] = '\0'; printf ("a=%3d b=%5.1f c=%c ch=%s\n",a,b,c,ch);

12. Az els pldaprogramok

A C nyelv eddig megismert elemei segtsgvel rjunk meg nhny egyszer programot. 12.1. Pldaprogram rjunk programot, amely kirja a kisbetk kdjait! /* CPELDA1.C */ /* Ksztette: Ficsor Lajos */ /************************************************** A program kirja a kisbetk kdjait. ***************************************************/ 24

#include <stdio.h> void main(void) { char i; /* Fejlc rsa */ printf ("\n A kisbetuk kodjai:\n"); /* A ciklus vgigmegy a kisbetkn */ for (i='a'; i<='z'; i++) { printf ("Betu: %c Kodja: %d\n", i, i); } } A fenti kis program megmutatja, hogy ugyanazon vltoz klnbz konverzikkal is kirhat. Egyben szemllteti, hogy a char tpus valjban egszknt kezelhet. Fontos megjegyezni, hogy a program megrshoz nem kellett ismerni a kdtblt, csak azt kellett felttelezni rla, hogy a kisbetk folyamatosan, egyms utn helyezkednek el benne. Ez a legltalnosabban hasznlt ASCII kdtblra s az kezet nkli betkre igaz. 12.2 Pldaprogram rjunk programot, amely a standard bemenetrl beolvasott szveget csupa nagybetvel rja ki. /* CPELDA2.C */ /* Keszitette: Ficsor Lajos */ /***************************************************** A program a standard bemenetrl beolvasott szveg et nagybetsen rja ki ******************************************************/ #include <stdio.h> void main(void) { int c; /* int tpus, hogy az EOF is brzolhat legyen! */ while ( (c=getchar()) != EOF) /* Olvass file vgig */ { if (c >= 'a' && c<= 'z') /* Ha kisbett olvastunk be */ 25

{ c = c - ('a' - 'A'); } putchar(c); }

/* Konvertls nagybetre */ /* Karakter kirsa */

A fenti program azt ttelezi fel, hogy a kdtbla mind a kisbetket, mind a nagybetket folyamatosan trolja, s az azonos kisbet s nagybet kztti "tvolsg" (a kdjaik klnbsge) lland. Ez az ASCII kdtblra s az kezet nlkli betkre igaz. A while ( (c=getchar()) != EOF) { utastsok } szerkezet egy file karakter enknti beolvasst s feldolgozst vgz szoksos megolds.

13. A fggvny
A fggvny (mint minden programozsi nyelvben) utastsok egy csoportja, amelyek megadott paramtereken kpesek mveleteteket vgezni. A tipikus C nyelv program sok, viszonylag egyszer fggvny sszessge. 13.1. Fggvny definci Formja: tpus nv (formlis paramterlista) { loklis deklarcik utastsok } A formlis paramterlista tpus azonost vagy tpus tmbnv[] prok, vesszvel elvlasztva. Ha nincs param tere, a paramterlista helyre a void alapsz rand. A visszatrsi rtk tpusa brmely tpusnv lehet. Ha a fggvny nem ad vissza rtket, a visszatrsi rtk tpusa void. 13.2. Fggvny deklarci (prototpus)

26

A fggvnyt a hasznlata eltt deklarlni kell. A fggvny deklarci a fggvny definci fejvel egyezik, s pontosvessz zrja. Formja teht: tpus nv (formlis paramterlista); Megjegyzs A C nyelv a fentiektl enyhbb szablyokat r el, de a helyes programozsi stlus elsajttsa rdekben fogadjuk el ezt a szigorbb szablyozst. 13.3. A fggvny hvsa: nv (aktulis paramterlista) A fggvnyhvs llhat magban, pontosvesszvel lezrva, (ekkor a visszaadott rtk - ha volt - elvsz), vagy kifejezs rszeknt. Az aktulis paramterlista kifejezsek vesszvel elvlasztott listja. A zrjel pr kirsa akkor is ktelez, ha nincs paramterlista! A C nyelv csak az rtk szerinti paramtertadsi mechanizmust ismeri. Ez a kvetkez folyamatot jelenti: 1. kirtkeldik az aktulis paramter kifejezs 2. a kifejezs rtke a formlis paramter tpusra konvertldik a szoksos tpuskonverzi szablyai szerint 3. a formlis paramter megkapja kezdrtknek ezt az rtket 4. vgrehajtdnak a fggvny trzsben felsorolt utastsok. A fenti szablyok rtelmben a formlis paramterek a fggvnyre nzve loklis vltozknak tekinthetk (a fogalom pontos magyarzatt csak ksbb tudjuk megadni), amelyek az aktulis paramter kifejezs rtkvel inicializldnak. A formlis paramterek a fggvnyen bell kaphatnak ms rtket is, de ennek az aktulis paramterre semmi hatsa nincs.

13.4. Pldaprogram: faktorilis szmtsa Bevezet pldaknt rjunk egy fggvnyt, amely a faktorilis rtkt szmtja ki. rjunk egy teljes programot, amely ezt a fggvnyt hasznlja. /* CPELDA3.C */ /* Ksztette: Ficsor Lajos */ /***************************************************** Fggvny n! szmtshoz. Prbaprogram a fggvnyhez. ******************************************************/ #include <stdio.h> long faktor (int n); void main(void) { /* Ez a fggvny deklarcija */ /* Fprogram */

27

int n; n= 10; /* az albbi sor tartalmazza a fgv hvst */ printf ("\n%d faktorialisa: %ld",n, faktor(n)); } long faktor (int n) /* Fggvny definci fejrsze */ /**************************************************** A fggvny n! rtket szmtja. Nem rekurzv. ****************************************************/ { long fakt; int i; /* loklis deklarcik */ for (fakt=1, i=2; i<=n; i++) fakt *= i; return fakt; } rdemes megnzni a ciklusutasts megoldst: fakt=1, i=2; i<=n; i++; fakt *= i; Kezdrtk belltsa. A vessz opertor teszi lehetv egynl tbb kifejezs rst. A ciklus lelltsnak a felttele. Lptets. Ebben az esetben a ++i is ugyanazt a hatst rte volna el. A ciklus magja. sszetett rtkad opertort hasznl a fakt = fakt*i kifejezs egyszerstsre.

Megjegyezzk mg, hogy ezt a ciklusutastst a gyakorlottabb C programoz az albbi tmrebb formban rta volna fel: for (fakt=1, i=2; i<=n; fakt *= i++); Ebben az alakban kihasznltuk a lptet opertor azon tulajdonsgt, hogy elbb az i rtke felhasznldik a kifejezs kiszmtsnl, majd utna nveldik eggyel az rtke. A ciklusvltoz lptetse teht most egy mveletvgz utasts mellkhatsaknt trtnik meg. Ez az egyetlen kifejezs teht egyenrtk az albbi utastsokkal: fakt = fakt *i; i = i+1; Ezzel a megoldssal minden feladatot a ciklusutasts vezrl rszre bztunk, gy a ciklustrzs res: ezt jelzi az utasts utn kzvetlenl rt pontosvessz.

28

13.5. Pldaprogram: egy sor beolvassa A fggvnyrs gyakorlsra rjunk egy kvetkez fggvnyt, amely beolvas egy sort a standard inputrl, s azt egy stringknt adja vissza. Ehhez a kvetkezket rdemes vgiggondolni: Egy sor vgt a \n (sorvg) karakter jelzi. A string (karaktersorozat) trolsra a char tpus tmb a legalkalmasabb. rdemes betartani azt a C nyelvi konvencit, hogy a string vgt egy 0 tartalm byte jelzi, mert ekkor azt a szoksos mdon kezelhetjk (pl %s konverzival kirathatjuk, hasznlhatjuk r a szabvnyos string kezel fggvnyeket). Mindezek figyelembevtelvel a fggvny s azt azt hasznl fprogram pldul az albbi lehet:

29

/* CPELDA4.C */ /* Ksztette: Ficsor Lajos */ /***************************************************** Egy sor beolvassa fggvnnyel. Prbaprogram a fggvnyhez. ******************************************************/ #include <stdio.h> #define MAX 100 int getstr (char s[]); void main(void) { int n; char szoveg[MAX+1]; printf ("\nEgy sor beolvasasa a standard inputrol\n\n"); n = getstr(szoveg); printf ("%s\n",szoveg); printf ("A szoveg hossza: %d\n",n); } int getstr (char s[]) /**************************************************** A fggvny egy sort olvas be a standard inputrl, es az s tmbbe helyezi el, string-knt. Visszatrsi rtke a beolvasott karakterek szma, vagy EOF ****************************************************/ { int c; int i; i=0; while ( (c=getchar()) != '\n' && c !=EOF) { s[i++] = c; } s[i] = '\0';/* Zr 0 elhelyezse */ return c==EOF ? c : i; } Megjegyzsek a programszveghez:

30

1. A #define MAX 100 sor szimbolikus konstanst definil. A j programozsi stlushoz tartozik, hogy a konstansoknak olyan nevet adjunk, amely a jelentsre utal. gy olvashatbb tesszk a szveget, s egy esetleges vltoztatshoz csak egyetlen helyen kell mdostani a programot. Az itt alkalmazott szerkezet gynevezett makr definci. Ezt egy elfeldolgoz program (precompiler) a tnyleges fordtprogram eltt feldolgozza gy, hogy a programszveget vgignzve minden MAX karaktersorozatot az 100 karaktersorozattal helyettest. A fordtprogram teht a char szoveg[100+1]; sort kapja meg. 2. A szoveg karaktertmb defincija azt jelenti, hogy maximum 100 karakter hosszsg string trolsra alkalmas, ekkor a string vgt jelz 0 byte a 101. elembe kerl. Ne felejtsk azonban el, hogy a C az indexelst 0-tl kezdi. A 101 elem tmb leglis indexei teht 0-tl 100-ig terjednek, gy az els karakter a "nulladik" tmbelem. Gyakori hibaforrs C programokban ennek a figyelmen kvl hagysa. 3. Mivel a beolvas fggvny nem figyeli a beolvasott karakterek szmt, a fenti kis program hibsan mkdik, ha 100-nl tbb karakterbl ll sort kap. Ilyenkor a tmb nem ltez elemeibe r, amely elre nem meghatrozhat (s akr futsonknt ms s ms) hibajelensget idzhet el! 4. Az utols sor lehet, hogy nem sorvgjellel vgzdik, hanem a file vge (EOF) jellel. Ebben az esetben a fggvny nem jl dolgozik: EOF-et ad vissza a fggvnyrtkben, br a paramtere tartalmazza a beolvasott stringet. 5. A while ( (c=getchar()) != '\n' && c !=EOF) sor "magyar fordtsa": olvasd be a kvetkez karaktert, s mindaddig, amg az nem sor vge, s nem file vge, ismteld az a lbbi utastsokat! 6. A return utastsban alkalmazott feltteles kifejezssel az albbi programrszletet tudtuk helyettesteni: if (c==EOF) return EOF else return i; 7. A ciklus a for utastssal is megfogalmazhat: for( i=0; (c=gethar()) != '\n' && c !=EOF); s[i++] = c) Br ez sokkal tmrebb, emiatt nehezebben is olvashat, ezrt taln szerencssebb az eredeti megolds. Idegen programok olvassnl azonban szmthatunk ilyen jelleg rszletekre is.

14. Mutatk

31

A mutat (pointer) olyan vltoz, amely egy msik objektum cmt tartalmazza. (Ezrt bels brzolsi mdja ersen gpfgg!) A mutat rtket kaphat az & opertorral, a mutat ltal megcmzett trrsz pedig a * opertorral. gy teht a px = &x; utasts, ha px mutat, ahhoz az x vltoz cmt rendeli. Ha ezutn az y = *px; utastst rjuk, a kt utasts egyttes hatsa azonos az y=x; rtkadssal.

14.1 Mutatk deklarcija A mutatk deklarcijnak tartalmaznia kell, hogy milyen tpus objektumra mutat. Formlisan: tpus *azonost; Pldul: int *px; A *mutat konstrukci balrtk, teht szerepelhet rtkad utasts baloldaln. Pldul a *px=0 a px ltal megcmzett egsz rtket 0-ra lltja be, a (*px)++ pedig inkrementltja. Megjegyzs A *px++ nem azonos a fentivel mivel az egyoperandus opertorok jobbrl balra csoportostanak, gy ennek zrjelezse a *(px++) lenne, ami azt jelenti, hogy a px inkrementldik (ennek pontos jelentst lsd a kvetkez alpontban), majd az gy keletkezett cmen lev rtkre hivatkozunk.

14.2 Cmaritmetika Mivel a mutat is vltoz, gy rtket kaphat, s mveletek vgezhetk rajta. A mveletek defincija figyelembe veszi azt a tnyt, hogy a mutat cmet trol, az eredmnyt pedig befolysolja az, hogy a mutat milyen tpusra mutat. Az albbi mveletek megeng edettek: mutat s egsz sszeadsa, kivonsa mutat inkrementlsa, dekrementlsa kt mutat kivonsa mutatk sszehasonltsa mutatnak "0" rtk adsa 32

mutat sszehasonltsa 0-val mutat indexelse

A felsorolt mveleteken kvl minden ms mvelet tilos. Az egyes mveletek defincija:

A mutat s egsz kztti mvelet eredmnye jabb cm, amely ugyanolyan tpus objektumra mutat. Pldul tipus *p int n; esetn a p+n egy olyan cm, amelyet gy kapunk, hogy a p rtkhez hozzadunk egy n * sizeof (tpus) mrtk eltolst. Ezltal az eredmny az adott gp cmzsi rendszerben egy jabb cm, amely ugyanolyan tpus, de n elemmel odbb elhelyezked objektumra (pldul egy tmb n-el nagyobb index elemre) mutat. gy pldul, ha int *px,n akkor a px+n kifejezs eredmnye mutat, amely a px ltal megcmzett egsz utni n. egszre mutat. Hasonlan rtelmezhetk a p-n p++ p-- kifejezsek is.

Kt azonos tpus mutat kivonsa mindig engedlyezett, de ltalban csak azonos tmb elemeire mutat pointerek esetn van rtelme. Eredmnye int tpus, s a kt cm kztt elhelyezked, adott tpus elemek szmt adja meg. Az azonos tpus p1 s p2 mutatkra a p1 < p2 relci akkor igaz, ha p1 kisebb cmre mutat (az adott gp cmzsi rendszerben), mint p2. Ez abban az esetben, ha mindkt mutat ugyanazon tmb elemeit cmzi meg, azt mutatja, hogy a p1 ltal cmzett elem sorszma kisebb, mint a p2 ltal cmzett. Ms esetben ltalban az eredmny gpfgg, s nem rtelmezhet. A tbbi relci rtelemszeren hasonlan mkdik. A 0 rtk mutat specilis jelents: nem mutat semmilyen objektumra. Ezzel lehet jelezni, hogy a mutat mg belltatlan. Ezrt engedlyezett a 0-val val sszehasonlts is. A mutat indexelsrl bvebben a mutatk s tmbk sszefggsnek trgyalsnl beszlnk.

33

14.3 Mutatk s tmbk A C- ben a tmbk elemei indexelssel s mutatkkal egyarnt elrhetk. Ennek alapja az, hogy egy tmb azonostjt a fordt mindig a tmb els elemt megcmz mutatknt kezeli. Ennek kvetkezmnyeit szemllteti a kvetkez sszellts: Legyen a deklarcis rszben az albbi sor: int *pa,a[10],i; s ttelezzk fel, hogy vgrehajtdott a pa = &a[0]; utasts. Ekkor rtelmesek az albbi kifejezsek, s a megadott jelentssel rendelkeznek. Kifejezs pa=&a[0] a[i] &a[i] Vele egyenrtk pa = a *(pa+i) *(a+i) pa[i] pa+i a+i Jelents A pa mutat az a tmb els elemre mutat Hivatkozs az a tmb i index elemre Az a tmb i index elemnek cme Megjegyzs Br a tmb azonostja a fordtprogram szmra mutatknt viselkedik, mgsem vltoz, ebbl kvetkezik, hogy nem balrtk, gy az a=pa pa++ p=&a

jelleg kifejezsek tilosak!

14.4 Karakterlncok s mutatk A fordtprogram a karakterlnc-llandt (stringet) karakter tpus tmbknt kezeli, s megengedi, hogy egy karaktertmbt karakterlnccal inicializljunk. A karakterlnc vgre a zr 0 byte is odakerl. Ugyanezen okbl megengedett egy char* mutat s egy string kztti rtkads, hiszen ez a fordt szmra kt mutat kztti rtkadst jelent. Pldul: char *string; 34

string="Ez egy szoveg" hasznlhat, s ez utn *string egyenl 'E' -vel, *(string+3) vagy string[3] egyenl 'e'-vel *(string+14) egyenl '\0'-val, *(string+20) pedig hatrozatlan.

35

14.5 Mutat-tmbk, mutatkat cmz mutatk Mivel a mutat is vltoz, gy tmbkbe foglalhat, cmezheti mutat. A char *sor[100]; deklarci egy 100 darab char tpus mutat trolsra alkalmaz tmbt definil. A sor [1] pldul a sorban a msodik mutat. Mivel a tmb azonostja is mutat, gy a sor is az, de egy mutatt (a sor[0]-t) cmez meg, azaz tpusa char**. gy sor[1] azonos a sor+1- el, s ha px char tpus mutat, akkor a px=sor[1] px=sor+1 kifejezsek rtelmesek.

14.6 Tbbdimenzis tmbk s mutatk A ktdimenzis tmb gy foghat fel, mint egy egydimenzis tmb, amelynek minden eleme tmb. (Ennek kvetkezmnye az, hogy a C programban hasznlt tmbk elemei sorfolytonosan troldnak a memriban.) A tmbazonost pedig mutat, gy pldul int a[10][10] int *b[10] esetn a[5][5] s b[5][5] egyarnt rhat, mindkt kifejezs egy- egy egsz rtket ad vissza. Azonban az a[10][10] 100 egsz szm trolsra szksges helyet foglal el, a b[10] csak 10 cm szmra szksgeset, s a b[5][5] felhasznlsa csak akkor rtelmes, ha a b[5] elemeit elzleg valahogyan belltottuk. A fentiek illusztrlsra nzznk egy pldt. Legyen a deklarciban char s[5][10]; char *st[5]; Ekkor rhat s[0]= "Els"; s[1]= "Msodik"; s[2]= "Harmadik"; s[3]= "Negyedik"; s[4]= "tdik";

36

Ebben az esetben az s tmb 50 byte-nyi helyet foglal le, s minden string hossza korltozott 10- re. Az s[1][5] a fenti utastsok utn az i bett jelenti. Mivel a deklarciban az char *st[5]; is szerepel, rhat st[0] = "Els"; st[1] = "Msodik"; st[2] = "Harmadik"; st[3] = "Negyedik"; st[4]="tdik" Ebben az esetben az st[5] 5 cmnek szksges helyet foglal el, amihez mg hozzaddik a karaktersorozatok trolsra szksges hely (de csak a felttlenl szksges), radsul tetszleges hosszsg stringek trolhatk. A z st[1][5] a fenti utastsok utn is az i bett jelenti.

14.7. Mutat, mint fggvny argumentum Ha egy fggvny argumentuma tmb, ebben az esetben - mint a legtbb sszefggsben - a tmbazonost mutatknt viselkedik, azaz a fggvny a tmb els elemnek cmt kapja meg. Ez azt is jelenti, hogy a deklarciban mind a tmb-szer, mind a mutat tpus deklarci alkalmazhat, s a deklarci formjtl fggetlenl a tmbelemekre mutatkon keresztl vagy indexelssel is hivatkozhatunk. Ennek megfelele n az albbi formlis paramter-deklarcik egyenrtkek: int a[] int b[][5] int *a int (*b)[5]

Fggvny argumentuma lehet egy vltoz mutatja. gy indirekt hivatkozssal megvltoztathat a fggvny argumentumnak rtke. Pldaknt egy fggvny, amely megcserli kt argumentumnak rtkt: void csere (int* x,int* y) { int a; a = *x; *x = *y; *y = a; } A fggvny hvsa: main() { int a,b; . 37

. csere (&a,&b); . . }

14.8 Fggvnyeket megcmz mutatk Br a fggvny nem vltoz, de van cme a memriban, gy definilhat fggvnyt megcmz mutat. Ezltal lehet fggvny ms fggvny paramtere, st ilyen mutat fggvnyrtk is lehet. (Az ennek megfelel deklarcikra pldkat a ksbbiekben, a deklarcikkal kapcsolatban adunk.)

14.9. Pldaprogram: string msolsa Az albbi pldaprogram egy string-msol fggvny (a standard strcpy fggvny megfelelje) hrom lehetsges megoldst mutatja. A C nyelv lehetsgeit kihasznlva egyre tmrebb programszveget kaphatunk. /* CPELDA5.C */ /* Ksztette: Ficsor Lajos */ /***************************************************** Plda string msols klnbz vltozataira ******************************************************/ #include <stdio.h> void strmasol1 (char* cel, char* forras); void strmasol2 (char* cel, char* forras); void strmasol (char* cel, char* forras); void main(void) { char szoveg[50]; printf ("\n String masolas\n\n"); strmasol1(szoveg,"Ficsor Lajos"); printf("Elso verzio: %s\n",szoveg); strmasol2(szoveg,"Ficsor Lajos"); printf("Masodik verzio: %s\n",szoveg); strmasol(szoveg,"Ficsor Lajos"); printf("Legtomorebb verzio: %s\n",szoveg);

38

39

void strmasol1 (char* cel, char* forras) { /******************************************** Tmb jelleg hivatkozs, teljes felttel ********************************************/ int i; i=0; while ( (cel[i] = forras[i]) != '\0') i++; } void strmasol2 (char* cel, char* forras) { /******************************************** Tmb jelleg hivatkozs, kihasznlva, hogy az rtkads rteke a forrs karakter kdja, ami nem nulla. A msols lelltsnak felttele a 0 kd karakter tmsolsa. (0 => "hamis" logikai rtk!) ********************************************/ int i; i=0; while ( cel[i] = forras[i] ) i++; /* A BORLAND C++ reakcija a fenti sorra: Warning: Possibly incorrect assigment Figyelem: lehet, hogy hibs rtkads. Magyarzat: felhvja a figyelmet arra a gyakori hibra, hogy = operatort runk == helyett. Itt termszetesen a sor hibtlan! */ } void strmasol (char* cel, char* forras) { /******************************************** Pointer jelleg hivatkozas, kihasznlva, hogy a paramrttads rtk szerinti, teht a formlis paramterek segdvltozknt hasznlhatk. ********************************************/ while ( *cel++ = *forras++ ); /* A BORLAND C++ reakcija a fenti sorra ugyanaz, mint az elz verzinl. A sor

40

termszetesen ebben a fggvnyben is hibtlan! */ }

41

14.10 Pldaprogram: llaptsuk meg egy stringrl , hogy numerikus-e Ksztsnk egy fggvnyt, amely a paramterknt kapott string-rl megllaptja, hogy csak helykz s szmjegy karaktereket tartalmaz-e. rjunk main fggvnyt a kiprblshoz. A string beolvassra hasznljuk a CPELDA4.C-ben megrt getstr fggvnyt! /* CHF1.C */ /* Ksztette: Ficsor Lajos */ /********************************************************** A feladat olyan fggveny rsa, amely egy stringrl megllaptja, hogy csak helykz s szmjegy karaktereket tartalmaz-e. Egy sor beolvassa a getstr fggvnnyel trtnik. Prbaprogram a fggvnyhez. **********************************************************/ #include <stdio.h> #define MAX 100 #define IGAZ 1 #define HAMIS 0 int getstr (char s[]); int szame1(char* s); int szame(char* s); void main(void) { int n; char szoveg[MAX+1]; printf ("\nEgy sorol megallapitja, hogy csak\n"); printf ("helykozt es szamjegyet tartalmaz-e\n"); printf ("Elso verzio:\n"); getstr(szoveg); if ( szame1(szoveg) ) printf("\nNumerikus!\n"); else printf("\nNem numerikus!\n"); printf ("Masodik verzio:\n"); getstr(szoveg); if ( szame(szoveg) )

42

printf("\nNumerikus!\n"); else printf("\nNem numerikus!\n"); } int getstr (char* s) /**************************************************** A fuggveny egy sort olvas be a standard inputrol, es az s tombbe helyezi el, string-kent. Visszateresi erteke a beolvasott karakterek szama, vagy EOF ****************************************************/ { int c; int i; i=0; while ( (c=getchar()) != '\n' && c !=EOF) { s[i++] = c; } s[i] = '\0'; return c==EOF ? c : i; } int szame1(char* s) /************************************************************* A fggvny IGAZ (1) rtkkel tr vissza, ha a paramter string csak helykz vagy szmjegy karaktereket tartalmaz, HAMIS (0) rtekkel egybknt. Az res sztringre IGAZ rtket ad. Tmb stlus hivatkozsokat hasznl. *************************************************************/ { int szamjegy_e; int i; char c; szamjegy_e = IGAZ; i =0; while ( c=s[i++] ) {

/* Kihasznlja, hogy a zr 0 lelltja*/ /* a ciklust. Az i++ kifejezs lpteti */ /* a ciklusvltozt. */ if ( !(c==' ' || c>='0' && c<='9') ) { szamjegy_e = HAMIS; break;

43

} } return szamjegy_e; }

44

int szame(char* s) /************************************************************* A fggvny IGAZ (1) rtkkel tr vissza, ha a paramter string csak helykz vagy szmjegy karaktereket tartalmaz, HAMIS (0) rtekkel egybknt. Az res sztringre IGAZ rtket ad. Pointer stlus hivatkozsokat hasznl. Nem hasznl break utastst. *************************************************************/ { int szamjegy_e; char c; szamjegy_e = IGAZ; while ( (c=*s++) && szamjegy_e) { if ( !(c==' ' || c>='0' && c<='9') ) szamjegy_e = HAMIS; } return szamjegy_e; }

14.11 Pldaprogram: string konvertlsa egsz szmm rjunk fggvnyt, amely egy csak helykzt s szmjegyeket tarta lmaz string-bl kiolvas egy egsz szmot. (Szm hatrol karakter a helykz vagy a string vge). Visszatrsi rtk a szm, s paramterben adja vissza a feldolgozott karakterek szmt is. A fenti fggvny segtsgvel olvassuk be egy stringben lev valam ennyi szmot. /* CPELDA6.C */ /* Ksztette: Ficsor Lajos */ /********************************************************** Egy csak helykzt s szmjegyeket tartalmaz stringbl egsz szmokat olvas be. Szm hatrol jel: helykz. ***********************************************************/ #include <stdio.h> int aboli (char* s, int* hossz); int getstr (char* s); void main(void) { char szoveg[100]; int sorhossz,kezdes,sorszam,szam,hossz; sorhossz = getstr(szoveg);

45

kezdes = 0; sorszam = 0;

46

while ( kezdes < sorhossz) /* Mindaddig, amg a string */ /* vgre nem rnk */ { /* A soron kvetkez szm beolvassa */ szam = aboli(szoveg+kezdes, &hossz); printf ("A(z) %d. szam: %d, hossza: %d\n", ++sorszam, szam,hossz); /* A kvetkez szm kezdetnek belltsa */ kezdes += hossz; } } int aboli(char* s, int* hossz) /*********************************************************** Az s stringbl egsz szmokat olvas be. Hatrol jel: legalbb egy helykz vagy a string vge.. A string elejn ll helykzket tugorja. Visszatrsi rtk a beolvasott szm, a msodik paramterben pedig a feldolgozott karakterek hossza. (tpusa ezrt int*!) ***********************************************************/ { int i; int szam; i=0; szam = 0; /* Vezet helykzk tugrsa /* while ( s[i] == ' ') i++; /* Szm sszelltsa */ while ( s[i] != ' ' && s[i] != '\0' ) { szam = 10*szam + s[i++] - '0'; } *hossz = i; /* Mutatn keresztli indirekt hivatkozs */ return szam; } int getstr (char* s) /**************************************************** A fuggveny egy sort olvas be a standard inputrol, es az s tombbe helyezi el, string-kent. Visszateresi erteke a beolvasott karakterek szama, vagy EOF ****************************************************/ { int c; int i; i=0;

47

while ( (c=getchar()) != '\n' && c !=EOF) { s[i++] = c; } s[i] = '\0'; return c==EOF ? c : i; } Megjegyzsek: 1. Az aboli fggvny els formlis paramtere azrt char*, mert egy karaktertmbt (stringet) kell tvenni. A msodik paramter viszont azrt int*, mert ennek a paramternek a segtsgvel egy rtkt akarunk visszaadni a fggvnybl. 2. A fggvny hvs sorn kihasznltuk azt, hogy egy stringet feldolgoz fggvnynek nem csak egy karaktertmb kezdcmt adhatjuk meg, hanem tetszleges elemnek a cmt is. gy intzhettk el, hogy a beolvasott stringnek mindig a mg feldolgozatlan rszvel folytassa a fggvny a szm keresst. 3. A msodik (mutat tpus) formlis paramter helyre aktulis paramterknt a hossz vltoz cmt rtuk be, gy a fggvny ezen a cmen keresztl a vltoz rtkt vltoztatja meg.

15 Objektumok deklarcija
A deklarci hatrozza meg, hogy a C fordt hogyan rtelmezze az azonostkat (azaz milyen objektumok jellsre hasznlatosak.) A jegyzetben mr tbb helyen volt sz deklarcikrl. Ebben a pontban sszefoglaljuk a szksges ismereteket.

15.1 Definici s deklarci A definici meghatrozza valamely objektum tpust, mrett, s hatsra helyfoglals trtnik. A definci egyben deklarci is. A deklarci valamely objektumnak a tpusa, mrete (azaz alapvet tulajdonsgainak) jelzsre szolgl. Pldul: char matrix [10][20] definci char matrix [][20] deklarci A teljes programot tekintve minden objektumot pontosan egyszer kell definilni (hacsak nem akarjuk jra definilni), de lehet, hogy tbbszr kell deklarlni. 15.2 A deklarci formja

48

[trolsi_osztly] [tpusnv] deklartor_specifiktor A szgletes zrjelek azt jelzik, hogy a trolsi osztly s a tpusnv kzl az egyik elmaradhat, ilyenkor a megfelel alaprtelmezs lp letbe. 15.2.1 A tpusnv A deklarciban a tpusnv lehet:

az alaptpusok ismertetsnl felsoroltak valamelyike struktra- s uni defincik vagy cmkk (nevek) typdef- el definilt tpusnevek

15.2.2 A deklartor specifiktor A deklartor specifiktor az albbiak valamelyike lehet: Formja azonost azonost [lland kifejezs] azonost [ ] azonost ( ) a fentiek, elttk *- al (* azonost ) () A fentiek az albbi korltozsokkal rvnyesek: 1. Tmb csak az albbiakbl kpezhet: 2. alaptpusok mutatk struktrk unik tmbk Fggvnyrtk nem lehet:

Jelentse alaptpus tmb tmb fggvny fenti objektumok mutati fggvny-mutat

tmb uni fggvny

de lehet a fentiek brmelyikt megcmz mutat!

49

Mindezek megrtsnek megknnytsre nzzk az albbi pldkat: int int int int int int int t[] *t[] f() *f() (*f)() *(f()) (*f())[] egszeket tartalmaz tmb egszeket megcmz mutatkat tartalmaz tmb egszt visszaad fggvny egszt megcmz mutatt visszaad fggvny egszt visszaad fggvnyt megcmz mutat olyan tmb, amelyeknek elemei fenti tpus fggvny-mutatk

15.2.3 Trolsi osztlyok A definilt objektum rvnyessgi krt s lettartamt (vagy trolsi mdjt) hatrozza meg. A kvetkez trolsi osztlyok lteznek: auto regiszter Loklis vltoz ("automatikus vltoz") egy fggvnyre vagy egy blokkra nzve. rtke a fggvnybe (blokkba) val belpskor hatrozatlan, a kilpskor megsznik. Olyan auto vltoz, amelyet gyakran kvnunk hasznlni. Utasts a fordtprogramnak, hogy "knnyen elrhet" mdon (pldul regiszterekben) trolja az rtkket. Mivel ez a md gpfgg lehet, nem alkalmazhat rjuk az & opertor, hiszen lehet, hogy nincs is valdi rtelemben vett cmk. ltalnos rvny vltoz, a program klnbz r szeiben is rvnyes. rtke megmarad, nem jn ltre s sznik meg a fggvnyhvssal. (Lehet bels vagy kls.) rvnyessgi kre korltozott.

extern static

15.3 Kls s bels vltozk Kls definci az, amely minden fggvnyen kvl helyezkedik el. A fggvnydefinci mindig kls. A C program kls defincik sorozata. A kls definciban az extern s static trolsi osztly hasznlhat. Az alaprtelmezs az extern trolsi osztly. Az egyes fggvnyekben extern deklarcival jelezni lehet a kls vltozkat. Ez azonban csak akkor ktelez, ha a deklarci egy forrsszvegben megelzi a defincit, vagy a definci ms forrsllomnyban van, mint a fggvny. A gyakorlottabb programozk ltal hasznlt konvenci: valamennyi kls defincit helyezzk el a forrs-file elejn, s ne hasznljunk extern deklarcit a fggvnyeken bell.

50

Bels definci az, amely fggvnyeken vagy blokkon bell helyezkedik el. Trolsi osztlya lehet auto (felttelezett), register vagy static.

15.4 Az rvnyessgi tartomny szablyai Egy C program tbb forrs-file-bl llhat, s knyvtrakban elre lefordtott rutinokra is hivatkozhat. Ezrt szksges tisztzni az azonostk rvnyessgi tartomnyt. Ktfle rvnyessgi tartomnyrl beszlhetnk:

lexiklis rvnyessgi tartomny a kls vltozk rvnyessgi tartomnya

15.4.1 Lexiklis rvnyessgi tartomny A programnak az a rsze, amelyben "definilatlan azonost" hibajelzs nlkl hasznlhatjuk az azonostt. Rszletesebben: 1. Kls defincik : a defincitl az ket tartalmaz forrsllomny vgig. 2. Formlis paramter: az a fggvny, amelynek fejben szerepel. 3. Bels definci: az a fggvny vagy blokk, amelyben szerepel. 4. Cmke: az a fggvny, amelyben elfordul. (Nincs "kls" cmke!) Megjegyzs Ha egy azonostt egy blokk vagy fggvny fejben explicit mdon deklarlunk, akkor annak vgig az adott azonost sszes blokkon kvli deklarcija felfggesztdik (jradefinils). 15.4.2 A kls azonostk rvnyessgi tartomnya A program egszre nzve tisztzza, hogy ugyanarra az azonostra vonatkoz hivatkozs ugyanazt az objektumot jelenti-e. Egy extern-knt deklarlt vltoznak a teljes programot alkot forrsllomnyok s knyvtrak valamelyikben pontosan egyszer definiltnak kell lennie. Minden r hivatkoz fggvnyt tartalmaz llomnyban (esetleg magban a fggvnyben - br ez nem szoksos) szerepelnie kell az azonost deklarcijnak. gy ezzel az azonostval minden fggvny ugyanarra az objektumra hivatkozik. A deklarciknak ezrt kompatibiliseknek kell lennik. (Tpus s mret szempontjbl.) A legfels szinten static-knt deklarlt azonost csak az adott llomnyra rvnyes, a tbbi llomnyban szerepl fggvnyek nem ismerik. Fggvny is deklarlhat static-knt.

51

52

15.5 Implicit deklarcik Ebben a pontban ismertetjk azokat az alaprtelmezseket, amelyek a deklarcikkal kapcsolatosak. A trolsi osztly alaprtelmezse: kls defincikban: extern fggvnyen bell: auto Tpus alaprtelmezse: int. Nem hinyozhat egyszerre a trolsi osztly s a tpus. Kifejezsekben azt a nem deklarlt azonostt, amelyet "(" kvet, a fordt int- et visszaad fgvnynek rtelmezi. ( Ezrt ilyeneknek a deklarcija elhagyhat - br a helyes programozsi stlus megkveteli a fggvnyek deklarlst, azaz a prototpusok alkalmazst.)

15.6 Az inicializls A deklarciban (bizonyos korltozsokkal) az objektumoknak kezdrtk adhat. Inicializls nlkl:

a kls s a statikus vltozk rtke garantltan 0 az automatikus s regisztervltozk rtke hatrozatlan.

Egyszer vltoz inicializlsa: tr_o tpus azonost = kif sszetett objektum inicializlsa: deklarci = { kif, kif,....,} A kifejezsek az elemek sorrendjben addnak t. Ha szmuk kevesebb, mint amit a deklarci meghatroz a maradk elemek 0-val tltdnek fel. Ha tbb, hibajelzst kapunk. Tmbk esetn a deklarcibl az els index fels hatra elmaradhat, ezt ekkor a kifejezsek szma hatrozza meg. 15.6.1 Kls s statikus vltozk inicializlsa Az inicializls egyszer, fordtsi idben, a helyfoglalssal egytt trtnik. A kifejezs lehet lland kifejezs mint az lland kifejezs, de szerepelhet operandusknt mr deklarlt vltoz cme (+ eltols) is. 53

15.6.2 Automatikus s regiszter vltozk inicializlsa Minden alkalommal vgrehajtdik, amikor a vezrls belp a blokkba. A kifejezs tetszleges, korbban definilt rtket tartalmazhat. (Vltozkat, fggvnyhvsokat stb.) Valjban rvidtett formban rt rtkads. Pldk: int t[] = {0,1,2,13,26,45} int m[5][3] = {1,3,5,2,4,6,7,9,11,8,10,12,13,15,17}

15.6.3 Karaktertmb inicializlsa Karaktertmb inicializlsra hasznlhat karakterlnc is, ezzel egyszersthet a kezdrtkads. Plda: char s[] = "szoveg"; ami egyenrtk a "szablyos" char s[] = {'s','z','o','v','e','g','\0'}; formval.

16. Fomattlt beolvass

A standard inputrl formattlt beolvasst vgez a scanf fggvny. Formja: scanf("Konverzis karakterek", p1, p2, ...) A fggvny a konverzis karakterek ltal megadott mdon adatokat olvas be, majd azok konvertlssal kapott rtkt sorban a paramterekhez rendeli. A p1, p2, ... paramtereknek mutatknak kell lennik. A pontos mkdse meglehetsen bonyolult, itt csak egy egyszerstett lerst adjuk meg. A fggvny adatok s reshely karakterek (helykz, tabultor, j sor, kocsi vissza, soremels, fggleges tabultor s lapemels) vltakozsaknt tekinti a bemenetet. Az reshely-karaktereket tlpi, a kztk lev karaktereket pedig konvertlja s az gy kapott rtket az aktulis paramter ltal megcmzett vltozban trolja.

54

A konverzis karakterek az albbiak lehetnek (a felsorols nem teljes!): Konverzi %d %f %lf %c %s Az argumentum tpusa int* float* double* char* char* A beolvasott adat Egsz szm Vals szm Vals szm Egy karakter Karaktersorozat (a zr 0-t elhelyezi)

gyeljnk a hasznlat sorn arra, hogy a konverzis karakterek kztt ms karakterek ne legyenek (mg helykzk sem), mert azoknak is van jelentsk, amelyet itt most nem rszleteznk.

16.1. Pldaprogam: egy vals tmb elemeinek beolvassa s rendezse A feladat egy vals tmb elemszmnak s elemeinek beolvassa s a tmb rendezse a kivlasztsos s a bubork rendezs segtsgvel. /* CPELDA7.C */ /* Ksztette: Ficsor Lajos */ /* A program beolvas egy double tmbt s rendezi ktfle mdszerrel */ #include <stdio.h> #define MAXELEM 100 void rendez_cseres(double* tomb, int elemszam); void rendez_buborek(double* tomb, int ele4mszam); void main(void) { int i,n; double a[MAXELEM]; /* Elemszam beolvasasa */ scanf ("%d",&n); /* Tombelemek beolvasasa */ for (i=0; i<n; i++) scanf("%lf",a+i); rendez_cseres (a,n); for (i=0; i<n; i++) printf("%lf ",a[i]); printf("\n"); rendez_buborek (a,n); for (i=0; i<n; i++) printf("%lf ",a[i]); printf("\n");

55

} void rendez_kiv(double* tomb, int elemszam) /* A fggvny nvekv sorrendbe rendezi a tmb tmbt */ { int i,j,minindex; double min, seged; for (i=0; i<elemszam-1; i++) { /* legkisebb elem keresese az aktualis elemtol a tomb vegeig */ min = tomb[i]; minindex = i; for (j=i+1; j<elemszam; j++) { if (tomb[j] < min) { min = tomb[j]; minindex = j; } } /* Ha nem az aktualis elem a legkisebb, csere */ if (minindex != i) { seged = tomb[i]; tomb[i] = min; tomb[minindex] = seged; } } } void rendez_buborek(double* tomb, int elemszam) /* A fggvny nvekv sorrendbe rendezi a tmb tmbt */ { int i,csere; double seged; csere =1; while (csere) /* Mindaddig, amg csere szksges volt */ { csere = 0; for (i=0; i<elemszam-1; i++) if (tomb[i] > tomb[i+1]) /* Ha a szomszdos elemek */ { /* sorrendje nem j */ seged = tomb[i]; /* Csere */ tomb[i] = tomb[i+1]; tomb[i+1] = seged; csere++;

56

} } }

16.2. Pldaprogram: j elem beszrsa rendezett tmbbe A feladat egy program rsa, amely a standard inputrl pozitv egsz szmokat olvas, s ezeket elhelyezi nagysg szerint nvekv sorrendben egy tmb egyms utn kvetkez elemeibe. A beolvass vgt az els nem pozitv szm jelzi. /* CPELDA10.C */ /* Ksztette: Ficsor Lajos */ /* A program a standard inputrl pozitv egsz rtkeket olvas be, s egy tmbben nagysg szerint nvekv sorrendben helyezi el. A beolvass vgt az els nem pozitv szm jelzi. */ #include <stdio.h> #define MAX 100 #define JOKICSISZAM 0 void main(void) { int tomb[MAX+1]; /* A tomb, amely a 1. indexu elemetol */ /*kezdve tartalmazza a beolvasott szamokat */ int elemek; /* A tombben elhelyezett elemek szama */ int szam,i; elemek = 0; /* A tomb 0. elemebe elhelyezunk egy olyan kis szamot, amely az adatok kozott nem fordulhat elo */ tomb[0] = JOKICSISZAM; scanf("%d",&szam); while (szam > 0) { /* A tomb vegetol kezdve minden elemet eggyel hatrebb (nagyobb indexu helyre) helyezunk, amig a beszurando szamnal kisebbet nem talalunk. Ekkor az uj elemet ez utan az elem utan tesszuk be a tombbe. Az ures tombre is jol mukodik. */ for (i=elemek; i>0 && szam<tomb[i]; i--) {

57

tomb[i+1] = tomb[i]; } tomb[++i] = szam; elemek++; printf ("A tomb elemszama: %d\n",elemek); for (i=0; i<=elemek; i++) printf (" %d",tomb[i]); printf("\n"); /* Kovetkezo szam beolvasasa */ scanf("%d",&szam); } /* while szam > 0 */ printf ("\nA vegleges tomb:\n"); for (i=1; i<=elemek; i++) printf (" %d",tomb[i]); }

17. Tbb forrsfile-bl ll programok

Egy C program a gyakorlatban mindig tbb forrsfile-bl ll, mert a tlsgosan hossz szvegek nehezen kezelhetk. Ezzel lehetv vlik az is, hogy egy forrsfile-ban csak a logikailag sszetartoz fggvnyek defincii legyenek. Ha azonban egy fggvny defincija s hvsa nem azonos forrsfile-ban van, a hvst tartalmaz file-ban azt deklarlni kell. A szksges deklarcik nyilvntartsa nem egyszer feladat, klnsen ha figyelembe vesszk, hogy egy vltoztatst minden helyen t kell vezetni. Ugyanez a problma akkor, ha knyvtrban trolt (pldul szabvnyos) fggvnyeket hvunk. Ezeknek a deklarcijt is meg kell adnunk a hvst tartalmaz forrsban. A problma megoldsra szolgl az #include <filenv> vagy #include "filenv" direktva. Jelentse: a filenv ltal meghatrozott file tartalma a direktva helyn bemsoldik a forrsfile-ba. Az els esetben a bemsoland file-t a fejleszt krnyezetben belltott szabvnyos helyen, a msodik forma esetn az aktulis katalgusban keresi a rendszer. Ezt a direktvt hasznlhatjuk fel a deklarcik egyszerstsre. Az elterjedt programozi gyakorlat szerint minden forrsfile (szoksos kiterjesztse: .C) csak a fggvnyek definciit tartalmazza, a deklarciikat egy ugyanolyan nev. de .H kiterjeszts file-ba (header file) gyjtjk ssze. A defincikat tartalmaz forrsfile-ba ez a header file egy #include direktva segtsgvel kerl be, s ugyanezt az eljrst hasznljuk a hvsokat tartalmaz forrsfile-ok esetn is. Az eddigi mintapldk elejn tallhat #include <stdio.h>

58

sor magyarzata az. hogy a szabvnyos input-output fggvnyek deklarciit a (szabvnyos) stdio.h header file tartalmazza. A fggvnyek lerst tartalmaz dokumentci minden fggvnyre megadja, hogy milyen nev header file tartalmazza az adott fggvny deklarcijt. A header file-ok a fggvny-deklarcikon kvl egyb deklarcikat, szimbolikus konstansokat stb. is tartalmazhatnak. Pldul az eddigi pldkban is mr hasznlt EOF az stdio.h file-ban deklarlt szimbolikus konstans.

17.1. Pldaprogram: egy szveg sorainak, szavainak s karaktereinek szma rjunk programot, amely meghatrozza a standard inputrl beolvasott file sorainak, szavainak s karaktereinek szmt. Sz: nem helykzzel kezdd, helykzzel vagy sor vgvel vgzd karaktersorozat. A file-t soronknt olvassuk be, a mr elzleg megrt getstr fggvny segtsgvel. Br a feladat mrete ezt most nem indokolja, gyakorlskppen a fprogramot s a fggvnyeket (a mr ismert getstr s a most megrand egyszo fggvnyt) tegyk kln forrsfile-okba. Legyen teht az STR.C file-ban a kt fggvny defincija, deklarciik pedig az STR.H file-ban. A fprogram forrsfile-ja legyen a SZAVAK.C . /* CPELDA8 */ /* Ksztette: Ficsor Lajos */ STR.H int getstr (char* s); void strmasol (char* cel, char* forras); STR.C #include <stdio.h> #include "str.h" int getstr (char* s) /**************************************************** A fuggveny egy sort olvas be a standard inputrol, es az s tombbe helyezi el, string-kent. Visszateresi erteke a beolvasott karakterek szama, vagy EOF ****************************************************/ { int c; int i; i=0; while ( (c=getchar()) != '\n' && c !=EOF) { s[i++] = c; 59

} s[i] = '\0'; return c==EOF ? c : i; } int egyszo(char*s, char* szo, int* szohossz) /********************************************************** A fuggveny beolvas az "s" stringbol egy szot, es elteszi a "szo" stringbe, a szo hosszat pedig a "szohossz" parameterbe. Szo definicioja: nem helykozzel kezdodo, helykozel vagy string vegevel hatarolt karaktersorozat. A string elejetol kezdi a keresest. Fuggvenyertek: az "s" stringbol feldolgozott karakterek szama. ***********************************************************/ { int i; i=0; *szohossz = 0; while ( s[i] == ' ') i++;

/* Szokozok atlepese, a szo */ /* elejenek keresere */ while ( s[i] != ' ' && s[i] != '\0') /* Szo belsejeben */ { szo[(*szohossz)++] = s[i++]; } /* vagyunk */ szo[*szohossz] = '\0'; /* Zaro 0 elhelyezese */ return i; } /* SZAVAK.C */ /* Keszitette: Ficsor Lajos */ /******************************************************** A program a standard inputrol beolvasott szovegfile sorainak, szavainak es karaktereinek szamat hatarozza meg. Ismert hiba: Ha az utolso sor nem sorveggel, hanem EOF-el er veget, figyelmen kivul marad! *********************************************************/ #include <stdio.h> #include "str.h" #define MAXSORHOSSZ 200 #define MAXSZOHOSSZ 200 void main(void)

60

{ char sor[MAXSORHOSSZ+1]; char szo[MAXSZOHOSSZ+1]; int sorszam, szoszam, karakterszam; int sorhossz, szohossz; int kezdet; int i; sorszam=0; karakterszam=0; szoszam=0; /* Soronkenti beolvasas a file vegeig */ while ( (sorhossz=getstrl(sor)) != EOF) { sorszam++; karakterszam += sorhossz; /* A sor szetszedese szavakka */ kezdet = 0; while (kezdet < sorhossz) { i = egyszo(sor+kezdet, szo, &szohossz); kezdet += i; if (szohossz) szoszam++; /* Ha valodi szo */ } } printf ("Sorok szama: %d\n",sorszam); printf ("Szavak szama: %d\n",szoszam); printf ("Karakterek szama szama: %d\n",karakterszam); }

18. A struktra s az uni

18.1 A struktra deklarcija A struktra olyan sszetett tpus, amelynek elemei klnbz tpusak lehetnek. (A tmb azonos tpus elemek sszefogsra alkalmas!) Deklarcija az albbi formk valamelyikvel lehetsges: struct {elemek deklarcija} vltozlista Deklarlja, hogy a vltozlista elemei adott szerkezet struktrk. struct nv {elemek deklarcija}

61

Ltrehoz egy nv nev tpust, amely a megadott szerkezet struktra. Ezutn a struct nv tpusnvknt hasznlhat deklarcikban. Ez a forma az ajnlott. Az elemek deklarcija pontosvesszvel elvlasztott deklarcilista. Pldk: stuct { int v; charhonap[12]; int nap; } szulinap, ma, tegnap; vagy struct datum { int v; char honap[12]; int nap; }; struct datum szulinap, ma, tegnap,*pd; Struktra tagja lehet mr definilt struktra (vagy annak mutatja) is, de nem lehet tagja nmaga. Lehet viszont tagja nmaga mutatja (nhivatkoz struktra).

18.2 Hivatkozs a struktra elemeire A struktrkkal az albbi mveletet vgezhetjk: az & opertorral kpezhetjk a cmt hivatkozhatunk valamelyik elemre a "." (pont) s a "->" opertorral megengedett kt azonos tpus struktra kztti rtkads struktra lehet fggvny paramtere vagy visszatrsi rtke A struktra elemre (tagjra vagy mezjre) hivatkozhatunk a struktra_azonost.tagnv konstrukcival. Pldul: szulinap.ev = 1951; A hivatkozs trtnhet struktra-mutat segtsgvel is. Mivel a C nyelvben ez a forma gyakori, erre kln opertor is van. A hivatkozs formja ebben az esetben: (*pd).nv vagy pd -> nev A fenti kt forma egyenrtk.

62

18.3 Struktra - tmbk A struktra-tpus lehet tmb alaptpusa. Pldul: struct datum napok[20]

18.4. Uni Az uni olyan vltoz, amely (klnbz idpontban) klnfle tpus s mret objektumokat tartalmazhat, ezltal ugyanazon trterletet klnflekppen hasznlhatunk. Az uni deklarcija formlisan ugyanolyan, mint a struktr, de a struct alapsz helyett a union alapszt kell hasznlni, azonban mg a struktrban az elemek felsorolsa az adott elemek sorozatt jelenti, az unionban a felsorols "az albbiak egyike" rtelm. A programoz felelsge, hogy kvetkezetesen hasznlja ezt a konstrukcit. Az albbi kis pldaprogram segtsgvel illusztrljuk a uni s a struktra hasznlatt. A datum struktra els eleme egy egsz vltoz, amellyel jelezni lehet, hogy a msodik eleme, amely egy uni, a lehetsges rtkek kzl ppen milyen tpust hasznl. #include <stdio> main() { struct angol_datum { int day; int month; int year;}; struct usa_datum { int mm; int dd; int yy; }; struct magyar_datum { int ev; char honap[12]; int nap; }; struct datum { int tipuskod; union { struct angd d1;

63

struct usad d2; struct magyd d3;}dat; }; struct datum a,b,c; a.tipuskod = 1; a.dat.d1.day = 10; a.dat.d1.month = 9; a.dat.d1.year = 1951; printf ("Angol datum: %d %d %d \n", a.dat.d1.day,a.dat.d1.month,a.dat.d1.year); a.tipuskod = 2; a.dat.d2.dd = 10; a.dat.d2.mm = 9; a.dat.d2.yy = 1951; printf ("USA datum: %d %d %d \n", a.dat.d2.mm,a.dat.d2.dd,a.dat.d2.yy); a.tipuskod = 3; a.dat.d3.nap = 10; a.dat.d3.honap = "szeptember"; a.dat.d3.ev = 1951; printf ("Magyar datum: %d %s %d \n", a.dat.d3.ev,a.dat.d3.honap,a.dat.d3.nap); }

18.5. Pldaprogram: sz-statisztika (1. vltozat) Ebben az alpontban a cl egy sszetettebb plda megoldsa: hatrozzuk meg az input szvegfile szavainak gyakorisgt! Els lps: a szavak elhatrolsa. Ehhez a CPELDA8 program egyszo fggvnynek tovbbfejlesztse szksges, a sz-hatrol karakterek pontos meghatrozsval. A tovbbfejlesztett vltozat a NYTSZO.C file-ban tallhat. Msodik lps: a szavak trolsi mdszernek meghatrozsa. Az els tlet lehet kt, prhuzamosan kezelend tmb: char szavak[MAXSZOHOSSZ+1][MAXDB] int db[MAXDB] Ez nem tl j megolds, mert logikailag sszetartoz adatok klnbz adatszerkezetekben tallhatk. Jobb megolds: struktratmb hasznlata. A szavak trolsra szolgl adatszerkezet gy: struct szodb { char szo[MAXSZOHOSSZ+1];

64

int db; }; struct szodb szavak[MAXDB]; Ennek az adatszerkezetnek is van htrnya: flsleges helyfoglals, mert a maximlis szmrethez kell lefoglalni a helyet flsleges helyfoglals, mert a maximlis szszmhoz kell lefoglalni a helyet mivel keressre lesz szksg, a szavakat rendezetten kell tartani, ami sok adatmozgatst ignyel A ksbbiekben a fenti adatszerkezetet gy fogjuk mdostani, hogy a fenti htrnyok cskkenjenek, most azonban fogadjuk el ezt a megoldst. Az algoritmus az albbi lehet: 1. Olvassuk vgig soronknt a file-t, amg a file vgt el nem rjk 2. Minden sort vgjunk szt szavakra 3. Minden szt keressnk meg az eddigi szavakat trol tblzatban (a SZAVAK tmbben) Ha megtalltuk, a gyakorisgot nveljk eggyel Ha nem talltuk meg, szrjuk be a tmbbe, 1 gyakorisggal. Az 1. s 2. pontban lert mveletek a CPELDA8 programban kialaktottak szerint megoldhatk, teht ennek a programnak a mdostsval lehet a legknnyebben a feladatot megoldani. A 3. pont keressi mvelett a CPELDA10 programban implementlt algoritmus finomtsval implementlhatjuk. Az elforduls vagy beszrs helynek megkeresst klnvlasztva erre egy keres nev fggvnyt runk, a beszrshoz tartoz adatmozgatst a fprogramra bzzuk. Mivel a keres nev fggvny s a fprogram egyarnt hasznlja a szodb struktrt, ennek deklarcijt kls deklarciknt oldjuk meg, s a konstans defincikkal egytt a SZODEF1.H header file-ba teleptjk. Ezek alapjn a program az albbi modulokat tartalmazza:

SZODEF1.C amely hivatkozik a SZODEF1.H, az STR.H, az NYTSZO.H s a SZOFGV1.H header file-okra NYTSZO.C SZOFGV1.C, amely hivatkozik a SZODEF1.H header file-ra STR.C, amely korbban lett kifejlesztve, s a soronknti beolvasshoz szksges getstrl fggvny miatt szksges.

/* NYTSZO.C */ /* Keszitette: Ficsor Lajos */ #include "nytszo.h"

65

int nytszo(char*s, char* szo, int* szohossz) /******************************************************* A fuggveny beolvas az "s" stringbol egy szot, es elteszi a "szo" stringbe, a szo hosszat pedig a "szohossz" parameterbe. Szo definicioja: nem hatarolo karakterrel kezdodo, hatarolo karakterrel vagy string vegevel vegzodo karaktersorozat. A string elejetol kezdi a keresest. Hatarolo karakterek: amit a "hatarolo" fgv. annak jelez. Fuggvenyertek: az "s" stringbol feldolgozott karaktere szama. Hivott fuggvenyek: hatarolo *********************************************************/ { int i; i=0; *szohossz = 0; while ( hatarolo(s[i])) i++; /* Szo elejenek keresese */ while ( !hatarolo(s[i]) && s[i] != '\0') { szo[(*szohossz)++] = s[i++]; } szo[*szohossz] = '\0'; return i; } int hatarolo(char c) /* { int hatar; hatar = 0; if (c==' ' || c=='\t' || c=='.' || c==',' || c== '(' || c==')' || c=='!' || c =='?') hatar = 1; return hatar; } Persze ez irhato sokkal rovidebben: */

{ return c==' ' || c=='\t' || c=='.' || c==',' || c==':' || c==';' || c== '(' || c==')' || c=='!' || c =='?' || c=='"'; }

/* SZODEF1.H */ /* Definiciok a szo-statisztikahoz. 1. valtozat

66

*/ #define MAXSORHOSSZ 300 #define MAXSZOHOSSZ 50 #define MAXDB 800 struct szodb { char szo[MAXSZOHOSSZ+1]; int db; };

/* SZOFGV1.C */ /* Keszitette: Ficsor Lajos */ /* A szo statisztika keszitesehez szukseges fuggvenyek */ #include <string.h> #include "szodef1.h" #include "szofgv1.h" int keres (struct szodb tabla[], /* A szavak tablazata */ int tablahossz, /* A tabla elemeinak szama */ char* szo, /* A keresendo szo */ int* bennevan) /* =1, ha a szot megtalaltuk, =0 ha nem */ /* A fgv. a "szavak" tombben keresi a "szo" szot. Visszateresi ertek: a keresett szo sorszama (vagy helye) a tombben */ { int i,j; int hely = 0; int talalt = 0; *bennevan = 0; for (i=0; !talalt && i<=tablahossz; i++) { j = strcmp(szo, tabla[i].szo); if (j<=0) { hely = i; talalt = 1; if ( j == 0) *bennevan = 1; } } return hely; }

67

/* SZOSTAT1.C */ /* Szostatisztika program 1. valtozat */ /* Keszitette: Ficsor Lajos */ #include #include #include #include #include #include <stdio.h> <string.h> "szodef1.h" "str.h" "nytszo.h" "szofgv1.h"

void main(void) { char sor[MAXSORHOSSZ+1]; char szo[MAXSZOHOSSZ+1]; struct szodb szavak[MAXDB+1]; char* soreleje; int sorhossz, szohossz; int kezdet; int hely; int tablahossz; int bennevan; int i; /* Szo-tabla elokeszitese */ szavak[0].szo[0] = 'z'+1; szavak[0].szo[1] = '\0'; tablahossz = 0; /* Soronkenti beolvasas a file vegeig */ while ( (sorhossz=getstrl(sor, MAXSORHOSSZ)) != EOF) { /* A sor szetszedese szavakka */ kezdet = 0; while (kezdet < sorhossz) { i = nytszo(sor+kezdet, szo, &szohossz); kezdet += i; if (szohossz) { /* Valodi szot talalt */ printf ("\n%s",szo); /* Kereses a tablaban */ hely = keres (szavak, tablahossz, szo, &bennevan); if (bennevan)

68

{ /* Megtalalta */ szavak[hely].db++; } else { /* Nem talalta meg. Betesszuk a tablaba */ for (i=tablahossz; i>=hely; i--) { szavak[i+1] = szavak[i]; } strcpy(szavak[hely].szo,szo); szavak[hely].db = 1; tablahossz++; } /* If bennevan */ printf ("\n%d %d %s\n",tablahossz, hely, szavak[hely].szo); for (i=0; i<tablahossz; i++) /* Csak ellenorzo kiiras */ { printf ("\n%50s %5d\n", szavak[i].szo, szavak[i].db); } } /* If szohossz */ } /* while kezdet < sorhossz */ } /* while ...!-EOF */ /* Statisztika kiirasa */ for (i=0; i<tablahossz; i++) { printf ("\n%50s %5d", szavak[i].szo, szavak[i].db); } printf("\n"); }

19. Dinamikus memria kezels

Ha egy vltozt vagy tmbt definilunk, annak hely foglaldik a memriban, ami az adott vltoz vagy tmb teljes lettartama alatt rendelkezsre ll, akr kihasznljuk, akr nem. A tmbk esetn a mretet konstans kifejezsknt kell megadnunk, teht az nem fgghet a program kzben meghatrozott rtkektl. Mindkt problmt megoldja a dinamikus memriafoglals lehetsge. Segtsgvel csak akkor kell lefoglalni az adatok trolshoz a helyet, amikor azt hasznlni akarjuk, s csak annyit, amennyi szksges. Ha az adatokra mr nincs szksg, a lefoglalt memria felszabadthat s ms clra jra lefoglalhat. A lefoglalt memria a kezdcmt tartalmaz pointer segtsgvel kezelhet.

69

19.1 Memriakezel fggvnyek Hasznlatukhoz szksges az stdlib.h header file. void* malloc(size_t meret) Lefoglal meret byte nagysg memriaterletet. Visszatrsi rtke a lefoglalt terlet kezdcme, vagy NULL, ha a helyfoglals sikertelen volt. A visszaadott pointer void* tpus, ha teht a memriaterletet tmb-szeren akarjuk hasznlni (mint ltalban szoks), azt a trolni kvnt adatok tpusra kell konvertlni. A size_t elre definilt tpus (olyan egsz, amelyben biztosan elfr a lefoglaland terlet mrete), NULL pedig a 0 mutat szmra definilt szimbolikus konstans. void free(void* blokk) Felszabadtja a blokk kezdcm memriateletet. A paramternek elzleg malloc, calloc vagy a realloc fggvny segtsgvel kellett rtket kapnia. void* calloc (size_t db, size_t meret) Lefoglal db*meret byte nagysg memriaterletet. Visszatrsi rtke mint az malloc fggvnynl. void* realloc(void* blokk, size_t meret) A blokk egy mr korbban lefoglalt terlet kezdcme. Ennek a terletnek a mrett meret nagysgra lltja. Ha a mret cskken, adatok vesznek el. Ha n, a terlet kezdcme (ami a visszatrsi rtk) megvltozhat. Ekkor a korbbi adatok az j helyre msoldnak.

19.2. Pldaprogram: sz-statisztika (2. vltozat) A program els vltozatban alkalmazott adatszerkezet minden sz szmra valamilyen maximlis szhossznak megfelel helyet foglalt le. Ez flsleges memriapocskls, radsul a program emiatt a MAXSZOHOSSZ-nl hosszabb szavakat nem tudja kezelni. A feladat most a program mdostsa gy, hogy a helyfoglalsa kedvezbb l egyen. Ehhez a szavak adatait tartalmaz struktrt talaktjuk gy, hogy ne a szt, hanem annak pointert tartalmazza. Minden sz szmra dinamikusan foglalunk helyet, annyit, amennyi szksges. Az j struktra: struct szodb { char* szo; int db; } Az talakts miatt meglepen kevs helyen kell mdostani a programot! (Ez is mutatja a pointer hasznt a C nyelvben.)

70

Tovbbra is flsleges helyfoglalst okoz az, hogy a struktra-tmbt fix mrettel kell deklarlni. Ezt csak gy kerlhetjk el, hogy ms adatszerkezetet hasznlunk. A feladat legelegnsabb megoldsa a binris fa adatszerkezet segtsgvel kszthet el. Ez egyben a beszrshoz szksges keressre is j megoldst ad. /* SZODEF2.H */ /* Definiciok a szo-statisztikahoz. 2. valtozat */ #define MAXSORHOSSZ 300 #define MAXSZOHOSSZ 50 #define MAXDB 100 struct szodb { char* szo; int db; }; /* SZOSTAT2.C */ /* Szostatisztika program 2. valtozat */ /* Keszitette: Ficsor Lajos */ #include #include #include #include #include #include #include <stdio.h> <string.h> <alloc.h> "str.h" "nytszo.h" "szodef2.h" "szofgv2.h"

Mindssze kt helyen van vltozs az 1. vltozathoz kpest: /* Szo-tabla elokeszitese */ /* Itt a klnbseg!*/ szavak[0].szo = (char*) malloc(MAXSZOHOSSZ+1); /* Innentl mr vltozatlan /* szavak[0].szo[0] = 'z'+1); szavak[0].szo[1] = '\0'; tablahossz = 0; . . .

71

{ /* Nem talalta meg. Betesszuk a tablaba */ for (i=tablahossz; i>=hely; i--) { szavak[i+1] = szavak[i]; } /*Masik kulonbseg!! */ szavak[hely].szo = (char*) malloc(strlen(szo)+1); /* Innen jra vltozatlan! */ strcpy(szavak[hely].szo,szo); szavak[hely].db = 1; tablahossz++; } /* If bennevan */

/* SZOFGV2.C */ /* 2. valtozat */ /* Keszitette: Ficsor Lajos */ /* A szo statisztika keszitesehez szukseges fuggvenyek Csak a struktra defincijt tartalmaz szodef2.h miatt vltozik, maga a fggvny azonos! */ #include <string.h> #include "szodef2.h" #include "szofgv2.h" A teljes vltozat a lemezmellkleten megtallhat.

20. Parancssor-argumentumok
Ha az ltalunk megrt programot parancssorbl indtjuk el, van lehetsgnk arra, hogy a parancssorban adatokat adjunk meg szmra.

72

A main fggvny prototpusa az eddigi pldkban void main(void) volt. Teljes alakja azonban int main(int argc, char* argv[], char* env[]) A main fggvny visszatrsi rtkt a programot aktivizl program (ltalban az opercis rendszer) kapja meg. A 0 visszaadott rtk megllapods szerint a sikeres vgrehajtst jelenti. Az ettl eltr rtkkel a program befejezdsnek okra utalhatunk. A visszatrsi rtket a main fggvnyben lev return utasts, vagy a brhol meghvhat exit fggvny llthatja be. Az exit fggvny hasznlathoz az stdlib.h vagy process.h fejlcfile szksges. Prototpusa: void exit(int status) A main fggvny els kt paramtere a program aktivizlshoz hasznlt parancssorban tallhat paramtereket adja vissza, a harmadik (ami el is maradhat) pedig az opercis rendszer krnyezeti vltozit tarta lmazza, az albbiak szerint: argc a paramterek szma + 1 argv[0] a parancssorban a prompt utn gpelt els stringre (a program neve, esetleg elrsi ttal) mutat pointer argv[1] az els paramterre mutat pointer . . . argv[argc-1] az utols paramterre mutat pointer argv[argc] = NULL Hasonlan az env[0], env[1], ... , env[n-1] a program hvsakor rvnyes krnyezeti vltozkat tartalmazza, (ahol n a krnyezeti vltozk szma), env[n]=NULL. A parancssor paramtereit helykz vlasztja el. Ha egy paramterben helykz lenne, azt idzjelek kz kell rni. (A program az idzjelet nem kapja meg!)

21. Szabvnyos fggvnyek

A C nyelv hasznlatt szmos szabvnyos fggvny segti. Ezek ismertetsre itt termszetesen nincs hely, ezrt csak felsoroljuk a legfontosabb tmacsoportokat, s azokat a header file-okat, amelyet a szksges deklarcikat s egyb elemeket tartalmazzk. Nem teljes kren ismertetjk a string kezelshez s a file kezelshez szksges fggvnyeket.

73

21.1. Szabvnyos header file-ok Header file neve stdio.h ctype.h string.h math.h stdlib.h assert.h setjmp.h time.h signal.h limits.h float.h stdarg.h Funkci Szabvnyos adatbevitel s adatkivitel Karakter-vizsglatok String kezel fggvnyek Matematikai fggvnyek Kiegszt rendszerfggvnyek Programdiagnosztika Nem loklis vezrlstadsok Dtum s id kezelse Jelzsek (UNIX signal-ok) kezelse A gpi megvalstsban definilt hatrrtkek Vltoz hosszsg argumentumlistk kezelse

Termszetesen minden gpi megvalsts tovbbi, rendszer-specifikus fggvnyeket is tartalmaz. (Ilyen pldul DOS alatt a conio.h a direkt kpernykezels fggvnyeivel.)

21.2. String kezel fggvnyek Itt ismertetjk a legfontosabb karakterkezel fggvnyeket. A felsorols nem teljes! 21.2.1. Karaktertalakt fggvnyek. Szksges a ctype.h header file. int tolower(int ch) A paramtert kisbetsre konvertlja, ha az az A - Z tartomnyba esik, vltozatlanul hagyja egybknt. int toupper(int ch) A paramtert nagybetsre konvert lja, ha az az a - z tartomnyba esik, vltozatlanul hagyja egybknt. 21.2.2. Tovbbi string-kezel fggvnyek: Szksges a string.h header file. int strcmp(char* s1, char*s2) sszehasonltja az paramtereit, s a visszatrsi rtke negatv, ha s1 < s2 0, ha s1 = s2 pozitv, ha s1 > s2 int strncmp(char* s1, char*s2, int maxhossz) 74

Mint az strcmp, de legfeljebb maxhossz karaktert hasonlt ssze. char* strcpy (char* cel, chsr* forras) A forras stringet a cel stringbe msolja, belertve a zr 0-t is. Visszatrsi rtke a cel string mutatja. char* strncpy (char* cel, chsr* forras, int maxhossz) Mint az strcpy, de legfeljebb maxhossz karaktert msol. 21.2.3 Konvertl fggvnyek Az stdlib.h header file kell! int atoi(char* s) Az s stringet egsz szmm konvertlja. A konverzi megll az els nem megfelel karakternl. long atol(char* s) Az s stringet hossz egsz szmm konvertlja. A konverzi megll az els nem megfelel karakternl. double atof(char* s) Az s stringet lebegpontos szmm konvertlja. A konverzi megll az els nem megfelel karakternl.

21.3. File kezel fggvnyek A C alapveten byte-ok (pontosabban char tpus egysgek) sorozataknt tekinti a fileokat. A programoz feladata a file tartalmt rtelmezni. Egyetlen kivtel: ha a file-t text tpusnak deklarljuk, a '\n' ("sorvg") karakter opercis rendszer fgg kezelst elfedi ellnk. 21.3.1 File megnyitsa s lezrsa Minden file-t egy FILE elredefinilt tpus struktra azonost. Erre mutat pointert (FILE* tpust) hasznlnak a file-kezel fggvnyek. Van hrom elre definilt FILE* vltoz: stdin : standard input stdout : standard output stderr : standard hibacsatorna Minden file-t a hasznlata eltt meg kell nyitni. Ezzel kapunk egy egyedi azonostt, amellyel a ksbbiekben hivatkozunk r, illetve bellthatjuk bizonyos jellemzit. Erre szolgl az fopen fggvny: FILE* fopen(char* filenev, char* mod)

75

ahol filenv paramter a file neve (az adott opercis rendszer szablyai szerint) mod egy, kt vagy hrom karakteres string, amely meghatrozza a file hasznlatnak a mdjt, az albbiak szerint: Md jele r w a r+ w+ a+ Hasznlat mdja Csak olvassra Csak rsra Hozzrs Olvass s rs Olvass s rs Olvass s hozzrs A megnevezett file-lal val kapcsolat Lteznie kell! Ha ltezik, elz tartalma elvsz, ha nem ltezik, ltre jn egy j (res) file. Ha ltezik, az rs az elz tartalom vgtl kezddik. Ha nem ltezik, ltrejn egy j file. Lteznie kell! Ha ltezik, elz tartalma elvsz, ha nem ltezik, ltrejn egy j ( res) file. Ha ltezik, az rs az elz tartalom vgtl kezddik. Ha nem ltezik, ltrejn egy j file.

A fenti hat md jel brmelyike utn rhat a b vagy t karakter, jelezve a binris vagy text (szvegfile) jelleget. A klnbsg csak az, hogy a binris filet mindig byte-onknt kezeli a program, mg szvegfile esetn a '\n' karakter kirsa az opercis rendszer ltal sorvgjelknt rtelmezett bytesorozatot szr be a file-ba, az ilyen byte-sorozat olvassa pedig egy '\n' karaktert eredmnyez. Pldk: "a+t" "rb" szvegfile megnyitsa hozzfzsre binris file megnyitsa csak olvassra.

A fggvny visszatrsi rtke a file ler struktrra mutat pointer, ha a megnyits sikeres, a NULL pointer egybknt. Ezrt szoksos hasznlata: FILE* inputfile; . . .

if ( (inputfile=fopen("bemeno.txt","rt")) == NULL) { fprintf (stderr,"File nyitsi hiba az input file-nl!\n"); exit(1); /* A program futsnak befejezse */ } else { /* A file feldolgozsa */ } Minden file-t a hasznlata utn le kell zrni. Erre szolgl az int fclose(FILE* f) fggvny, amelynek paramtere a lezrand file lerja, visszatrsi rtke 0 sikeres lezrs esetn, EOF egybknt. 76

Megjegyzsek: A file lezrsa utn az azonostsra hasznlt vltoz jra felhasznlhat. A fprogram (main fggvny) vgn minden nyitott file automatikusan lezrdik, mieltt a program befejezi a futst. A program nem kzvetlenl a file-ba (tbbnyire a lemezre) r, hanem egy bufferbe. A bufferbl a file-ba az adatok automatikusan kerlnek be, ha a buffer megtelik. A file lezrsa eltt a nem res buffer is kirdik a file-ba. Ha azonban a program futsa rendellenesen ll le, nem hajtdik vgre automati kusan file lezrs, gy adatok veszhetnek el. 21.3.2 rs s olvass int fprintf(FILE* f, char*s, . . . ) Mint a printf, csak az f file-ba r ki. int fscanf(FILE* f, char*s, . . . ) Mint a scanf, csak az f file-bl olvas. int getc(FILE* f) Mint a getchar, csak az f file-bl olvas. int putc(char c, FILE* f) Kirja a c karaktert az f file-ba. Visszatrsi rtke a kirt karakter, hiba esetn EOF. int fputs(char*s, FILE* f) Kirja az s stringet, a zr nulla karakter nlkl. Visszatrsi rtke az utoljra kirt karakter, vagy EOF. char* fgets(char*s, int n, FILE* f) Beolvas az s stringbe a sorvge karakterig, de maximum n-1 karaktert. A string vgre teszi a zr nulla karaktert. Visszatrsi rtke a beolvasott stringre mutat pointer, vagy NULL. Megjegyzs: A fenti fggvnyek elssorban szveges file-ok kezelsre szolglnak, br a getc s putc mindkt tpus esetn hasznlhat, de sorvg-karakter esetn a mkdsk a file tpustl fgg. int fread(void*p, int meret, int n, FILE* f) A fggvny n db, meret mret adatot olvas be, s elhelyezi azokat a p cmtl kezdden. A p tetszleges objektumot megcmezhet. A programoz felelssge, hogy a kijellt memriaterlet elegend hosszsg-e s a feltlttt memriaterlet rtelmezhet-e. Visszatrsi rtke a beolv asott adatok szma. Hiba vagy file vge esetn ez n-tl kisebb. int fwrite(void*p, int meret, int n, FILE* f) Mint az fread, de kir.

77

Megjegyzs: A fenti fggvnyek a binris file-ok kezelsre szolglnak. 21.3.3 Pozicionls a file-ban Minden file-hoz tartozik egy aktulis pozci, amit byte-ban szmtunk. Egy file megnyitsa utn az aktulis pozci 0, azaz a file elejre mutat. A vgrehajtott rsi s olvassi mveletek az aktulis pozcit is lltjk, az tvitt byte-ok szmnak megfelelen. Az aktulis pozcit a programbl kzvetlenl is llthatjuk, amivel a file feldolgozsa tetszleges sorrendben megvalsthat. int fseek(FILE* f, long offset, int viszonyitas) Hozzadja (eljelesen!) az offset rtkt a viszonyitas ltal meghatrozott rtkhez, s ez lesz az j aktulis pozci. viszonyitas lehetsges rtkei (elredefinilt konstansok): SEEK_SET a file eleje SEEK_CUR az aktulis file pozci SEEK_END a file vge Visszatrsi rtke 0 sikeres vgrehajts esetn, nem 0 egybknt. long ftell(FILE* f) Visszadja az aktulis file pozci rtkt, a file elejtl szmolva. Sikertelensg esetn a visszatrsi rtk -1. void rewind(FILE* f) A file elejre lltja a file pozcit. Megjegyzs: A file pozci lltsa a buffer kirst is jelenti, ha az j pozci nem a bufferen bell van.

21.4. Pldaprogram: string keresse file-ban rjunk programot, amely az els paramterben megadott stringet megkeresi a msodik paramterben megadott file-ban. Ha a harmadik paramter "p", akkor pontos (kis/nagybet rzkeny) egyezst keres, ha elmarad, vagy brmi ms, akkor csak "betegyezst" keres. A program csak akkor kezdje el a mkdst, ha a paramterek szma megfelel. Jelezze ki, ha a megadott file megnyitsa nem sikerlt. A visszaadott sttuszk d jelezze a hiba okt! A program minden egyezsnl rja ki a sor s a soron bell az els egyez karakter szmt!

78

/* KERES.C */ /* Ksztette: Ficsor Lajos */ /* A program megkeresi egy szvegfile-ban egy string elfordulsait */ #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAXSORHOSSZ 300 int fgetstrl (FILE* inp, char* s, int max); FILE* inp; int main(int argc, char* argv[]) { int pontos; int sorhossz; char sor[MAXSORHOSSZ+1]; int mintahossz; int sorszam = 0; int i; if (argc < 3 || argc > 4 ) { fprintf(stderr, "\nHasznalata: keres minta filenev [p]\n"); exit(1); } if ( (inp=fopen(argv[2], "r")) == NULL) { fprintf(stderr, "\nFile nyitasi hiba!\n"); exit(2); } if (argc == 4 && argv[3][0] == 'p') { /* Pontos kereses kell! */ pontos = 1; } else { /* nem kell pontos kereses */ pontos = 0; /* A minta nagybetusre konvertalasa */

79

strupr(argv[1]); } /* Minta hossza */ mintahossz = strlen(argv[1]); /* Olvasas soronkent a file vegeig */ while ( (sorhossz=fgetstrl(inp, sor, MAXSORHOSSZ)) != EOF) { sorszam++; /* Ha nem kell pontos egyezes, nagybetusre konvertalas */ if ( !pontos) { strupr(sor); } /* kereses a soron belul */ for (i=0; i<=sorhossz-mintahossz; i++) { if ( strncmp(argv[1], sor+i, mintahossz) == 0) { /* Egyezes van! */ printf("\n Sorszam: %d, karakter: %d", sorszam, i); } } } /* while */ fclose (inp); return 0; } int fgetstrl (FILE* inp, char* s, int max) /****************************************************** A fuggveny egy sort olvas be az inp file-bol, vagy annak az elso max karakteret, ha attol hosszabb, es az s tombbe helyezi el, string-kent. Visszateresi erteke a beolvasott karakterek szama, vagy EOF *******************************************************/ { int c; int i; i=0; while ( (c=getc(inp)) != '\n' && c !=EOF && i<max) { s[i++] = c; }

80

s[i] = '\0'; return c==EOF ? c : i; }

81

Ajnlott irodalom:
1. Brian W. Kernighan, Dennis M. Ritchie A C programozsi nyelv Mszaki Knyvkiad Budapest, 1988. 2. Brian W. Kernighan, Dennis M Ritchie A C programozsi nyelv. Az ANSI szerint szerint szabvnyostott vltozat. Mszaki Knyvkiad Budapest, 1997. 3. Benk Tiborn, Poppe Andrs, Benk Lszl Bevezets a BORLAND C++ programozsba ComputerBooks Budapest, 1995

82

Kdolsi szabvny

Miskolci Egyetem ltalnos Informatikai Tanszk kdolsi szabvnya C nyelvhez

Tartalom:
1. Bevezets 2. Fjlok 3. Nevek 4. Fggvnyek 5. Konstansok 6. Vltozk 7. Vezrlsi szerkezetek 8. Kifejezsek 9. Memria kezels 10. Hordozhatsg

1. Bevezets
1.1 A szabvny clja A szabvny clja az egysges s helyes programozsi stlus elsajttsnak elsegtse. A szabvnynak megfelel programok egyszeren ttekinthetek, ebbl kvetkezen jl rthetek, s knnyen karbantarthatak lesznek. Az egyes kdrszek jrahasznosthatsga megnvekszik, ezltal a feladatok elksztshez szksges idrfordts is cskken. 1.2 Hatskr Az ltalnos Informatikai Tanszk szmra kszlt valamennyi C nyelv program ktelezen meg kell felelnjen ennek a szabvnynak. A szabvny formai elrsai igazodnak a GNU kdolsi szabvnyhoz, gy a forrsfjlok formzshoz a GNU indent, vagy a GNU Emacs program hasznlata javasolt.

2. Fjlok
2.1 A forrs tagolsa Egy forrsfjlba csak logikailag szorosan sszetartoz fggvnyek kerlhetnek. ssze nem tartoz fggvnyek egy fjlban trolsakor az egyes fggvnyeket nehezen lehet megtallni, valamint jrafelhasznlskor egy fggvny miatt a teljes object fjl sszes fggvnye hozzlinkeldik a programhoz, ezzel flslegesen nvelve a futtathat fjl mrett. A forrsfjlok mrete nem lpheti tl az 500 sort. Ez a szably is az ttekinthetsget szolglja. Amennyiben egy 500 sor sszterjedelmet meghalad fggvnycsoport nagyon szorosan kapcsoldik egymshoz, azt az egyes forrs fjlok elnevezsvel 83

kell jelezni.

2.2 A fjlok elnevezse A C forrs fjlok kiterjesztse mindig ".c", a header fjlok kiterjesztse mindig ".h". A fjlnvbl els ltsra megllapthatjuk a fjl rendeltetst. Az egysges elnevezsbl addan a fjlok kezelse is egysges lehet, egyszeren kszthetnk fjlkezel eszkzket. Az sszetartoz C s header fjlok neve a kiterjesztstl eltekintve azonos. Amennyiben tbb, szorosan sszetartoz C fjlhoz egy header fjl tartozik, akkor a C fjlok nevnek els rsze megegyezik a header fjl nevvel, msodik rsze pedg egy szm, vagy a funkcira utal rvidts.
Pldul: Esetleg: screen.h screen.h screen1.c screen_base.c screen2.c screen_complex.c

A nevek egyezsge elsegti a gyors, magtl rtetd sszerendelst, gy nvelve az ttekinthetsget, s knnytve az jrahasznosthatsgot. A fjlnevek legyenek egyediek minnl nagyobb krnyezetben, s utaljanak a tartalmazott fggvny(ek) funkcijra. Egy nagyobb projektben, - ahol tbb katalgusba kell szervezni a fjlokat, - vagy jra felhasznlskor zavar lehet tbb, azonos nev fjl meglte -, mgha klnbz katalgusban tallhatak is. A funkcira nem utal fjlnv mr nhny forrs fjl esetn is szinte lehetetenn teszi egy adott fggvny megtallst, ami nagyban megnehezti mind a hibakeresst, mind a karbantartst.

2.3 Include fjlok Header fjlokon kvl ms fjl include-lsa tilos ! Kezd programozknl elfordul az a nagyon rossz gyakorlat, hogy a tbb forrs fjlbl ll programnl egyszeren a C fjlokat include-ljk a main fggvnyt tartalmaz forrs fjlba. Ez elrelthatatlan hibkhoz, s risi kavarodshoz vezethet. A fordtsi id is nagyban megnvekszik, mert minden fordts alkalmval jrafordul az sszes modul, nem csak a fggsgekbl ered szksgesek. Minden header fjlban lteznie kell egy tbbszrs include-lst gtl mechanizmusnak. Ha egy header fjl tbb, ms header fjlba is include-lva van, akkor knnyen elllhat az a helyzet, hogy egy header fjl tbbszr kerl include-lsra ugyanabba a forrs fjlba. Ez fordtsi hibkhoz (konstans jradefinils) vezethet, valamint nveli a fordtsi idt. Ezt a legegyszerbben az #ifndef/#define/#endif szerkezettel akadlyozhatjuk meg.
Plda: #ifndef _SPECIALNAME_ #define _SPECIALNAME_ /* header block */ #endif

A _SPECIALNAME_ ajnlott kpzsi mdja: a filenev.h include file-hoz hasznljuk az _FILENEV_H_ konvencit. Csak a minimlisan szksges header fjlokat include-ljuk. Ezzel biztosthat a minimlis fordtsi id, s a nvazonossgbl ered sszefrhetelensg eslyt is a minimlisra cskkentjk. Az elre definilt header fjlokat a #include <filenv.h>, a felhasznli header fjlokat pedg a #include "fjlnv.h" direktvval include-ljuk. Ha a #include direktvt <> pr kveti, akkor a fordt a header fjlt a megadott include katalgusokban keresi, ezzel szemben ha a fjlnv "" jelek kztt szerepel, akkor a fordt csak az

84

aktulis kataloggusban keresi a header fjlt. gy cskken a fjlnv tkzs veszlye is.

2.4 Kommentek Minden forrs fjl elejn szerepelnie kell az adott fjlra vonatkoz ltalnos informcikat tartalmaz megjegyzs blokknak. A blokk kinzete:
/* fjlnv A fjlban lv fggvnyek egyttes funkcija A kszt neve (esetleg Copyright) Utols mdosts dtuma, verziszm */

Minden fggvny deklarcija s defincija eltt rszletes megjegyzsnek kell szerepelnie. A header fjlban a fggvny hasznljnak szl, a C forrs fjlban pedg a program karbantartjnak, esetleges tovbbfejlesztjnek szl megjegyzst kell elhelyezni. A megjegyzs blokk rszletes ismertetse a fggvnyek-rl szl szablyoknl tallhat. A megjegyzsek egy fjlon -, lehetleg az egsz projekten - bell azonos nyelven, vagy csak magyarul, vagy csak angolul legyenek rva. Zavar lehet tbb nyelv keverse, esetleg flrertst is okozhat, az olvashatsgot mindenkppen rontja. Feladatok elksztse sorn magyar nyelv (de az eltr kdtblk miatti problmkat elkerlend termszetesen kezet nkli) megjegyzseket hasznljunk.

3. Nevek
A nv mindig utaljon az ltala azonostott elem funkcijra. Akr fggvnyrl, konstansrl, vagy vltozrl legyen is sz, csak gy lesz egyszeren rthet s tlthat a program. Ellenkez esetben minden elfordulskor meg kell keresni a definci, vagy az utols hivatkozs helyt, hogy rtelmezhessk a nv jelentst. A j nvvlaszts egyszersti, egyes esetekben flslegess is teheti a megjegyzseket. A makrk ( #define ) neve mindig csupa nagybetbl lljon. Ez ltal a makrk els ltsra elklnlnek a programszveg tbbi rsztl. Erre azrt van szksg, mert a makrk - fknt a fggvnyek - kezelse elvigyzatossgot ignyel. Lsd a konstansok s a fggvnyek fejezeteket. A tbb szbl ll neveket egybe kell rni, s minden szt nagybetvel kell kezdeni. Tbb szban pontosabban lehet utalni az azonostott elem funkcijra. A kis- s nagybetk megfelel alkalmazsval a szhatrok egyrtelmek. A makrk nevben a szhatrokat az '_' karakterrel kell jellni.
Pldul: NotTooLongName THIS_IS_A_MACRO

Egy nv lthatsga minnl nagyobb, annl hosszabbnak kell lennie. A hossz nv cskkenti a nvtkzs lehetsgt. Egy knyvtr megrsakor minden nv el a knyvtrra utal prefixet kell alkalmazni. A prefix s a nv kz '_'-t kell tenni. A prefix mindig kezddjn kis betvel, kivve a makrneveket.
Pldul: disc_FunctionName DISC_MACRO_NAME

Sose hasznljunk egy vagy kt alhzssal ( _ vagy __ ) kezdd neveket A fordtk legtbbje mkds kzben ilyen formj neveket hasznl bels azonostsra, ezrt esetleg felderthetetlen fordtsi hibt eredmnyezhet alkalmazsuk. Egyetlen kivtel lehet: a header fjlok tbbszri include-lst megakadlyoz mechanizmus. Az itt

85

megadott nvnek minden ms nvtl klnbznek, a header fjl funkcijra utalnak, s hossznak kell lennie. Sose hasznljunk olyan neveket, amelyek csak a kis- s nagybets rsmdban, vagy az alhzs megltben, ill. hinyban trnek el. Ebben az esetben egy elrs esetleg nem okoz szintaktikai hibt, ezrt a fordt nem figyelmeztet r. Az ebbl ered szemantikai hibk feldertse klnsen nehz. Egyebknt is nehez fejben tartani, hogy melyik rsmd melyik elemet azonostja.
Ilyet ne: ThisIsaName THISisaName ThisIs_A_Name

A nevekben ne alkalmazzunk flrerthet rvidtseket. Ami a program rsakor a program rjnak egyrtelm, az nem biztos, hogy ksbb, egy msik szemlynek is az lesz.
Pldul: TermCap /* Terminate Capture or Terminal Capability ? */

4. Fggvnyek
Egy fggvny hossza nem haladhatja meg a 100-150 sort. Ettl hosszabb fggvnyek nehezen ttekinthetek, nehezen rtelmezhetek, ezrt a hibakeress is nehz. Ha egy hossz fggvny futst valamilyen hibaesemny miatt meg kell szaktani, akkor bonyolult a fggvny elz tevkenysgeit visszalltani (undo). A 100-150 soros terjedelem csak abban az esetben lphet t, ha a tevkenysg olyan, szorosan sszefgg utastsokat tartalmaz, amelyeket nem lehet logikusan sztbontani j fggvnyekre, s sok (5-nl tbb) paramter tadsa lenne szksges. Tovbbi felttel, hogy az ilyen hossz fggvnyek nem tartalmazhatnak 3 szintnl mlyebben egymsba gyazott elgazsokat. A nagy elgazsi mlysg nehezen tesztelhetv teszi a fggvnyt.

4.1 Argumentumok Trekedjk minnl kevesebb argumentum hasznlatra. A sok argumentum rossz tervezsre utal. Sok argumentum esetn nehz fejbentartani az argumentumok sorrendjt, azonos tpus argumentumok felcserlse esetn nehezen felderthet szemantikai hiba keletkezik. Tmbket s (nagy mret) struktrkat mindig mutatn keresztl adjunk t. Az argumentumok fggvnyhvskor tmsoldnak a stack-re. Nagy mret tmbk, vagy struktrk msolsa hossz ideig tart, rontja a kd hatsfokt. Bizonyos szmtgp architektrknl a stack mrete viszonylag kicsire van korltozva. Ezrt akr egyetlen, nagyobb mret tmb tadsa is stack-tlcsordulst okozhat. A fggvny prototpusok megadsnl az argumentumok tpusai mellett mindig adjuk meg azok neveit is. A nevek megadsa az ANSI-C szabvny szerint nem ktelez, de a funckira utal nevek alkalmazsval a fggvny hasznlata egyszerbben megjegyezhet, a fggvny egyszerbben dokumentlhat. Kerljk a meghatrozatlan (...) paramter-tadst. A meghatrozatlan paramter-tadsra a legismertebb plda a printf() fggvny. A msodik s tovbbi argumentumok szma s tpusa meghatrozatlan. Ebbl fakadan a fordt nem tudja ellenrizni a fggvnyhvs helyessgt, szemantikai hibk elkvetsre nagyobb a lehetsg. Ezrt csak vgs esetben alkalmazzunk meghatrozatlan paramter-tadst.

86

4.2 Visszatrsi rtk Mindg adjuk meg a fggvny visszatrsi rtknek tpust. A tpus hinya a programot rtelmez szmra zavar lehet, mert nem azt jelenti, hogy nincs visszatrsi rtk (void tpus), hanem a fordt alaprtelmezse szerinti int rtket jelent. Tmbket s struktrkat mindig mutatn keresztl adjuk vissza. Az argumentumok tadshoz hasonlan itt is msols trtnik, ami nagy mennyisg adat esetn sokig tart. Sose adjuk vissza valamelyik loklis vltoz cmt. A fggvny visszatrsekor elszr felszabadul a stack-en a loklis vltozk ltal elfoglalt terlet, a vezrls ezutn kerl vissza a hv fggvnyhez. A visszakapott mutat pedg egy rvnytelen (felszabadtott) terletre mutat. Az els mutatmvelet szegmentcis hibt fog okozni. (DOS alatt nem kapunk hibajelzst, csak valamilyen, esetleg vletlenszer rtket, s ez mg rosszabb.) Ha a fggvnyen bell dinamikusan foglalunk memrit a visszatrsi rtknek, akkor ezt egyrtelmen dokumentlni kell. Ilyen esetekben ugyanis a hv fggvnyben kell gondoskodni a memriaterlet felszabadtsrl, amit sok programoz elfelejt. Az eredmny: futs kzben fokozatosan nvekv memriaszksglet, esetleg instabil program. 4.3 Kommentek A nagyobb llegzet, tbb soros megjegyzseket az els oszlopban kell kezdeni, s a magyarzott blokk eltt kell elhelyezni. Az ilyen tpus megjegyzsek ltalban egy nagyobb programrszlet, esetleg egy egsz fggvny mkdst, vagy funkcijt rjk le. A programszveg jobb olvashatsga miatt a megjegyzsnek el kell klnlnie a tbbi szvegtl. Minden fggvny defincijnl ktelez egy ilyen megjegyzsblokk alkalmazsa a kvetkez formban:
/* Feladata: Hasznlatnak elfelttelei: Bemen paramterek: Kimen paramterek (visszatrsi rtk): Egyb paramterek: Hivatkozott globlis vltozk: Hvott fggvnyek: Kszt: Utols mdosts dtuma: */

Az egyes sorok meglte akkor is ktelez, ha adott esetben valamelyikhez nem tartozik semmi. A hasznlat elfeltteleihez tartozik minden olyan elzetes tevkenysg, ami a fggvny megfelel mkdshez szksges. Pl: egy fjl megnyitsa, bizonyos belltsok, vagy valamilyen adatstruktra feltltse. A bemen paramtereknl le kell rni az sszes bemen argumentum funkcijt, lehetsges rtktartomnyt, az egyes argumentumok sszefggseit. A kimen paramterek kztt a visszatrsi rtken kvl az sszes olyan argumentumot -, s azok lehetsges rtktartomnyt - is fel kell tntetni, amelyeket a fggvny megvltoztathat. A hivatkozott globlis vltozknl meg kell adni, hogy mely vltozk rtkt vltoztatja meg a fggvny, s az egyes vltozknl mi az elvrt bemen, ill. kimen rtktartomny. A hvott fggvnyek listjn csak a nem szabvnyos fggvnyeket kell felsorolni. Ez a fordtsi fggsgek knnyebb meghatrozsnl hasznos. A rvd, egysoros megjegyzseket a magyarzott utastssal egy sorba, vagy az utastst kvet sorba kell elhelyezni gy, hogy az utaststl jl elklnljn. Ezek a megjegyzsek egy fontos, esetleg bonyolult utastst magyarznak. Amennyiben az utasts s a magyarzat olyan rvd, hogy elfrnek egy sorban, akkor minimum 8-10 helykzt kell kztk 87

hagyni. Ha az utasts vagy a megjegyzs hossza nem teszi lehetv az egy sorba rst, akkor a megjegyzst a kvetkez sorban kell kezdeni egy plussz bekezdsnyivel az utaststl beljebb. Ilyenkor a megjegyzs utn res sort kell hagyni, s a kvetkez utasts csak az res sor utn kvetkezhet. A megjegyzsnek mindig jl el kell klnlnie az utastsoktl, klnben rontja az olvashatsgot, s az ellenkez hatst ri el, mint amire szntk. A megjegyzsnek azokat a dolgokat kell magyarzni, amelyek nem ltszanak, pl. mi a jelentse egy felttelnek, mikor, vagy mitl kvetkezhet be. A trivilis dolgok kommentezse hiba.
Plda: FontosFuggveny( ElsoParameter, MasodikParameter ); /* Ez itt a hozzatartozo megjegyzes */ Utasitas(); /* Rovid megjegyzes */

4.4 rsmd A fggvny visszatrsi rtknek tpust a prototpust (vagy fejlcet) megelz sorba kell rni. gy a fggvny neve kerlhet a sor elejre, a fggvnyt knnyebb lesz megtallni. Ha a fggvnynek olyan sok argumentuma van, hogy nem frnek ki egy sorba, akkor minden argumentum nevt a tpusval egytt egy bekezdssel j sorba kell rni. A paramterek gy jl elklnlnek egymstl, a sorrendjk is jl kvethet.
Plda: int Fuggvenynev( int ElsoParameter, char *MasodikParameter, float HarmadikParameter );

5. Konstansok
A programszvegben mindig szimblikus konstansokat hasznljunk. Ennek egyik oka, hogy a program rtelmezse nagyon nehzkess, szls esetben szinte lehetetlenn vlik. Minden egyes elfordulst megjegyzssel kellene elltni, s mint lttuk, a sok komment szintn rontja az olvashatsgot. A msik ok, hogy ha egy konstans tbbszr is elfordul egy programban, s ksbb meg kell vltoztatni az rtkt, akkor vgig kell bogarszni a teljes forrsszveget, - esetleg tbb fjlt is -, hogy megtalljuk s kicserljk az sszes elfordulst. Ha csak egy-kt helyen elfelejtjk trni a konstans rtket, az "katasztrfhoz" is vezethet. Az egyszer, automatikus keres-cserl nem alkalmas, mert lehet, hogy szerepel ugyanilyen rtk ms funkcival. Szimblikus konstansok esetn az rtket csak egy helyen - a konstans defincinl - kell megvltoztatni. A szably all csak az egyedi szvegkonstansok s a 0, 1, -1 szmrtkek jelenthetnek kivtelt. A szvegkonstansok nagy rsze csak egyszer fordul el a forrsszvegben, s viszonylag hossz, ezekre flsleges szimblummal hivatkozni. A 0, 1, -1 rtkek jelentse pedg ltalban vilgos, ha mgsem, akkor ezeket is lehet szimblikusan megadni, vagy megjegyzseket alkalmazni. A konstansokat a #define helyett lehetleg a const vagy az enum hasznlatval definiljuk. A makrkat fordtskor szvegbehelyettestssel rtelmezi az elfordt. Ezrt a lefordtott binris fjlban mr semmi sem utal a konstans nevre. A legtbb debugger nem tudja megjelenteni az ilyen konstansok nevt, csak az rtke fog szerepelni a megfelel helyeken. Ha egyszerre tbb, sszetartoz konstanst szeretnnk definilni, akkor hasznljuk az enum konstrukcit. Ha mgis a #define-t hasznljuk, akkor gyeljnk arra, hogy a negatv szmokat mindig tegyk zrjelek kz, ezzel cskkenthetjk a mellkhatsok szmt s valsznsgt.
Pldul (ilyet ne): #define HETFO #define KEDD . . 1 2

88

#define VASARNAP 7 #define SZORZO -3 Inkbb: enum NAPOK { HETFO = 1, KEDD, SZERDA, CSUTORTOK, PENTEK, SZOMBAT, VASARNAP }; #define SZORZO (-3)

Sose hasznljunk olyan makrfggvnyt, amelyben az argumentumokra egynl tbb hivatkozs van. A makrfggvnyeket nagyon vatosan kell kezelni, mert gynevezett mellkhatsok lphetnek fel, s esetleg a fggvny sem azt az eredmnyt szolgltatja, amit elvrnnk tle.
Pldul: #include<stdio.h> #define NEGYZET( a ) ( (a) * (a) ) void main( void ) { int szam = 2; printf( "szam=%d, ", szam ); /* szam = 2 */ printf( "NEGYZET( ++szam )=%d, ", NEGYZET( ++szam ) ); /* ++2 = 3, NEGYZET( 3 ) = 9, NEGYZET( ++szam ) = 16 !!! */ printf( "szam=%d\n", szam ); /* szam = 4 */ }

6. Vltozk
A vltozkat a lehet legkisebb hatskrrel deklarljuk. Ez nveli a kd olvashatsgt, cskkenti a nvtkzs lehetsgt, s cskkenti a program memriaignyt, bizonyos esetekben mg a futsi sebessget is javtja. Ha egy vltoz deklarcija s hasznlata egymstl tvol esik, akkor nehz a vltoz tpusnak megllaptsa, elre-htra kell lapozni a szvegben. A nvtkzs nem okoz szintaktikai hibt, mert a kisebb hatskr vltoz az adott blokkban elfedi a nagyobb hatskr vltozt. Ebbl szemantikai hiba addhat, flrertst okozhat. Ha egy vltozt egy fggvny elejn deklarlunk, s csak egy feltteles blokkban hasznlunk, akkor a vltoznak szksges hely abban az esetben is lefoglaldik, majd felszabadtdik, ha a blokk vgre sem hajtdik. A program futsa gyorsthat azltal, ha a vltozt csak a feltteles blokk elejn deklarljuk. Minden vltozt kln sorban deklarljunk. Az olvashatsg jobb lesz, az adott vltoz funkcijra utal megjegyzs a deklarcival egy sorba rhat. Ez vonatkozik a struktrk s az unik mezinek deklarlsra is. Mutatk hasznlatnl gyelni kell, hogy az els rtkads mindig elzze meg az els hivatkozst. A mutatk a tbbi vltozhoz hasonlan deklarcikor 0-ra vagy sehogyan sem inicializldnak. Amikor egy ilyen mutatra hivatkozunk, biztos a Segmentation Fault, vagy valamilyen hasonl futsi hibazenet. Bvebben lsd a Memria kezels fejezetet.

89

7. Vezrlsi szerkezetek
A feltteles blokkok, ciklusmagok rsmdja: A blokkot nyit kapcsos zrjelet '{' a feltteles utastssal egy oszlopba, de az azt kzvetlenl kvet sorba kell rni. A blokkot zr kapcsos zrjel '}' szintn ebben az oszlopba kell hogy kerljn. A blokkban szerepl sszes utasts egy bekezdssel (2, 4 karakter, de mindig azonos) beljebb kerl. Ha egy utasts nem fr ki egy sorba, akkor a kvetkez sorban mg egy bekezdssel beljebb kell folytatni. Amennyiben mg ez sem elg, akkor a kvetkez sorokban mr nem kell jabb bekezdst tenni. Ez all csak a hossz szvegkonstansok jelentenek kivtelt, ahol a bekezds helykz karakterei is a szveg rszt kpeznk. Minden tbb sorba rt utasts utn clszer egy res sort hagyni, hogy a kvetkez utasts jl elklnljn.
Pldul: if ( feltetel ) { EzEgySokParameteresFuggveny( ElsoParameter, MasodikParameter, HarmadikParameter ); printf( "Ez itt egy nagyon hossz szvegkonstans, amit\ muszly tbb sorba rni, ezrt a sorok elejn csak egy\ helykz hagyhat.\n" ); } else { Ut1; . . }

Ha egy blokk hosszabb, mint egy kpernyoldal, vagy tbb blokk van egymsba gyazva gy, hogy a blokkok vge nagyon kzel van egymshoz, akkor a zr }-hez megjegyzst kell rni. A bekezdsekbl ugyan ltszani kell, hogy melyik } melyik blokk vgt jelzi, de hossz blokkok esetn sokat kell elre-htra lapozni a szvegben, hogy megtalljuk a prokat. A megjegyzsben feltntetve a felttelt, vagy a ciklus utasts els sort sokat segthet a megrtsben, s jobb teszi az ttekinthetsget. Ez a szably vonatkozik az elfordt direktvk hasznlatra is. (#ifndef ... #endif)
Pldul: switch( szelektor ) { case FEL: { Utasitasok; break; } /* FEL */ case LE: { Utasitasok; break; } /* LE */ default: { Hiba; break; } /* default */ } /* switch( szelektor ) */ vagy

90

for( index = 0; index < MERET; index++ ) { Ciklusmag; } /* for( index = 0; index < MERET; index++ ) */

A switch kifejezsben mindig legyen default g a vratlan esetek kezelsre. Ennek az gnak elegend valamilyen egyszer hibazenetet tartalmaznia, esetleg exit utastssal kilpni a programbl. Ez mg mindig jobb, mintha a program zavartalanul fut tovbb valamilyen jelzs nlkli szemantikai hibval. A case gak vgnl mindig gondoljunk vgig, szksges-e a break utasts! A break hinyban a program futsa a kvtkez case gon folytatdik mindaddig, amg az els break-hez, return-hz, vagy a switch kifejezs vgre nem r a program futsa. A program ltszlag hiba nlkl fut, mgis szemantikailag rtelmetlen eredmnyeket szolgltathat. Nehezen kiderthet hiba. A goto utasts hasznlata szigoran TILOS !!! A goto megtri a program futst s az elrelthatatlan helyen fut tovbb. A program futsa kvethetetlenn vlik. Msrszt a C nyelv olyan vltozatos ciklusokat, vezrlsi szerkezeteket tesz lehetv, hogy nincs is szksg a goto hasznlatra. A continue, break utastsokkal a ciklusok s feltteles blokkok vgrehajtsa knnyedn megszakthat, a futs mgis ttekinthet marad, mert az mindig a blokkban els, illetve a blokkot kvet els utastson folytatdik. A ciklusokbl val kilpsre flag-ek helyett a break utastst hasznljuk. Ezltal egyszersdik a ciklus vgrehajtsi felttele, egy vltozval kevesebbet kell hasznlni, s a program is ttekinthetbb lesz.
Pldul (ilyet ne): int flag = 0; for( index = 0; index < HATAR && !flag; index++ ) { Utasitasok1; if ( feltetel ) flag = 1; Utasitasok2; } Inkbb: for( index = 0; index < HATAR; index++ ) { Utasitasok; if ( feltetel ) break; }

Felttelek megadsakor (ha csak az algoritmus nem r el kifejezetten mst) hasznljunk alul zrt, fell nyitott halmazokat. Az x>=20 s x<=50 helyett hasznljuk a x>=20 s x<51 formt. Ennek tbb elnye is van: Az intervallum mrete megegyezik a hatrok klnbsgvel. A hatrok egyenlek res intervallum esetn. A fels hatr sosem kisebb az als hatrnl.

8. Kifejezsek
Helykzk hasznlata: ltalnos elv, hogy mindig az ttekinthetsget s az olvashatsgot kell szemeltt tartani. Mindg helykzt kell tenni: az unris (egyoperandus) operttorok ('.', '->', '++', '--', ...) kivtelvel minden opertor el s mg; a vessz utn;

91

 a pontosvessz s a magyarzat kzz; a ()-be s []-be zrt kifejezs el s mg kivve, ha az res, vagy csak egy tag; az if utasts s a nyit zrjel kz. Sosem szabad helyzzt tenni: vessz s pontosvessz el; az unris opertorok s az operandusuk kz; a ciklus utasts, vagy a fggvny neve s a nyit zrjel kz; a tmb neve s a nyit szgletes zrjel kz. Ha egy kifejezs kirtkelsi sorrendje nem trivilis, akkor hasznljunk zrjeleket, mg abban az esetben is, ha a fordt szempontjbl flslegesek. Kevsb gyakorlott programozknak nehzsget jelenthet egy sszetett kifejezs megfelel rtelmezse. A zrjelek hasznlatval ez egyszersthet. Msrszt, a fordt nem mindent a matematikban megszokott rtelmezs szerint fordt le. Ezeket az eseteket is egyrtelmv lehet tenni zrjelek alkalmazsval.
Pldul: a < b < c a & b < 8 a++ - ++a-/* ( a < b ) < c s nem ( a < b ) && ( b < c ) */ /* a & ( b < 8 ) s nem ( a & b ) < 8 */ /* Mit is jelent ez ??? */

Egy hossz kifejezs tbb sorba is rhat, ilyenkor az j sort mindig egy bekezdssel beljebb kell kezdeni gy, hogy az opertor (kivve a zr zrjelet) a kvetkez sorba kerljn. Mindig a szveg ttekinthetsgre kell trekedni. Az ilyen, tbbsoros kifejezsek utn egy res sort kell hagyni, gy az egyes kifejezsek, illetve utastsok elklnlnek egymstl.

9. Memria kezels
A lefoglaland mret kiszmtsnl mindig hasznljuk a sizeof makrt. Akr egyedi vltoznak, akr tmbnek foglalunk helyet, mindenkppen elnys a sizeof makr hasznlata. Ha struktrnak, vagy struktratmbnek akarunk memrit foglalni, s a fejleszts sorn megvltozik annak mrete, - pl. j mezk hozzadsa, - akkor sem kell a folgalalsi rszt mdostani, mert az automatikusan kvetni fogja a mretvltozst. Elemi tpusok - pl. int - is hasznos a sizeof hasznlata, mert gy jobban hordozhat lesz a program. Egy adott blokk felszabadtsa lehet legkzelebb kerljn a blokk lefoglalshoz. Ezltal kisebb az esly, hogy a blokk felszabadtatlanul marad, s jobban nyomonkvethet a lefoglals/felszabadts menete. Minden blokk lefoglalst ellenrizzk. A malloc s rokonai NULL-lal trnek vissza sikertelen foglals esetn. Amennyiben ezt nem ellenrizzk, a mutatra val els hivatkozs Segmentation Fault futsi hibhoz fog vezetni. (DOS alatt ilyen nincs. Sajnos !) Ellenrztt foglalssal ez elkerlhet. Sorozatos helyfoglalsnl minnl nagyobb blokkokat foglaljunk le. Dinamikus tmbk, vagy lncolt listk kezelsnl - kivve, ha egy elem mrete meghaladja a 100150 bjtot - ne egyesvel, hanem minimum 50-100 bjtos darabokban foglaljuk le a memrit. Ennek az az oka, hogy az opercis rendszerek nem "szeretik" a sok, apr blokkot, lelassulhatnak a memriamveletek, s egyb kros esemnyek trtnhetnek. Egy blokk felszabadtsa utn a mutatjnak adjunk NULL rtket. Ezltal a programban brhol ellenrizhetv vlik, hogy a mutat hasznlhat terletre mutat-e, vagy egy hasznlaton kvli mutat-e. Ennek szintn a Segmentation Fault hiba elkerlsnl van jelentsge.

92

Amennyiben egy fggvnyben dinamikus memriakezels van, azt a fggvny fejrsznl lv megjegyzsben egyrtelmen jelezni kell. gy cskkenthet az esly arra, hogy a blokk felszabadtatlan marad.

10. Hordozhatsg
Semmilyen felttelezst ne tegynk a tpusok mretre, vagy eljelre vonatkozan. Klnbz fordtk, klnbz opercis rendszerek ms-ms mrettel kezelik az egyes tpusokat. Az ebbl add hibk elkerlsre mindig hasznljuk a sizeof makrt, valamint a long s a short tpusmdostt. Hasonl a helyzet az eljelessggel is. A char tpust bizonyos fordtk eljelesnek, msok eljel nlklinek tekintik. Ezrt 8 bites ASCII rtket trol vltozk deklarcijnl mindig hasznljuk az unsigned tpusmdostt. Amikor tpuskonverzira van szksg az explicit konverzit rszestsk elnyben az implicittel szemben. Ez klnsen a numerikus tpusoknl szvlelend meg, mert klnbz architektrknl esetleg nem az az automatikus konverzi kvetkezik be, mint amit feltteleztnk, s gy hibs eredmnyt adhat a kifejezs. Ne rjunk olyan kdot, amelynek a mkdse valamelyik vltoz tl- vagy alulcsordulstl fgg. Ms-ms architektrkon ms-ms lehet egy adott tpus vltozban trolhat maximlis illetve minimlis rtk, ezrt a tl- illetve alulcsorduls is ms rtknl kvetkezhet be, ami a program hibs mkdshez vezethet. Nehezen kiderthet hiba! Ne ttelezznk fel egy adott vgrehajtsi sorrendet egy kifejezsen bell. A vgrehajtsi sorrendet az optimalizl fordtk trendezik. Mindegyik fordt mskppen. A tnyleges sorrendet pedig nem tudjuk megllaptani. Ezekben az esetekben a zrjelezs segthet. Ne ttelezzk fel, hogy a fggvnyhvsban az argumentumok a prototpusnl megadott sorrendben addnak t. Az elz pontban mondottak itt is rvnyesek. Az tads sorrendje fordtfgg. Ez leginkbb a mellkhatsok kihasznlsnl vezethet hibs mkdshez. Ennek elkerlsre fggvnyhvsokban tbb, egymssal kzvetlen kapcsolatban lv argumentum esetn semmilyen mellkhatst eredmnyez kifejezst se hasznljunk.

A fenti dokumentum az ELLEMTEL Telecommunication Systems Laboratories Sweden Programming in C++ Rules and Recommendations cm angol nyelv dokumentum C nyelvre adaptlsa s tdolgozsa. Az erdeti dokumentum ri: Mats Henricson s Erik Nyquist. Angolra fordtotta: Joseph Supanich. A C nyelvre adaptlst s a magyar nyelvre fordtst ksztette: Straub Kornl. Ellenrizte: Ficsor Lajos Utols mdosts: 1999. mrcius 20.

93