Programozás | C / C++ » Bevezetés a Borland C++ programozásba

Tartalomjegyz
ek 1. C programozas a BORLAND C++-ban 1.1 Alapismeretek 1.2 A valtozok alaptpusai 1.21 A karakter tpus es a sztringek 1.22 Az egesz tpusok 1.23 A felsorolt tpus 1.24 Amit a logikai tpusrol tudni kell a C-ben 1.25 A lebeg}opontos valos szamok tpusai 1.26 A mutato tpusok 1.3 Az el}ofeldolgozo 1.31 Szimbolumok es makrok 1.32 Felteteles fordtas 1.33 El}oredenialt szimbolumok 1.34 File-beeptes 1.35 Implementacio-fugg}o vezerl}osorok 1.4 Tarolasi osztalyok, hataskorok 1.41 Modulok, blokkok 1.42 Fuggvenyek tarolasi osztalyai 1.43 Valtozok elettartama es hataskore 1.44 Egyszer}u adatdeklaratorok

1.45 Fuggvenyek dencioja es deklaracioja 1.46 Modosto jelz}ok 1.47 Tpusdenialo (typedef) azonostok 1.5 Kifejezesek 1.51 Els}odleges kifejezesek 1.52 Operatorok 1.6 Konverziok 1.61 A konverzio a char, az int es az enum tpusok kozott 1.62 Konverzio mutatok kozott 1.63 Aritmetikai konverziok 1.7 Utastasok 1.71 Kifejezes-utastasok 1.72 A felteteles utastas 1.73 Ciklusszervez}o utastasok 1.74 Egyeb vezerlesatado utastasok 1.8 Strukturak es unionok 1.81 Strukturak megadasa 1.82 Hivatkozas struktura elemekre i . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . 1 2 3 4 5 6 6 7 7 9 9 12 13 14 15 16 16 16 16 18 20 23 25 27 27 28 34 34 35 35 35 36 37 38 40 42 42 44 TARTALOMJEGYZE
K ii 1.83 A bitmez}ok 1.84 A union fogalma 1.9 Mutatok es tombok 1.91 A mutatok hasznalata 1.92 E rtekadas mutatoknak 1.93 Mutatok fuggvenyparameterkent 1.94 Pointer aritmetika 1.95 Tombok hasznalata Tobbdimenzios tombok 1.96 Kapcsolat tombok es mutatok kozott 1.97 A ltalanos mutatok 1.98 Fuggvenyekre mutato pointerek 1.10 Bevitel es kivitel 1.101 Alacsony szint}u I/O 1.102 Folyam jelleg}u I/O 1.11 A main fuggveny 1.12 Tovabbi magyarazatok 1.121 A balertek es jobbertek fogalma 1.122 Meg egyszer a deklaraciokrol es a tpusokrol 1.123

Fuggvenyek valtozo szamu parameterrel  1.13 Osszetett mintapelda . 1.131 A tervezes egyes fazisai 1.132 A menukezel}o rendszer listaja 2. Programozas C++-ban . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.1 U j elemek a C++-ban 2.11 Alternatvak a #define direktva helyett 2.12 Cm szerint nyilvantartott tpusu, vagy referencia tpusu valtozok . 2.13 Inicializalt fuggvenyparameterek 2.14 C ++ kommentek 2.2 Az OOP alapjai 2.3 Egysegbezaras  okles . 2.4 Or 2.5

Tobbret}useg (polimorzmus) 2.6 Fuggvenymez}ok denialasa 2.61 Fuggvenymez}ok aktivizalasa 2.62 A this nev}u, implicit mutato 2.7 Konstruktorok es destruktorok 2.71 Konstruktorok denialasa 2.72 Destruktorok denialasa 2.8 Mez}ohozzaferes 2.81 Mez}ohozzaferesi szintek 2.82 Mez}ohozzaferes es orokles 2.9 Virtualis fuggvenyek 2.91 Kes}oi osszerendeles 2.92 Virtualis fuggvenyek deklaralasa 2.10 Dinamikus objektumok 2.101 Dinamikus objektumok letrehozasa 2.102 Dinamikus objektumok megszuntetese 2.11 Tovabbi exibilitas a C++-ban 44 45 46 47 49 50 51 53 54 56 57 57 58 58 64 65 65 66 67 68 69 75 93 94 94 95 98 99 99 100 101

104 106 108 108 109 110 111 112 113 114 115 115 118 119 119 120 120 iii 2.111 Rokonok es baratok 120 2.112 Operator overloading 122 2.12 C++ I/O konyvtarak 122 A. Include le-ok es fuggvenyek A.1 Fontosabb konyvtari fuggvenyek A.11 Fuggvenyek szoveges uzemmodban A.12 Hangeektusok letrehozasa A.13 Fuggvenyek grakus uzemmodban A.14 A ltalanos konyvtari fuggvenyek Irodalomjegyzek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 125 125 131 132 157 197 1. fejezet C programoz
as a BORLAND C++-ban A BORLAND C++ rendszer az ANSI szabvanyajanlasnak megfelel}o, korszer}u, sok hasznos szolgaltatast nyujto C nyelvi implementacio. Ismertetesunk soran igyekeztunk kerulni a nyelv formalis denciojat, inkabb szavakba ontve, peldakon keresztul probaltuk azt

bemutatni. A nyelv bemutatasat az ANSI C, illetve annak a BORLAND C++-beli implementaciojanak ismertetesevel kezdjuk. A 2. fejezet foglalkozik a nyelv objektum-orientalt vonasainak a targyalasaval A BORLAND C++ rendszer konyvtari fuggvenyeinek rovid lerasat az A.1 fuggelek tartalmazza Konyvunk masodik kotete azzal foglalkozik, milyen modon hasznalhato a BORLAND C++ rendszer MS-Windows alkalmazoi programok fejlesztesere. Ha az Olvaso az egyes C nyelvi elemek precz lerasa irant erdekl}odik, akkor a legels}o es legfontosabb C nyelvi referenciat, B. W Kernighan es D M Ritchie konyvenek 1]. A fuggeleket ajanljuk tanulmanyozasra A nyelv BORLAND C++ implementacoval kapcsolatos reszleteit az eredeti programdokumentacio vonatkozo kotetei 2], 3] tartalmazzak. Kulon erenye a programdokumentacio ezen koteteinek, hogy kiternek a portabilitasi kerdesekre is. Megadunk itt egy egyszer}u kis peldaprogramot, amelyre kes}obb

tobbszor is hivatkozni fogunk, javasolva, hogy az Olvaso lepjen be a a BORLAND C++ integralt fejleszt}oi kornyezetebe es gepelje be a programot, majd fordtsa le es probalja is ki. A program funkcioja, hogy ENTER-rel lezart sorokat ker be a felhasznalotol, es azokat ugy rja vissza a keperny}ore, hogy a kisbet}uket a nagybet}us parjukkal, a nagybet}uket pedig a megfelel}o kisbet}uvel helyettesti. A programbol kilepni CTRL-Z billenty}uleutest tartalmazo sor berasaval lehet. Meg kell jegyeznunk, hogy nyomdatechnikai okokbol a szovegben talalhato programlistak magyar nyelv}u megjegyezseib}ol hianyoznak az ekezetek. Ezert a kellemetlensegert az Olvaso elnezeset kerjuk. /* * File: pelda.c * * Tartalom: Kisbetu-nagybetu felcserelo mintaprogram * */ #include <stdio.h> #include <ctype.h> 1
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 2 /* A modulban definialt fuggvenyek: void main(void) /*

======================================================== void main() { register c while ((c = getchar()) != EOF) { /* c-be olvasunk, file vegeig if (isupper(c)) /* Ha nagybetu, akkor. { c = tolower(c) /* . kisbeture csereljuk, } else /* . egyebkent pedig { c = toupper(c) /* . nagybeture csereljuk } /* . Az if utasitas vege putchar(c) /* A megvaltoztatott c-t kiirjuk } /* . A while ciklus vege } /* . A main blokk vege */ */ */ */ */ */ */ */ */ */ */ 1.1 Alapismeretek A C programutastasokat kotetlen formatumban rhatjuk. Ez azt jelenti, hogy { az el}ofeldolgozonak szolo utastasokat kiveve, lasd ott { a C nyelv sorfuggetlen, azaz egy sorba tobb utastas is rhato, illetve egy utastas tobb sorba is torhet}o. A ltalanos erveny}u szabaly, hogy ahol egy szokoz allhat, ott tetsz}oleges szamu { legalabb egy { tetsz}oleges szokozjelleg}u karakter (un. whitespace) is allhat. Szokozjelleg}u karakter a szokoz, a tabulator es az ujsor karakter,

illetve ilyen funkcioju a megjegyzes (comment) is. A megjegyzesek /* karakterkombinacioval kezd}od}o es / kombinacioval lezart, tetszes szerinti karaktersorozatok. Ennek alapjan a pelda.c forrasprogram alabbi ket sorat void main() { a kovetkez}o formaban is rhattuk volna: main() void { /* komment / Modulnak nevezunk egy onalloan fordthato forrasnyelvi egyseget. Az operacios rendszer szintjen a modul onallo le-kent jelentkezik A C forrasmodulokat hagyomanyosan .c kiterjesztes}u le-okban helyezzuk el, kiveve az un include le-okat (header les, illetve fejlecle-ok), amelyek h kiterjesztest kapnak A C programok egy, vagy tobb modulbol epulnek fel, a pelda.c egymodulos program Ha egy tobbmodulos programban csak az egyik modulhoz tartozo forrasle-t modostjuk, akkor elegend}o csupan azt ujrafordtani, majd a tobbi modullal { es a megfelel}o modulkonyvtarakkal { ujraszerkeszteni. A kulonallo modulok forrasnyelvi

szinten deklaraciokon keresztul tartjak egymassal a kapcsolatot, amelyeket celszer}uen include le-okba foglalunk.

ALAPT
IPUSAI 1.2 A VALTOZ OK 3 A modulok fordtasvezerl}o utastasokbol, valtozo- es fuggveny-deklaraciokbol/denciokbol allnak. Az egyes tarolasi egysegek lehetnek kodgeneralok (ezekbe helyezzuk a vegrehajthato utastasokat), es lehetnek tarterulet foglalok (adatok, valtozok) A kodgeneralo tarolasi egysegeket a C nyelvben altalanosan fuggvenyeknek nevezzuk (szemben mas programozasi nyelvekkel, ahol kulonbseget tesznek a function es a procedure, illetve subroutine kozott). Egy tarolasi egyseg deklaracioja kozli a fordtoprogrammal az adott egyseg jellemz}oit, de nem jar egyutt tarterulet foglalassal, az mashol (esetleg mas modulban) tortenik meg. A deklaraciot kovet}oen az adott tarolasi egyseget a fordto az adott tulajdonsagokkal rendelkez}o, letez}o egysegnek tetelezi

fel (ha egy deklaraciohoz sehol sem tartozik megfelel}o dencio, akkor a szerkesztes alkalmaval hibauzenetet kapunk). Ugyanazt a tarolasi egyseget tobbszor is deklaralhatjuk egy forrasallomanyban mindaddig, amg az egymast kovet}o deklaraciok osszhangban vannak egymassal. Egy tarolasi egyseg denciojakor tortenik meg az adott egyseg tenyleges elhelyezese Tarterulet-foglalo tarolasi egyseg eseten lefoglalasra kerul a szukseges adatterulet, mg kodgeneralo egyseg eseten az adott utastasokat fordtja le es helyezi el a fordto program. (Itt adjuk meg a programunk vegrehajthato utastasait). Egy dencio ertelemszer}uen deklaracio ertek}u is, kiveve a kodgeneralo-egysegek (fuggvenyek) dencioit, melyeket nem tekint teljes ertek}u deklaracionak a C fordto. Ezert celszer}u minden forrasmodul elejen elhelyezni az adott modulban denialando fuggvenyek teljes deklaraciojat (void main(void) sor a

pelda.c-ben), ez egyben j ol felhasznalhato dokumentalasra is. Ugyanannak a tarolasi egysegnek termeszetesen { a programhoz tartozo osszes modult gyelembe veve { kizarolag egy helyen lehet dencioja (ezert "illetlenseg" include le-ba denciot helyezni). A felhasznalo azonostas celjabol a tarolasi egysegekhez azonostokat (identier) rendel. A C-ben az azonosto bet}uvel kezd}od}o, bet}uvel es/vagy szamjeggyel folytatodo karaktersorozat. A kis- es nagybet}uk kulonboz}onek szamtanak (alfa, AlfA) Bet} unek tekintjuk az angol ABC bet}uin (a{z, A{Z) kvul az alahuzas karaktert ( ) is, szamjegyek a szokasos 0{9 karakterek. Az azonostok hoszszara nincs megkotes, de a BORLAND C++ fordto csak az els}o 32 karaktert veszi gyelembe (mas ertek is beallthato az Options menuben). Javasoljuk, hogy a tarolasi egysegek elnevezesere hasznaljunk csupa kisbet}ut tartalmazo azonostokat, es ne kezdjuk sajat

azonostoinkat alahuzas karakterrel. 1.2 A valtozok alaptpusai Ebben a reszben a tarterulet foglalo tarolasi egysegekkel foglalkozunk reszletesebben. A tovabbiakban az azonostoval ellatott tarterulet foglalo egysegeket roviden valtozoknak nevezzuk. A valtozok tpusa meghatarozza az elfoglalt tarterulet nagysagat, az operatorokhoz tartozo gepi utastas(sorozat)okat, stb. A BORLAND C++ a kovetkez}o, tovabb mar nem bonthato, elemi tpusokkal rendelkezik:
karakter,
egeszek (tobbfele meret es abr azolasmod),
lebeg} opontos (tobbfele pontossag),
mutato (pointer).
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 4 C-beli jeloles na nb nf nn nr nt nv nn n n" n? nooo nxhhh Karakter Magyarazat (BEL) (BS) (FF) (LF) (CR) (HT) (VT) (n) () (") (?) cseng}o karakter visszaleptetes lapdobas ujsor (soremeles) kocsi vissza vzszintes tabulator (vagy maskeppen: fugg}oleges tabulator maga a backslash karakter

egyszeres idez}ojel (apostrophe) dupla idez}ojel kerd}ojel a ooo oktalis kodu katkter a hhh hexadecimalis kodu karakter TAB) 1.1 tablazat Backslash-szekvenciakkal megadhato karakterek Ezeket az alaptpusokat azutan { a kes}obbiekben lert modokon { ept}okovekkent felhasznalhatjuk un. szarmaztatott tpusok kepzesehez, illetve bonyolultabb aggregatumok (tombok, strukturak, unionok, stb) feleptesehez A kulonfele egeszeket es a karaktertpust osszefoglalo neven sorszamozott tpusnak nevezzuk. (A sorszamozott tpus osszefoglalo elnevezest a magyar nyelv}u C szakirodalom (peldaul 1]), integralis tpusnak (integral type) nevezi. A fogalmi hasonlosag, es a magyarosabb hangzas miatt megtartottuk a Pascal nyelvvel kapcsolatban altalanosan hasznalt terminologiat, a sorszamozott tpus elnevezest) 1.21 A karakter tpus es a sztringek A karakter tpusu valtozo egy karakter tarolasara alkalmas. A BORLAND C++

fordto { az MS-DOS operacios rendszerrel osszhangban { a karaktereket az ASCII tabla szerint kodolja. A karakterallandok megadasa egyszeres idez}ojelek kozott tortenik, peldaul A, (, stb. Lehet}oseg van bizonyos nem lathato karakterek abrazolasara a backslash karakter segtsegevel. Ezeket a 11 tablazatban foglatuk ossze. A karakterlancok (sztringek) a C nyelvben nem alaptpusok, hanem karaktertombokben abrazoljuk }oket. Mivel egy sztring hossza dinamikusan valtozhat, ezert a lefoglalt tarteruletb}ol adott pillanatban csak bizonyos karakterek tartoznak tenylegesen a karakterlanchoz. A problemat ugy oldottak fel, hogy a karakterkeszlet egyik elemet kijeloltek arra a specialis funkciora, hogy a sztringek veget jelezze, ily modon tehat ez a karakter maganak a sztringnek soha sem lehet resze. Ez a specialis karakter a n0, azaz a 0 kodu karakter, amit a tovabbikban az EOS szimbolikus neven (End Of String) fogunk hvni. A

sztringallandokat a fordtonak dupla idez}ojelek kozott lehet megadni, peldaul "Hello". Ezt a fordt o ugy ertelmezi, hogy le kell foglalni 5+1 karakternyi (6 byte) helyet a memoriaban, es a kovetkez}o karakterekkel, mint kezd}oertekkel kell feltolteni: H, e, l, l, o, EOS. A sztringben lehetnek backslash-t

ALAPT
IPUSAI 1.2 A VALTOZ OK 5 alkalmazo szekvenciak is, peldaul "Ez egy idezojel: n"nn" ami a memoriaba a kovetkez}okeppen kerul: E, z, , e, g, y, ,i, d, e, z, o, j, e, l, :, , ", LF, EOS. A sztringkonstansok nem nyulhatnak at a kovetkez}o sorba, de lehet }oket egymas utan valo rassal egyesteni (konkatenalni), peldaul: | "Ez egy 2 sorba irt " "sztringkonstans" 1.22 Az egesz tpusok Az egesz tpusu valtozok meret es ertelmezes szerint tobbfelek lehetnek. Meret szerint a BORLAND C++ megkulonboztet rovid (short int) es hosszu (long int) eg eszeket, az

el}obbieket 16, az utobbiakat 32 biten abrazolja. Ha nem specikaljuk az egesz tpusu valtozo meretet, hanem csak int-et adunk meg, akkor minden C fordto tobbe-kevesbe onkenyesen valasztja azt meg, a BORLAND C++ peldaul 16 bites hosszat vesz fel. Ha ki akarjuk hasznalni a C nyelvben rejl}o portabilitasi kepesseget, akkor mindig hasznaljunk explicit meretmegadast, az alabbi negy eset kivetelevel:
register t arolasi osztalyu egeszeknel,
fuggveny altal visszaadott egeszeknel,
egesz tpusu fuggvenyparameter denciojanal,
ha egy konyvtari fuggveny meghatarozatlan meret}u egeszre mutato pointert var. Ezeket a fuggvenyhvasokat minden uj implementacional gondosan meg kell vizsgalni, osszevetve a gyelembe veend}o C rendszer deklaracioival Az el}obbi kivetelek magyarazatat termeszetesen megadjuk a megfelel}o helyeken. Ezekben az esetekben azonban a programozo felel}ossege, hogy a meretmegadas

nelkul felvett valtozot lgfeljebb 16 bit hosszukent kezelje (ennel kisebb hosszat int-re egyetlen komoly C fordto sem vesz fel). E rtelmezes szerint az egeszek lehetnek el}ojelesek (signed int) es el}ojel nelkuliek (unsigned int). Ha nem rjuk el}o az ertelmezest, akkor a fordto el}ojeles egeszt vesz fel. Ily modon peldaul a short int tpusu valtozok -32768 es 32767 kozott, az unsigned short int tpusuak pedig 0 es 65535 kozott vehetnek fel erteket. Itt jegyezzuk meg, hogy a char tpuson belul is letezik unsigned char, ez akkor lenyeges, ha a szabvanyos ASCII keszlett}ol elter}o erteket kvanunk benne tarolni. Ekkor a char ugy tekinthet}o, mint egy 8 bites egesz tpus, -128 es 127 illetve 0 es 255 kozotti ertekekkel. Fontos tudnivalo, hogy a BORLAND C++ a karakteres tpussal valo barmilyen m}uveletvegzes el}ott (aritmetikai, logikai, osszehasonlto, stb. m}uvelet) azt 16 bitre terjeszti ki, gyelembe veve az

ertelmezeset. Igy tehat barmilyen m}uveletvegzes szempontjabol a signed charban tarolt hexadecimalis 80 hexadecimalis FF80-kent lesz gyelembe veve, mg 6
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS az unsigned char-ban tarolt hexadecimalis 80 tenylegesen hexadecimalis 0080nak szamt. Tetelezzuk fel, hogy az alfa valtozo tpusa signed char, a beta valtozoe pedig unsigned char, es mindkett}obe a 128 egesz erteket rjuk. Ha alfa-t ezut an osszehasonltjuk 128-cal, akkor hamis logikai erteket kapunk, mg beta-t  osszehasonltva vele, igazat! S}ot, alfa sem lesz egyenl}o beta-val. Az egesz tpusu konstansokat decimalisan, oktalisan es hexadecimalisan is megadhatjuk. Az oktalis konstansok kotelez}oen 0-val kezd}odnek, a hexadecimalisak pedig 0x, vagy 0X el}otaggal (prex-szel) Peldaul 255 = 0377 = 0xFF A konstansokhoz is rendel meretet es ertelmezest a fordtoprogram. A szabaly az a BORLAND C++-ban, hogy a meret mindaddig

16 bit, amg ennyi bittel a megadott szam abrazolhato, azon felul 32 bites az abrazolas. Az ertelmezes decimalis konstansokra el}ojeles, a tobbire el}ojel nelkuli. Peldaul a 40000 el}ojeles egesz konstans, merete 32 bit (mert 16 biten a legnagyobb el}ojeles szam a 32767), de 0x89A0 el}ojel nelkuli 16 bites konstans. Lehet}oseg van azonban az l, illetve az L ut otaggal (sux) el}orni egy konstansra a 32 bites tarolast! az u, vagy U utotaggal pedig az el}ojel nelkuli ertelmezest. Peldaul 0L 32 bites el}ojeles, 40000U pedig 16 bites el} ojel nelkuli egesz konstans. 1.23 A felsorolt tpus Szinten egesz ertekeket hasznal az un. felsorolt (enum) tpus is Olyankor hasznaljuk, mikor nem a konkret szamertekek a fontosak, csak az, hogy ket ertek egyenl}o-e vagy sem, illetve melyik kisebb a masiknal. Ilyenkor eleg felsorolni a hasznalni kvant egyedi azonostokat, es a fordtoprogram automatikusan ellatja }oket ertekkel.

Peldaul az enum szin { piros, kek, sarga, zold } deklaracio letrehoz egy szin nev}u felsorolt tpust, amely a fenti egyedeket tartalmazza. Ha alapszin egy, a fenti tpusba tartozo valtozo, akkor van ertelme olyan ertekadasnak, mint peldaul alapszin = sarga, es lehet olyan vizsgalatokat vegezni, hogy az alapszin kek-e vagy sem, illetve nagyobb-e, mint kek (a nagysag szerinti sorrend megegyezik a felsorolasi sorrenddel, a legkisebb van legelol), azaz peldanknal maradva piros < kek < sarga < zold A felsorolt tpus a sorszamozott tpusokkal kompatibilis tpus. 1.24 Amit a logikai tpusrol tudni kell a C-ben A C nyelvben nincs explicit logikai tpus, erre a celra barmelyik sorszamozott alaptpus hasznalhato. A logikai igaz erteket az 1, a hamisat a 0 jelenti Az operatorok kozt vannak logikai jelleg}uek (peldaul az osszehasonlto operatorok), ezek mindig a fenti ket ertek valamelyiket szolgaltatjak eredmenyul.

Ugyanakkor azok az operatorok, illetve utastasok, amelyek logikai jelleg}u erteket varnak (peldaul a felteteles elagaztatas), egy ennel tagabb ertelmezest hasznalnak: a 0 jelenti tovabbra is a hamis logikai erteket, azonban minden mas, nem 0 adatot igaznak fogadnak el.

ALAPT
IPUSAI 1.2 A VALTOZ OK 7 1.25 A lebeg}opontos valos szamok tpusai A lebeg}opontos valos szamok a BORLAND C++-ban haromfele pontossaggal allnak rendelkezesre. A float ertekek 32 biten, a double szamok 64 biten, mg a long double v altozok 80 biten tarolodnak. A pontossag mellett az abrazolhato abszolutertekek is valtoznak (lasd a 1.2 tablazatot) A lebeg}opontos konstansok megadasa a szokasos modon tortenik, a kitev}o jelzesere e es E egyarant hasznalhato. 1.26 A mutato tpusok A mutatok (pointerek) olyan valtozok, amelyek egyes tarolasi egysegek (valtozok vagy fuggvenyek) memoria cmeit tartalmazzak. Az ilyen valtozok tehat

az adott tarolasi egysegre nem kozvetlenul utalnak, hanem kozvetetten (indirekcio). A C nyelv ereje { tobbek kozott { eppen a mutatok kezeleseben es a veluk vegzett m}uveletekben rejlik (lasd kes}obb a 1.9 reszben) Ennek egyik forrasa, hogy a pointer valtozokrol nemcsak annyit tart nyilvan a fordto, hogy ez egy mutato es hogy milyen meret}u (16 vagy 32 bites), de azt is feljegyzi es koveti, hogy a kerdeses valtozo vagy kifejezes milyen tpusra mutat. Ezert valojaban a C nyelvben nincs olyan alaptpus, hogy "mutato tpus", csak olyan tpusok vannak, mint paldaul "mutato egy rovid egeszre", "mutato egy el}ojel nelkuli karakterre", vagy akar "mutato egy olyan mutatora, amelyik egy double ertekkel visszater}o, ket el}ojel nelkuli long parametert varo fuggvenyre mutat". Azt, hogy ez igazabol nem is bonyolult, azzal bizonytjuk, hogy illusztralaskent megadunk egy denciot az

utolso tpusba tartozo dfuncptrs nev}u valtozora: double (*dfuncptrs)(long, long) A fenti peldakbol az is kit}unik, hogy a pointerek tarterulet foglalo es kodgeneralo program egysegekre egyarant mutathatnak. Az el}obbieket adatpointereknek, az utobbiakat kodpointereknek nevezzuk. A mutatok a BORLAND C++ rendszerben { illeszkedve a 8086-os mikroprocesszor feleptesehez { 16, illetve 32 bit hosszuak lehetnek. A 16 bites mutatok neve near pointer, a 32 bitesek pedig tovabbi ket csoportra oszlanak, a far pointerekre es a huge pointerekre Egy near pointerrel legfeljebb 64 Kbyte tarterulet cmezhet}o meg, far es huge pointerrel a teljes 1 Mbyte-os adattar elerhet}o, de far pointerek eseteben a megcmzett tarolasi egyseg (peldaul tomb) merete nem lehet nagyobb, mint 64 Kbyte, mg a huge pointerekre semmilyen megkotes nincs. Ennek megfelel}oen az egyes mutatokkal valo m}uveletvegzes bonyolultsaga es vegrehajtasi ideje a fentiek szerint

rohamosan n}o. Azert, hogy a felhasznalo az adott feladat igenyei szerint optimalis megoldast valaszthasson, a BORLAND C++ hat un memoriamodellt bocsat a felhasznalok rendelkezesere. Ezek a kovetkez}ok:

tiny model: mind az adat-, mind a kodpointerek near tpusuak. Megkotes, hogy az osszes adatnak es programkodnak el kell ferni egy 64 Kbyte-os memoriaszegmensben. Az gy fordtott es szerkesztett programok com tpusuva alakthatok at small model: mind az adat-, mind a kodpointerek near tpusuak. Megkotes, hogy az osszes adatnak el kell ferni egy 64 Kbyte-os memoriaszegmensben, valamint az osszes programkodnak el kell ferni egy masik 64 Kbyte-os szegmensben.
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 8 Tpus unsigned char enum unsigned int short int int unsigned long long float double long double near pointer far pointer Meret (bitben) 8 8 16 16 16 16 32 32 32 64 80 16 32 E rtektartomany Pontossag (decimalis jegyben) 0

. 255 ;128 . 127 ;32768 . 32767 0 . 65535 ;32768 . 32767 ;32768 . 32767 0 . 4294967295 ;2147483648 . 2147483647 3:4  10;38 . 3:4  1038 7 1:7  10;308 . 1:7  10308 15 3:4  10;4932 . 1:1  104932 19 - 1.2 tablazat Adattpusok, meretek es ertektartomanyok a BORLAND C++-ban
medium model: az adatpointerek near, a kodpointerek far tpusuak. Megkotes, hogy az osszes adatnak el kell ferni egy 64 Kbyte-os memoriaszegmensben.
compact model: az adatpointerek far, a kodpointerek near tpusuak. Megkotes, hogy az osszes programkodnak el kell ferni egy 64 Kbyte-os memoriaszegmensben, valamint, hogy az osszes statikus adatnak el kell ferni egy masik 64 Kbyte-os szegmensben.
large model: mind az adat-, mind a kodpointerek far tpusuak. Megkotes, hogy az osszes statikus adatnak el kell ferni egy 64 Kbyte-os memoriaszegmensben.
huge model: mind az adat-, mind a kodpointerek far tpusuak. Figyeljuk meg, hogy a huge modell nem hasznal huge

pointereket! A masik megjegyzesunk, hogy kodpointerben a huge tpusra soha sincs szukseg, mert egyeb megkotesek miatt egyetlen fuggveny sem lehet 64 Kbyte-nal nagyobb. Ugyanez a megkotes vonatkozik a modulokra is, azaz sem az egy modulban denialt programkod, sem az ott denialt statikus adatterulet nem haladhatja meg a 64 Kbyte-ot. A memoriamodell kivalasztasat egy program rasa soran minden modul fordtasakor celszer}u ellen}orizni. Linkeleskor az integralt rendszer automatikusan gondoskodik rola, hogy a megfelel}o modell}u indto (un startup) kod es rendszerfuggvenyek legyenek beszerkesztve. Lehet}oseg van tovabba arra is, hogy tetsz}oleges memoriamodell hasznalata eseten bizonyos mutatokat explicit modon near-nek, far-nak, vagy huge-nak deklaraljunk, s}ot, ez az egyetlen lehet}oseg a huge pointerek hasznalatara. A mutatokkal a 19-as reszben foglakozunk reszletesen. } 1.3 AZ ELOFELDOLGOZ O
forrasszoveg - C

ford
t
oprogram el}ofeldolgozo - bels}o fordto 9 - targykod 1.1 abra Az el}ofeldolgozo kapcsolata a kornyezettel 1.3 Az el}ofeldolgozo Minden C(++) fordtoprogram szerves reszet kepezi egy un. el}ofeldolgozo (preproceszszor) A fordtoprogram es a preprocesszor kapcsolatat ugy kell elkepzelni, hogy a tulajdonkeppeni fordto nem is latja a forrasszoveget, hanem csak azt, amit ebb}ol az el}ofeldolgozo keszt a szamara. Ezt a 11 abran lathato modon kepzelhetjuk el. Jellemz}o az abran lathato egyuttm}ukodesre, hogy a bels}o fordto nem ismeri a megjegyzesek szintaxisat, ugyanis nincs ra szuksege: a neki atadott sorokbol az el}ofeldolgozo azokat "kirtja". A BORLAND C++ integralt fejeszt}oi rendszerenel a ket resz kapcsolata olyan szoros, hogy nincs is lehet}oseg az el}ofeldolgozo kimenetenek a megtekintesere. Ehhez egy kulon segedprogramot (CPP utility) talalunk a programcsomagban. Ez szolgal arra,

hogy a forrasszovegb}ol el}oalltsa az el}ofeldolgozo kimenetet egy .i kiterjesztes}u le-ba, gy lathatova teve, hogy tenylegesen mi kerul at a bels}o fordtonak. Az el}ofeldolgozo egy sororientalt szovegfeldolgozo (mas szoval makronyelv), ami semmit sem "tud" a C nyelvr}ol. Ez ket fontos kovetkezmennyel jar: az el}ofeldolgozonak szolo utastasokat nem rhatjuk olyan kotetlen formaban, mint az egyeb C utastasokat (tehat egy sorba csak egy utastas kerulhet es a parancsok nem loghatnak at masik sorba, hacsak nem jeloljuk ki folytatosornak)! masreszt minden, amit az el}ofeldolgozo m}uvel, szigoruan csak szovegmanipulacio, fuggetlenul attol, hogy C nyelvi alapszavakon, kifejezeseken vagy valtozokon dolgozik. A preprocesszornak szolo parancsokat a sor elejen (esetleg szokozok es/vagy tabulatorok utan) allo # karakter jelzi. 1.31 Szimbolumok es makrok Az el}ofeldolgozonak szinten lehetnek

"valtozoi", ezeket szimbolumoknak, illetve makroknak nevezzuk, es ugyanaz a kepzesi szabaly vonatkozik rajuk, mint mas azonostokra. Azert, hogy a preprocesszor szamara denialt szimbolumok a C forrasnyelvi szovegben elesen kulonvaljanak a programban hasznalt azonostoktol, szokas szerint a szimbolumokat csupa nagybet}uvel kepezzuk. Szimbolumokat a kovetkez}o parancssal hozhatunk letre: #define szimbolum helyettestend}o szoveg A harom f}o reszt tetsz}oleges szamu, min. 1 db szokoz es/vagy tabulator valasztja el. Az el}ofeldolgozo minden beerkez}o sort atvizsgal, tartalmaz-e korabban denialt szimbolumot. Ha igen, akkor azt lecsereli a megfelel}o helyettest}o karaktersorozatra, es ujbol atvizsgalja a sort szimbolumokat keresve, amit uj helyettestes kovethet, stb. Mindaddig folytatodik ez a folyamat, amg vagy nem talal a sorban szimbolumot, vagy csak olyat talal, ami mar egyszer helyettestve 10


A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS lett (a vegtelen rekurziok elkerulesere). Peldak szimbolumdenciora: | #define #define #define #define #define #define #define #define #define EOS TRUE FALSE YES bool MENUCOL MENULINE BORDER MENUROW 1 0 TRUE int 20 5 2 (MENULINE+BORDER) Az els}o harom peldaban szerepl}o szimbolumokra szinte minden C programban szukseg van. Figyeljuk meg, hogy a YES-t a TRUE segtsegevel denialtuk, ami kett}os helyettestessel valik majd 1-gye. A kovetkez}okben egy lehet}oseget mutatunk arra, hogyan lehet a C nyelv alapszavait kib}ovteni: bar explicit logikai tpus a nyelvben nem letezik, mi letrehozhatunk egy uj "alapszot", a bool-t, amit azutan termeszetesen eppugy hasznalhatunk, mint az eredeti int-et (hiszen ugyis arra cserel}odik le), de hasznalataval az egyes valtozok szerepet jobban kidomborthatjuk. Az alapszo jelleg hangsulyozasa erdekeben hasznaltunk ennel a szimbolumnal

kisbet}uket. A tovabbi denciok a szimbolumok leggyakrabban hasznalt teruletet mutatjak be: legf}obb hasznuk az, hogy a kulonboz}o "b}uvkonstansokat" nevvel ellatva egy helyre gy}ujthetjuk ossze, vilagosabba teve hasznalatukat es megkonnytve modostasukat. Az utolso peldat annak illusztralasara hoztuk fel, hogy milyen fontos szem el}ott tartani azt, hogy szoveghelyettestesr}ol van szo. Ha a latszolag felesleges zarojelpart elhagynank, akkor a kovetkez}o sorbol #define MENUSIZE (MENUROW*MENUCOL) MENUSIZE (MENULINE+BORDER * MENUCOL) az alabbi keletkezne #define ami vegeredmenyben a kvant 140 helyett 45-ot eredmenyezne mindenutt, ahol MENUSIZE-t haszn aljuk. Mivel a felesleges zarojelek bajt nem okozhatnak, szokjuk meg, hogy minden dencioban szerepl}o kifejezest zarojelezunk A makrok lehet}ove teszik azt, hogy a szoveghelyettestes parameterezhet}o legyen. A parameterek szamara nincs elvi korlat

megadva Peldak makrodenciora: #define #define abs(x) ((x) < 0 ? (-(x)) : (x)) min(a, b) ((a) < (b) ? (a) : (b)) (Az itt szerepl}o, un. felteteles kifejezeseket a megfelel}o helyen targyalni fogjuk Ha a ? el}ott allo kifejezes logikai erteke igaz, akkor a ? es a : kozott allo, egyebkent a : utan allo kifejezes szolgaltatja az eredmenyt.) Figyeljuk meg, hogy { szinten a szoveghelyettestest szem el}ott tartva { makrok eseteben nemcsak a helyettest}o kifejezest, de a helyettestend}o parametereket is zarojelekkel vedjuk. Az els}o peldaban szerepl}o makro alabbi alaku hvasa alfa = abs(y + 2) gy a kovetkez}o sort eredmenyezi } 1.3 AZ ELOFELDOLGOZ O
11 alfa = ((y + 2) < 0 ? (-(y + 2)) : (y + 2)) Ha y erteke -3, akkor alfa-ba 1 kerul, mint az varhato. Ha azonban a dencio helyettest}o reszeben az x-et ved}o zarojeleket elhagytuk volna, akkor alfa 5-ot kapna ertekul. Itt hvjuk fel a gyelmet arra

is, hogy alfa kiszamtasahoz a fenti esetben az y+2 erteket ketszer kell meghatarozni. Egyszer a feltetel kiertekelesekor, aztan az eredmeny meghatarozasahoz Ez komplikaltabb kifejezes eseteben a program hatekonysagat jelent}osen ronthatja. Nagyobb bajt okoz azonban az, hogy a C-ben bizonyos kifejezeseknek un. mellekhatasuk is lehet (peldaul a kifejezes tartalmazhatja olyan fuggveny meghvasat, ami a kvant ertek kiszamtasa mellett, azt ki is rja a keperny}ore), es a tobbszori kiertekeles a mellekhatas tobbszori jelentkezeset vonja maga utan (peldanknal a reszeredmeny ketszer kerul kirasra). Az ilyen makrok hasznalatanal ezert celszer}ubb az adott kifejezest egy ideiglenes valtozoba helyezni, es azzal meghvni a makrot. A makrok hasznalatanak szintaxisa, mint majd latni fogjuk, megegyezik a fuggvenyek hvasanak szintaxisaval. Ez nem veletlen, ugyanis tobb konyvtari "fuggvenyt"

peldaul sok C rendszer makrokent valost meg (ilyen "fuggveny" a pelda.c-ben haszn alt getchar() is), ami a hasznalatat nem befolyasolja { a fent emltett ritka kivetelekt}ol eltekintve, mint peldaul toupper(), tolower(), min(), max(), stb. { ugyanakkor a rutinhv asok elmaradasa miatt gyorsabb kodot eredmenyez. Felhasznalhatok a makrok arra is, hogy a program egy uj teleptesenel az adott rendszerben esetleg elter}o nev}u, vagy parameterezes}u konyvtari fuggvenyeket segtsegukkel a korabbi alakban hasznalhassuk. Ha egy szimbolum vagy makro altal lefoglalt azonostot fel szeretnenk szabadtani, azt az #undef szimbolum utastassal tehetjuk meg. Ezt kovet}oen az el}ofeldolgozo a szimbolum (makro) tovabbi el}ofordulasait nem kseri gyelemmel Termeszetesen egy ujabb #define utast assal ujradenialhatjuk ezt a szimbolumot is. Megjegyzesek
A kovetkez}o szimbolumok nem szerepelhetnek sem #define, sem #undef

direktivakban: STDC DATE FILE TIME LINE
Ket szintaktikai egyseget (token-t) egybe lehet forrasztani egy makro dencios reszeben, ha ## valasztja el }oket egymastol (es barmelyik oldalon esetleges szokozok). Az el}ofeldolgozo eltavoltja az esetleges szokozoket es a ## jelet, es egyesti a ket kulonallo szintaktikai egyseget. Ilyen modon lehet valtozokat konstrualni. Peldaul a #define VAR(I, J) (I ## J) makrodenicio eseten a VAR(x, 6) szovegb}ol x6 lesz a kifejtes utan.
A makrok dencios reszeben lev}o beagyazott makrok kifejtese a kuls}o makro kifejtesekor tortenik meg, nem pedig a denciojakor. Ennek leginkabb olyankor van jelent}osege, amikor egy beagyazott makrot #undef direktvaban is hasznalunk.
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 12
A # karakter elhelyezhet}o barmely makroargumentum el}ott, ilyen modon azt sztringge alaktva. A makro kifejtesekor a #arg

alaku parameterhivatkozasok az "arg" alakkal helyettest}odnek Peldaul a #define PRINTVAL(value) printf(#value "=%d ",value) makrodenico eseteben a int counter = 0 . PRINTVAL(counter) programreszletb}ol int counter = 0 . printf("counter" "=%d ",counter) lesz. A fenti printf utastas pedig ekvivalens a printf("counter=%d ",counter)
utastassal. Mas implementaciokkal ellentetben a BORLAND C++ el}ofeldolgozoja nem vegez parameterhelyettestest sztringeken es karakterallandokon belul. 1.32 Felteteles fordtas A C nyelvi felteteles fordtas lehet}oseget szinten a preprocesszor biztostja. Ennek altalanos formaja: #if feltetel #elif feltetel . . #else . #endif ahol a feltetel konstans erteke vagy igaz (nem nulla), vagy hamis (nulla). Az #elif  agbol tetsz}oleges szamu lehet, akar el is maradhat, csakugy, mint az #else  ag. Ha az els}o feltetel nem teljesul, akkor az

el}ofeldolgozo a #if utastast kovet}o els}o #elif, #else, illetve #endif direktvaig terjed}o sorokat gyelmen kvul hagyja { tehat ezekben szerepelhetnek akar szintaktikailag hibas C utastasok is {, es a kovetkez}o #elif utastast veszi hasonlokeppen, ha van. Ha egyik feltetel sem teljesul, es van #else ag, akkor csak az abban szerepl}o sorok kerulnek tovabbi feldolgozasra. Ha valamelyik feltetel igaz volt, akkor az adott agat kovet}o els}o #elif vagy #else utastastol { ha van ilyen - a megfelel}o #endif-ig terjed} o sorok lesznek "eldobva". A felteteles fordtasu reszek tetsz}oleges melysegben egymasba agyazhatok, peldaul: } 1.3 AZ ELOFELDOLGOZ O
13 #if ALFA < 3 . #if defined(BETA) . #else . #endif . #el-if ALFA < 10 . #endif A defined(szimbolum) alaku kifejezes erteke akkor igaz, ha az adott szimbolum { tetsz}oleges ertekkel { denialva van, egyebkent hamis. Az #if defined(szimb olum) a kovetkez}o

alakban is rhato: #ifdef szimbolum, illetve a feltetel negaltjanak megfelel}oen letezik #ifndef szimbolum alaku utastas is. 1.33 El}orede nialt szimbolumok Szabvanyos szimbolumok A BORLAND C++ mind az ot, az ANSI altal megkvant el}oredenialt szimbolumot rendelkezesre bocsatja. Mindegyik szimbolum ket-ket alahuzaskarakterrel kezd}odik es vegz}odik. Ezek a kovetkez}ok:
LINE Az aktualis forrasle feldolgoz as alatt allo soranak sorszama, 1r}ol indul.
FILE Az aktualis forras- vagy include le nevet tartalmaz o sztringkonstans. atum, amikor az el}ofeldolgozo az aktualis forrasle feldol
DATE Az a d gozasahoz hozzakezdett, sztringkonstans formajaban.
TIME Az az id}opont, amikor az el} ofeldolgozo az aktualis forrasle feldolgozasahoz hozzakezdett, sztringkonstans formajaban.
STDC A szimbolum 1 ertekkel denialva van, ha az Ansi keywords only fordtasvezerl}o kapcsolo On-ra van alltva (ilyenkor a fordto

csak az ANSI altal tamogatott kulcsszavakat ismeri fel), egyebkent a szimbolum denialatlan. A BORLAND C++ sajat el}orede nialt szimbolumai Az ANSI altal megkvant el}oredenialt szimbolumokhoz hasonloan ezek is ketket alahuzaskarakterrel kezd}odnek es vegz}odnek. askor van denialva, erteke 0x0200, a
BCPLUSPLUS Csak C++ fordt C++ fordto verzioszamara utal. Ez a szam az ujabb verziokban novekedhet
BORLANDC Hexadecimalis  allando formajaban megadja a BORLAND C/C++ fordto verzioszamat (2.0-as verzio eseten 0x0200) Ez a szam az ujabb verziokban novekedhet.
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 14
TCPLUSPLUS Csak C++ fordt askor van denialva, erteke 0x0200, a C++ fordto verzioszamara utal. Ez a szam az ujabb verziokban novekedhet
TURBOC  erteke a hexadecimalis 0x0297 konstans. Ez a szam az ujabb verziokban novekedhet.
cplusplus 1  ertekkel van denialva akkor, ha C++ uzemmodban

hasznaljuk a fordtoprogramot, egyebkent denialatlan. Ez lehet}ove teszi, hogy egyes forrasmoduljainkat hol C, hol pedig C++ programkent fordthassuk.
CDECL A BORLAND C/C++ fordt o Calling Convention . C opciojanak bekapcsolt allapotaban erteke 1, egyebkent pedig denialatlan A kovetkez}o szimbolumok kozul minden esetben pontosan egy van denialva (1 ertekkel), a tobbi denialatlan. A denialt szimbolum neve megegyezik a fordtaskor alkalmazott memoriamodellel. TINY COMPACT SMALL LARGE MEDIUM HUGE Ha peldaul az alkalmazott memoriamodell a small, akkor a defined( SMALL erteke igaz (1), de a defined( LARGE ) erteke hamis (0), s ugyangy az osszes tobbi szimbolum eseten.
PASCAL Deni alva van 1 ertekkel, ha az alapertelmezes szerint minden szimbolum a PASCAL konvenciot koveti (a Calling convention fordtasvezerl}o kapcsolo Pascal-ra van alltva), egyebkent denialatlan.
MSDOS A BORLAND

C++-ban ez a szimb olum minden korulmenyek kozt 1 ertekkel denialva van.
OVERLAY deni alva van es erteke 1, ha egy modult un. overlay modulkent fordtunk denialva van es erteke 1, ha egy programot MS-Windows alakalmazoi programkent fordtunk.
WINDOWS
DLL deni alva van es erteke 1, ha egy modult un. dynamic link librarykent fordtunk le egy MS-Windows alkalmazashoz 1.34 File-beeptes Igen gyakran hasznaljuk a preprocesszor le-beeptesi (le include) kepesseget. Segtsegevel teljes le-ok epthet}ok be a forrasunkba, pontosan ugy, mintha ott szerepelnenek berva. Az ilyen beeptend}o include le-ok egy helyen osszegy}ujtve tartalmaznak szimbolum es makrodenciokat, strukturakat rnak le, mas modulokban denialt tarolasi egysegeket deklaralnak stb. A BORLAND C++ rendszer nagyszamu include le-t bocsat a programozok rendelkezesere, amelyek kozul az adott feladathoz szuksegeseket epthetik be. A

fejlec le-ok kiterjesztese hagyomanyosan h (header le) A include le-okba beagyazva lehetnek ) } 1.3 AZ ELOFELDOLGOZ O
15 ujabb beeptesi utastasok stb. A beeptesi utastas altalanos alakja: illetve #include <le-nev> #include "le-n ev" ahol le-nev a beeptend}o le neve. Az els}o format altalaban akkor alkalmazzuk, ha a rendszer altal rendelkezesunkre bocsatott include le-t hasznalunk (a pelda.c-ben is ily m odon hivatkoztunk az stdio.h-ra), a masodikat pedig sajat include le-jainkra. 1.35 Implementacio-fugg}o vezerl}osorok Ezek az un. pragma direktvak, amelyeknek altalanos alakja: #pragma direktvanev parameterek Ezekben minden fordtonak lehet}osege van arra, hogy tetsz}oleges, implementacio-fugg}o vezerl}outastast szabjon meg, ugyanis { dencio szerint { ha egy fordto nem ismer fel egy pragma direktvanevet, akkor az egesz sort gyelmen kvul kell hagynia. A BORLAND C++ harom

pragma utastast ismer A #pragma inline vez erl}osor csak a BORLAND C++ parancssor-valtozataban (BCC) hasznalhato , es arra gyelmezteti a fordtot, hogy beeptett assembly utastasok talalhatok a forrasszovegben. Ekkor a BCC nem targykodot general, hanem assembly forrasszoveget, amelybe beiktatja a kozvetlenul megadott assembly forrassorokat, es az gy kapott szovegre elindtja a TASM assemblert. A masodik pragma-direktva a #pragma warn Ennek segtsegevel felul lehet bralni a Display warnings fordtasvezerl}o kapcsolok bealltott ertekeit, es a forrasszoveg egyes reszeire az alapertelmezest}ol elter}o gyelmeztetesi szintet valaszthatunk. A direktvanak haromfele alakja van: #pragma warn +xxx #pragma warn -yyy #pragma warn .zzz A fenti utastasok hatasara az xxx gyelmeztet}o uzenet generalasat bekapcsoljuk, az yyy-et ki, mg a zzz-et visszaalltja az eredeti ertekere. A hasznalhato harombet}us

rovidtesek es a hozzajuk tartozo gyelmeztetesek jelenteseit a BORLAND C++ Users Guide 6. fejezeteben talalhatjuk meg A harmadik pragma-utastas a #pragma saveregs direktva, amely arra utastja a fordtot, hogy egy huge fuggvenyre olyan kodot generaljon, ami belepeskor elmenti az osszes regiszter erteket, es kilepeskor visszaalltja azokat. A pragmat kozvetlenul az adott fuggveny dencioja ele kell helyezni, es csak arra az egy fuggvenyre vonatkozik. 16
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 1.4 Tarolasi osztalyok, hataskorok 1.41 Modulok, blokkok Mint lattuk, a C programok tobb, kulon fordthato modulbol epulhetnek fel. Jogosan merul fel a kerdes, hogy az egyik modulban denialt tarolasi egysegre tudunk-e hivatkozni egy masik modulbol, masreszt kvancsiak lehetunk arra is, hogy milyen a program egyes reszeinek hierarchiaja, "elrejthetunk-e" valtozokat mas modulok el}ol, stb. Ahhoz,

hogy ezekre a kerdesekre valaszolni tudjunk, tovabb kell boncolgatnunk a C programok szerkezetet. Emltettuk, hogy a modulokban vannak kodgeneralo egysegek, a fuggvenyek Minden fuggveny torzse egy blokkbol all, amelyen belul ujabb blokkokat alakthatunk ki. (A blokk mas elnevezese: osszetett utastas). A blokkszerkezet tehat a modulszerkezettel ellentetben hierarchikus, hiszen minden blokknak lehet alblokkja, es minden alblokk ala van rendelve az o}t magaban foglalo blokknak, mg a modulok azonos hierarchiaszinten vannak, tehat egymas melle vannak rendelve. Minden blokk ket reszre oszthato: deklaraciokra es adatdenciokra, valamint vegrehajthato utastasokra (ez utobbiak tartalmazhatjak az alblokkokat). Egy blokk ket resze kozul a deklaracios/denicios resz el is maradhat. Mivel blokk belsejeben nem lehet fuggvenydencio, ezert a C nyelvben minden kodgeneralo tarolasi egyseg azonos hierarchia-szint}u (mint a

modulok). Termeszetesen a fuggvenyek kozott van egy logikai fugg}osegi rendszer, hiszen a fuggvenyek egymast adott szisztema szerint hvjak (peldaul ha egy fv1 hv egy fv2-t, akkor ritkan fordul el}o, hogy fv2 is hvja fv1-et). Logikailag mindig van egy vezet}o fuggveny, amelyik a program indulasakor legels}okent kapja meg a vezerlest. A C, illetve C++ nyelvben ennek a vezet}o fuggvenynek a neve kotelez}oen a main (lasd a 1.11-es reszt) 1.42 Fuggvenyek tarolasi osztalyai A kodgeneralo tarolasi egysegek elerhet}oseg szerint ketfelek lehetnek: vannak csak a denciot tartalmazo modulban elerhet}o es a mindenhonnan hvhato fuggvenyek. Az el}obbieket static tarolasi osztalyuaknak (static storage class), az utobbiakat extern tarolasi osztalyuaknak nevezzuk. Ha tehat egy adott funkciot megvalosto fuggveny tobb, masok szamara erdektelen segedfuggvenyt hasznal, akkor ezeket osszegy}ujthetjuk egy modulba, es

egy kivetelevel { aminek hvasa kezdemenyezi a kerdeses feladat vegrehajtasat { a tobbit static tarolasi osztalyunak valasztjuk. Ilyen modon lehet}ove tesszuk, hogy egy { gyakran mas programozo altal rt { masik modulban ugyanolyan azonostokat koniktus nelkul lehessen hasznalni. 1.43 Valtozok elettartama es hataskore A tarterulet foglalo tarolasi egysegeket elettartam es hataskor szerint csoportosthatjuk. A C nyelvben az elettartam ketfele lehet: a program egesz futasara kiterjed}o, illetve egy bizonyos blokkban tartozkodas idejere korlatozodo. Az el}obbi csoportba tartozo valtozokat statikusaknak, az utobbiba tartozokat dinamikusaknak, vagy automatikusoknak (auto) nevezzuk. A statikus valtozok tehat mar a program indulasanak a pillanataban leteznek, ily modon { mint latni fogjuk { kezd}oertekkel is rendelkezhetnek, mg a dinamikusaknak a letrehozasa

OSZTALYOK,

OROK 1.4 TAROL ASI HATASK E

lettartam Lathatosag statikus globalis statikus statikus dinamikus modulra lokalis blokkra lokalis blokkra lokalis 17 Deklarator helye Tarolasi osztaly barmely modulban extern minden blokkon kvul adott modulban static minden blokkon kvul adott blokkban static adott blokkban auto, register 1.3 tablazat Valtozok elettartama, lathatosaga es tarolasi osztalya es megszuntetese futas kozben tortenik, az egyes blokkokba valo belepes, illetve kilepes alkalmaval. Ugyanabba a blokkba valo tobbszori belepeskor a dinamikus valtozoknak mindig egy uj, friss keszlete all rendelkezesre, amelyekben nyoma sincs azoknak az ertekeknek, amelyeket az utolso kilepeskor bennuk hagytunk. E ppen ezert a dinamikus valtozokat hasznalo fuggvenyek rekurzv modon is hvhatok. A dinamikus tarkezeles masik el}onye, hogy sokkal jobban gazdalkodik a memoriaval, hiszen az egyik blokkbol kilepve, a felszabadtott tarterulet

felhasznalhatova valik a kovetkez}o blokk szamara, azaz a valtozok egy resze a tarban { id}oeltolassal { atfedheti egymast. Hataskori csoportostas szerint leteznek teljesen globalis (mindenhonnan elerhet}o), modulra nezve lokalis (csak az adott modulbol hasznalhato) es blokkra nezve lokalis (csak az adott blokkon belul elerhet}o) valtozok. A C nyelvben az els}o ket csoportba csak statikus helyfoglalasu valtozok tartozhatnak, az utolsora nincs ilyen megkotes. A blokkra lokalis valtozok hataskore kiterjed az egesz blokkra, beleertve az alblokkokat is, azonban ha egy ugyanolyan azonostoju valtozot denialunk egy alblokkban, akkor az alblokkban valo tartozkodas idejere az uj dencio felulbralja az el}oz}ot, es uj valtozot hoz letre, ugymond "elfedi" az eggyel magasabb hierarchiaszinten denialt valtozot. Az alblokkbol valo kilepes utan a magasabb blokkban valo dencio fog ujra ervenyesulni

Ugyanez a helyzet akkor is, ha egy blokkban egy modulra lokalis, vagy teljesen globalis valtozot denialunk ujra. Egy valtozo deklaracioja illetve dencioja a valtozo tpusan kvul megadja azt is, hogy a fenti csoportok kozul hova keruljon. Ezt ket dolog szabalyozza: hol szerepel az adott deklarator, es hogy milyen tarolasi osztalyt runk el}o. Ezt a 1.3 tablazatban foglaltuk ossze Miel}ott a deklaratorok konkret formajara raternenk, szeretnenk megvilagtani a register tarolasi osztalyt. Ez lenyegeben az auto-val egyezik meg, az egyetlen elteres, hogy ennek hasznalataval rairanytjuk a fordtoprogram gyelmet az adott valtozora: varhatoan sokszor fogunk futas kozben hozzafordulni, ezert optimalis tarolas megvalasztasat kerjuk. Ez nem kotelezi a fordtoprogramot semmire, es az, hogy mennyiben tudja teljesteni igenyunket, attol is fugg, milyen tpusu valtozorol van szo. Csak sorszamozott, vagy

pointer tpusu valtozo lehet register tarolasi osztalyu. A regiszteres gepeknel az optimalis tarolas altalaban valamelyik gepi regiszter hasznalatat jelenti, ezert altalaban a gepi szo meret}u valtozoknal kepes a fordto teljesteni a register ajanlast. Mivel az int bitsz elesseget mindenhol a gepi szo meretere valasztjak, ezert ennel rovidebb 18
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS meret}u egesz valtozonal a register el}oras nem celszer}u. A register tarolasi osztaly el}orasa tehat az egyik olyan eset, amikor az int hasznalata ajanlott. Az egesz tpusu valtozukon kvul register tarolasi osztalyu valtozonak ajanlhatok meg a pointerek is. 1.44 Egyszer}u adatdeklaratorok Az adatdenciok legegyszer}ubb formaja a kovetkez}o: tarolasi osztaly spec. tpus spec azonostolista Ha a tarolasi osztalyt nem specikaljuk, akkor a kovetkez}o ket eset lehetseges: ha minden blokkon

kvul vagyunk, akkor a valtozo globalis lesz, mg ha valamely blokk belsejeben vagyunk, akkor a legbels}o befoglalo blokkra nezve lokalis, dinamikus valtozo jon letre (tehat auto, ezert ezt a kulcsszot nem is szokas sehol kirni). Amennyiben a denciobol a tpusmegadas hianyzik, akkor azt a fordto int-nek tetelezi fel, ez akkor is igaz, ha tpusmodosto kulcsszo (short, long, unsigned) mellett nem  all alaptpus. A peldac-ben a "register c " dencio tehat egy el}ojeles ertelmezes}u, gepi szohosszusagu egesznek foglal le helyet, amelyet dinamikus kezelessel blokkra lokalisnak vettunk fel, es egyben kertuk a fordtot, hogy igyekezzek optimalis tarolast hasznalni. (Ha valaki attanulmanyozza a lefordtott kodot, lathatja, hogy valoban gepi regiszterbe is kerul.) Nehany tovabbi dencio: | long alfa static unsigned short beta, gamma double x signed char c unsigned char byte unsigned delta Ezek kozul az

els}o alfa-t hosszu el}ojeles egesznek denialja (az int szokas szerint elmarad), es blokkon kvul globalis hataskorrel, blokkon belul auto-kent veszi fel. A beta es gamma egyarant el}ojel nelkuli rovid egesz, statikus helyfoglalassal! a dencio elhelyezese szerint modulra, vagy blokkra lokalis lathatosaggal Az x duplapontossagu valos valtozo, c es byte karakteresek! el}ojeles, illetve el}ojel nelkuli ertelmezessel, mg delta el}ojel nelkuli gepi szohosszusagu egesz. Ez utobbi negy valtozo vagy globalis, vagy auto, attol fugg}oen, hogy dencioik blokkon kvul, vagy belul vannak. Statikus helyfoglalasu valtozo denciojaban el}orhatunk kezd}oerteket is ugy, hogy a denialt azonosto utan egyenl}osegjellel elvalasztva kerul az inicializalo kifejezes, peldaul: static char c = EOS Ennek hatasara az adott valtozot a fordto eleve ugy helyezi el, hogy benne van a megfelel}o kezd}oertek, tehat ez az

ertekadas futasi id}oben nem igenyel id}ot. Ehhez azonban termeszetesen az szukseges, hogy az inicializalo kifejezes un. allando kifejezes legyen, azaz fordtasi id}oben kiertekelhet}o (nem fugghet mas valtozok erteket}ol). A C nyelv garantalja, hogyha egy statikus helyfoglalasu valtozonak nem adunk kezd}oerteket, akkor az csupa 0 bittel lesz inicializalva (azaz a fenti peldaban felesleges a kezd}oertek megadasa! ugyanakkor felhvja a

OSZTALYOK,

OROK 1.4 TAROL ASI HATASK 19 gyelmet arra, hogy ki fogjuk ezt hasznalni, es ha netan az EOS erteket megvaltoztatnank, akkor sem fogunk csalodni). Dinamikus valtozok dencioja utan is lehet kezd}oerteket rni, azonban ez csupan rovidtes, mert a helyfoglalas utan a "kezd}oertek" ugyanolyan modon kerul a valtozoba, mintha ertekado utastast hasznalnank. Emiatt az itt hasznalt kifejezesre nincs semmilyen megkotes, meg fuggvenyhvasokat is

tartalmazhat. Az el}obbiekt}ol kisse elter}o formaju a felsorolt (enum) tpusu valtozok deklaralasa. Az altalanos alak: tarolasi osztaly spec. enum tpuscmke felemlistag azonostolista A { nem kotelez}oen megadott { tpuscmke az adott felsorolt tpus megnevezese lesz, ezt kovet}oen mar hasznalhato az alabbi forma: tarolasi osztaly spec. enum tpuscmke azonostolista Az elemlista az adott tpusba tartozo elemeket adja meg, az azonostolista a denialt valtozokat nevezi meg, ha elmarad, akkor csak a tpust deklaraljuk kes}obbi denciok kedveert. Pelda felsorolt tpusu valtozok megadasara: static enum nap { hetfo, kedd, szerda, csutortok, pentek, szombat, vasarnap } ma enum nap tegnap, holnap Az Olvaso talan eszrevette, hogy az extern kulcsszot eddig nem hasznaltuk. Nos, ez azert van, mert a globalis valtozok denciojanal nem is szabad kirni. Ezzel a kulcsszoval azt jelezzuk, hogy nem denialjuk az

adott valtozot, hanem deklaraljuk. A globalis valtozokat mas modulokban is hasznalhatjuk, de ahhoz, hogy a fordtoprogram az azonostot megfelel}oen ertelmezhesse, azt szamara deklaralni kell. Az extern kulcsszo szerepe tehat jelezni azt, hogy az azt kovet}o deklaracio valami olyan tarolasi egysegre vonatkozik, amelyet egy masik { az aktualis modulra nezve kuls}o { modulban denialtunk. A ltalanos szabaly, hogy csak olyan valtozot szabad a C-ben hasznalni, amelyik az adott modulban { akar include le-okon keresztul { el}oz}oleg deklaralva van. Egy modulra nezve kuls}o globalis valtozok deklaracioja formailag megegyezik denciojukkal, a tarolasi osztalyuk extern, es termeszetesen nem szerepelhet kezd}oertekadas Peldaul: extern short unsigned kulso valtozo Egydimenzios tombvaltozo (array) megadasa a nev utan szammal (fels}o indexhatar + 1) tortenik, peldaul a " ]-be rt elem- float vektor"20] sor egy

20 lebeg}opontos elemb}ol allo vektor nev}u tombot denial. Hivatkozni az egyes tombelemekre tetsz}oleges kifejezessel lehet A tombindexek a C nyelvben mindig 0-tol indulnak, es a megadott meretnel eggyel kisebb ertekig mehetnek, tehat peldanknal vektor"0]-tol vektor"19]-ig. Statikus tombok inicializalhatok is, f g-ek koze zart elemlistaval, peldaul: 20
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS static short paratlan" ] = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 } Figyeljuk meg, hogy ebben az esetben az indexmeret el is maradhat, mert a fordtoprogram a kezd}oertekek szama alapjan foglalja le a szukseges tarteruletet. Karaktertombok sztringek segtsegevel is inicializalhatok: static char hiba" ] = "Hibas nev!" Itt a hiba tomb 11 elem}u lesz, hiba"10] erteke EOS lesz. Ha egy sztring nem kezd}oertekkent jelenik meg a programban, akkor az egy statikus helyfoglalasu, az adott karakterekkel (+ az

EOS) inicializalt tarterulet foglalo egyseg lesz, azonosto nelkul. Mutatok denialasat (vagy deklaralasat, ez ebb}ol a szempontbol kozombos) a mutatott tpus denciojabol vezethetjuk le. Ha unsigned short abc denialja az abc-t, mint egy rovid, el}ojel nelkuli egesz valtozot, akkor unsigned short *bcd denialja a bcd-t, mint egy rovid, el}ojel nelkuli egeszre mutato pointert. Hasonloan register char *p denialja p-t, mint egy (el}ojeles) karakterre mutato pointert. A p mutato dinamikus helyfoglalassal kerul tarolasra, blokkra lokalis es lehet}oseg szerint regiszterben lesz elhelyezve (ez utobbi a BORLAND C++ban fugg a memoriamodellt}ol is). Hasonlo elven tetsz}oleges alaptpusra mutato pointer denialhato. A tombokre es a mutatokra kes}obb meg reszletesebben visszaterunk a 1.9-as alfejezetben 1.45 Fuggvenyek de ncioja es deklaracioja Az eddigiekben tarterulet foglalo tarolasi egysegek

denialasarol es deklaraciojarol volt szo, most tekintsuk at a kodgeneralo program egysegeket ebb}ol a szempontbol. A fuggvenydencio altalanos formaja: tarolasi osztaly tpus azonosto(formalis parameterlista) blokk A tarolasi osztaly specikator vagy ures (globalis fuggveny), vagy static (modulra lokalis fuggveny). A tpus a fuggveny altal visszaadott ertek tpusa, ez gyakorlatilag tetsz}oleges lehet (kivetel, hogy fuggveny nem adhat vissza tombot vagy fuggvenyt, de visszaadhat ezeket megcmz}o mutatot). A fuggvenyazonostora (azonosto) az azonostokrol altalaban elmondottak ervenyesek A ( )-ek kozott allo formalis parameterlista a parameterek deklaraciojara szolgal, ahany deklaracio szerepel benne, annyi parametere van a fuggvenynek (akar egy sem, mint peldaul a main() a pelda.c-ben) A blokk { f g-ek kozott { deklaraciokat, blokkra lokalis adatdenciokat es vegrehajthato

utastasokat tartalmazhat Peldaul a: static double deg to rad(double x) {

OSZTALYOK,

OROK 1.4 TAROL ASI HATASK 21 . } denialja a deg to rad azonostoju modulra lokalis fuggvenyt, amely egy dupla pontossagu lebeg}opontos parameterrel rendelkezik es ugyanilyen tpusu ertekkel ter vissza (a blokkban hasznalhato utastasokat a kovetkez}o reszekben fogjuk ismertetni). Vagy tekintsunk egy masik peldat: int read(int handle, char *buf, unsigned len) { . } Ez a dencio letrehozza a read azonostoju globalis fuggvenyt, amely (el}ojeles) egesz erteket ad vissza es harom parametert var, ezek tpusa sorrendben egesz, karaktert megcmz}o pointer es el}ojel nelkuli egesz. Ha a formalis parameterlistaban . all az utolso parameter helyett, akkor ezzel azt jelezzuk, hogy az adott fuggvenynek a deklaraltakon kvul tovabbi, ismeretlen szamu es/vagy ismeretlen tpusu parametere lehet. Erre jellemz}o pelda az stdio.h

include le-ban deklaralt int printf(char*, .) standard fuggveny (mely az els}o parametereben adott sztringben lev}o specikacio szerint a szabvanyos kimeneti allomanyra { tipikusan a keperny}ore { nyomtatja ki a tovabbi parametereit). A fentebb ismertetett dencios forma az un. modern stlus szerinti, a BORLAND C++ altal is elfogadott alak A hagyomanyos forma (classic style) a kovetkez}o: tarolasi osztaly spec. tpus azonosto(azonostolista) deklaraciolista blokk Peldakent alljon itt az el}obb denialt read fuggveny hagyomanyos formatumu dencioja: int read(handle, buf, len) int handle char *buf unsigned len { . } A hagyomanyos forma kicsit tobb gepelest kvan, talan kevesbe attekinthet}o, de van egy nagy el}onye: sokkal szelesebb korben hasznalhato, mint a modern valtozat, ugyanis a klasszikus stlusu fuggvenydeniciokat minden (regi) C-fordto kepes "megerteni", mg a modern stlust csak az ujabb

fordtok tamogatjak. Ugyanakkor, ha egyes, tisztan C nyelven rt forrasmoduljainkat esetleg C++ kornyezetben is szeretnenk hasznalni, feltetlenul a modern deklaracios stlust kell alkalmaznunk. Ennek okara a 2 fejezetben az un sokalakusag kapcsan 22
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS vilagtunk ra. Hogy melyik stlust hasznaljuk a fuggvenyek denialasara, illetve deklaralasara, a programozonak kell eldontenie Ha szeles korben portabilis programot szeretnenk rni, celszer}u a hagyomanyos stlus, mg ha a jov}obe tekintunk, es C++ modulokkal kozos project-ben szeretnenk hagyomanyos C modulokat is (atras, modernizalas nelkul) felhasznalni, a modern stlus alkalmazasat javasoljuk. A kett}ot nem mindig lehet keverni a BORLAND C++-ban Ha C++ moduljaink is vannak a project-ben, akkor a BORLAND C++ fordto a hagyomanyos stlusu fuggveny deniciokat, illetve a formalis parameterlista nelkuli

deklaraciokat nem fogadja el. A fenti dilemma feloldasara celszer}u a preprocesszor altal nyujtotta felteteles fordtas lehet}oseget kihasznalni. Mi e fejezet hatralev}o reszeben a modern format hasznaljuk peldainkban. Termeszetesen, ha a portabilitas erdekeben regi C fordtokra is fel kell keszulnunk, akkor celszer}u a hagyomanyos alakot hasznalni. A pelda.c mintaprogramot tanulmanyozva felt}unhet, hogy a main fuggveny altal visszaadott ertek tpusarol (void) eddig meg nem tettunk emltest. Ennek az az oka, hogy a void eppen azt jelenti, hogy nem letez}o, nem denialt tpusu tarolasi egyseg. Vannak fuggvenyek, amelyek szerepe az, hogy meghvasukkor bizonyos feladatot vegrehajtsanak, de az altaluk visszaadott ertek kozombos, erdektelen (mas programozasi nyelvekben ezeket a programegysegeket szubrutinnak vagy eljarasnak nevezik). A void "tpusu" fuggvenydeklaracio azt jelzi a fordtoprogramnak,

hogy az adott fuggveny nem ad vissza erteket, es gy az gyelmeztethet, ha tevedesb}ol megis felhasznaljuk a fuggveny erteket. (A void "tpus" egy m asik jellemz}o hasznalata a void* tpusu mutatok deklaralasa. A void* tpussal altalanos pointereket deklaralhatunk (lasd 1.97-et): azt jellezzuk ezen a modon, hogy pontosan meg nem tudjuk, milyen tpusu tarolasi egyseg cmer}ol van szo, a pontos tpus majd kes}obb derul ki, es akkor a pointer tpusat a megfelel}ore konvertaljuk { lasd kes}obb a tpuskonverzio operatorat a 1.52 szakaszban) Ha egy mas modulban denialt globalis vagy konyvtari fuggvenyt szeretnenk meghvni, fuggvenydeklaraciot (function prototype) celszer}u hasznalni (s}ot, a C++-ban ez egyenesen kotelez}o). A C nyelv megkotesei ezen a teren nem olyan szigoruak, mint a valtozok eseten, ugyanis szabad meghvni nem deklaralt fuggvenyt, ha az int erteket ad vissza. Ezzel azonban kizarjuk

azt a lehet}oseget, hogy a fordtoprogram a parametereket ellen}orizhesse. Javasolt ezert, hogy minden fuggvenyt meghvasa el}ott deklaraljunk. A szabvanyos konyvtari fuggvenyek deklaracioi mind megtalalhatok a megfelel}o include le-okban, tehat ezek beeptesevel a deklaraciok automatikusan ervenyre jutnak. A leggyakrabban hasznalt stdioh tartalmazza a f}obb be- es kiviteli fuggvenyek deklaracioit (ezenkvul fontos struktura- es szimbolum-denciokat)! a string.h a karakterlancok kezeleset vegz}o fuggvenyeket! az stdlibh az altalanos jelleg}u, a mathh a matematikai fuggvenyek deklaracioit tartalmazza, egyeb hasznos denciok mellett! stb. A fuggvenydeklaracio formaja nagyon hasonlt a dencioera: tarolasi osztaly tpus azonosto(formalis parameterlista) Lathato, hogy elmarad a fuggvenytorzset alkoto blokk, es megjelenik a lezaro pontosvessz}o ( ). A tarolasi osztaly lehet extern, vagy static, ha

elmarad, az extern-t jelent. A read deklaracioja { a modern stlusu deniciojahoz hasonloan { tehat a kovetkez}o:

OSZTALYOK,

OROK 1.4 TAROL ASI HATASK 23 extern int read(int handle, char *buf, unsigned len) A fuggvenydeklaracio masik { a fentivel egyenertek}u, de szelesebb korben (azaz regebbi C fordtoknal is) alkalmazhato { formaja: tarolasi osztaly tpus azonosto(tpuslista) A read peldajanal maradva: extern int read(int, char *, unsigned) A parameterek helyen szerepl}o tpusdeklaraciokat ugy kapjuk, hogy a teljes parameter deklaraciokbol elhagyjuk az azonostokat. Lehet}oseg van arra is, hogy a teljes parameterdeklaraciot elhagyjuk, ekkor csupan azt kozoljuk a fordtoval, hogy az adott azonosto fuggvenynev, es milyen tpust ad vissza. (Ez a megoldas igazodik a klasszikus stlusu fuggvenydeniciokhoz, ugyanis a regebbi C fordtok sokszor nem fogadjak el a deklaracioban a parameterlista

megadasat.) Ez minimalisan szukseges, ha a fuggveny nem int-et ad vissza. Ha egy f uggveny nem var parametert, azt a deklaracioban ugy jelezzuk, hogy a parameterlista helyere a void kulcsszot rjuk, mint ahogy ezt a pelda.c-ben is tettuk 1.46 Modosto jelz}ok Kernighan es Ritchie 1]-ben 3 modosto jelz}ot denial , ezek a short, a long es az unsigned. A BORLAND C++ az ANSI szabvanyajanlasnak megfelel}oen tovabbi harmat valost meg, ezek a signed, const es volatile. A signed modosto jelz}o A signed jelz}o azt alltja egy adott objektumrol, hogy nem unsigned, tehat el}ojeles ertelmezes}u. Ennek szerepe els}osorban dokumentatv, illetve szimmetriat biztost Ha azonban az alapertelmezesbeli karaktertpust el}ojel nelkulire valasztjuk, akkor csak ennek segtsegevel denialhatunk el}ojeles karaktereket. A signed onmagaban signed int tpust hataroz meg, ugyanugy, mint ahogy az unsigned onmagaban unsigned int-et jelent. A

const modosto jelz}o Ha egy inicializalt valtozodenicio ele kitesszuk a const modosto szot, akkor az gy deklaralt valtozora ugy tekint a fordto, hogy annak erteket a kes}obbiek soran mar nem lehet megvaltoztatni: const int a = 100 const int b" ] = { 1, 2, 3, 4 } Az els}o denicio egy a nev}u egesz konstanst hoz letre, melynek erteke 100, a masodik denicio pedig egy b azonostoju, 4 elem}u egesz konstansokat tartalmazo tombot eredmenyez. Mivel egy const-kent denialt valtozonak a programfutas soran ertek nem adhato, mindig inicializaltan kell denialni! A const mindenutt allhat, ahol valtozot deklaralhatunk, gy auto valtozok el}ott elhelyezve lokalis 24
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS konstansokat kaphatunk. A const kulcsszo tulajdonkeppen egy tpusmodosto, amely azt mondja, hogy a hataskore alatt letrehozott adott tpusu kifejezes erteke nem valtoztathato meg. Ennek alapjan

ertelmes az alabbi deklaracio is: static char *private" ] = { "Ebben a privat", "tombben sok-sok", "uzenet van." } const char *get message(int i) { return private"i] } A fenti fuggvenydeklaracio arra szolgal, hogy masok szamara lehet}ove tegyuk egy sztring olvasasat, de a visszateresi ertekkent kapott ointeren keresztul az adott sztringet soha se lehessen felulrni. A volatile modosto jelz}o Az ANSI C a volatile modosto jelz}ot ugyan denialja, de nem adja meg a komkret, implementacio-fuggetlen ertelmezeset. Egy volatile objektummal kapcsolatban csak azt a kivanalmat fogalmazza meg a C szabvany, hogy egy ilyen tarolasi egysegre vonatkozolag az adott C fordto semmifele optimalizalast ne hajtson vegre. A BORLAND C++ eseteben ez azt jelenti, hogy a a volatile jelz}o majdnem az ellentete a const-nak. Azt jelzi, hogy a tarolasi egyseg elvileg barmelyik pillanatban modosulhat egy, az adott

programtol fuggetlen folyamat (peldaul megszaktasi rutin, DMA stb.) altal A fordtoprogram a volatile jelz}o hatasara az adott valtozot nem fogja regiszterben tarolni, es az optimalizalas soran sem fogja a tobbszoros, vagy latszolag felesleges ertekadasokat kiiktatni. A volatile modosto jelz}o hasznalatara tekintsuk a kovetkez}o peldat: volatile int ticks void interrupt timer(void) { ticks++ } /* end timer() / void wait(int interval) { ticks = 0 while (ticks < interval) } /* end wait() / A timer fuggveny megszaktasi rutinkent aktivizalodik valamely periodikus hardveresemeny hatasara. A wait fuggveny a megszaktasi rutin altal modostott ticks erteket ciklikusan lekerdezi Nagyfoku optimalizalas eseten a

OSZTALYOK,

OROK 1.4 TAROL ASI HATASK 25 fordtoprogram generalhat olyan kodot, amely a ciklusban a ticks erteket csak egyszer veszi tekintetbe (mert az a ciklusban explicit modon nem valtozik meg),

ezaltal vegtelen ciklust eredmenyezve. Ennek elkerulesere szolgal a ticks denciojaban a volatile jelz}o: a ciklus minden egyes futasa alkalmaval ki kell ertekelni ticks tartalmat, hiszen azt egy megszaktasi rutin modostja. 1.47 Tpusde nialo (typedef) azonostok A C nyelvnek van egy specialis "tarolasi osztalyt" jelz}o kulcsszava, ez a typedef. Ha egy azonost o dencioja melle ezt a tarolasi osztalyt adjuk meg, akkor az azt jelenti, hogy valojaban nem hozunk letre uj dolgot, hanem az adott azonostot { mint egy szimbolumot { a megadott tpus megnevezesere kvanjuk hasznalni. Ez tehat kizarolag a fordtonak szol, a generalt kodban ennek semmi nyoma nem lesz. Peldaul: typedef int bool typedef float float array"20] typedef short *short ptr Az els}o pelda ugyanazt a funkciot latja el, mint az el}ofeldolgozonal bemutatott szimbolum-dencio. A masodik letrehoz egy float array nev}u uj tpust,

aminek segtsegevel lebeg}opontos tomboket lehet denialni. Tehat itt a megnevezett uj tpus a float array, amelyet a float elemi tpusbol hozunk letre egy un. tpusmodosto operator segtsegevel Ez az operator a " ] tombtpust kepz}o operator. Az utolso pelda egy mutatotpust { a rovid egeszre mutato pointert { lat el azonostoval. Ezt az uj tpust a * mutatotpust kepz}o operatorral alltottuk el}o a short elemi tpusbol. Ez utobbi ket peldaban hasznalt szerkezetre a kes}obbiekben meg visszaterunk. A fenti sorok lerasa utan szerpelhetnek a kovetkez}o alaku denciok: bool yesno float array t11 short ptr shp illetve alkalmazhatjuk a kovetkez}o fuggvenydeklaraciot: extern bool ext fv(short ptr, bool, float array) A C-ben termeszetesen nem csak tarteruletfoglalo tarolasi egysegekre vonatkozo tpusokat hozhatunk letre, hanem kodgeneralo tarolasi egysegek tpusait is denalhatjuk, azaz

kulonfele fuggvenytpusokat adhatunk meg. A fentiekhez hasonloan, ez a tpusdeklaracio is olyan, mintha egy typedef "tarolasi osztalyu" fuggvenyt deklaralnank. Peldaul a typedef double dbl fv(double, int) deklaracio ertelmeben az uj tpus neve dbl fv. Ezt a tpust a double elemi tpusbol hoztuk letre a ( ) fuggvenytpust kepz}o operatorral. A fenti pelda szerinti dbl fv olyan duplapontossagu valos erteket visszaado fuggveny tpusanak az azonostoja, amely parameterkent egy double es egy int erteket var. Az gy letrehozott uj tpusazonostot felhasznalva rhatjuk, hogy dbl fv power 26
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS Operator Megnevezes ( ) fuggvenytpust kepz}o operator " ] tombtpust kepz}o operator * mutatotpust kepz}o operator Jelleg postx postx prex 1.4 tablazat Tpusmodosto operatorok A precedencia felulr}ol lefele csokken ami teljesen ekvivalens egy

modern stlusu fuggvenydeklaracioval. Deklaralunk tehat egy power azonostoju tarolasi egyseget, amelynek a tpusa dbl fv. Bar formailag ugy nez ki, hogy ez nem pusztan deklaracio, hanem egy komplett denicio, ne feledjuk, hogy a kodegeneralo tarolasi egysegek eseteben a teljes deniciohoz szukseg van a fuggveny torzsere is! A fuggvenydeklaraciok fenti modjat nem javasoljuk, hiszen rejtve marad az, hogy power valojaban nem egy valtozo, hanem egy adott fajta fuggveny, mindazonaltal a dbl fv tpus deklaralasa nem haszontalan. Segtsegevel konnyen deklaralhatunk fuggvenyre mutato pointereket: dbl fv *fv mutato A fuggvenekre mutato pointerek hasznalataval a 1.98-as reszben foglalkozunk reszletesebben. Az egyszer}u okolszabalyon { azaz a typedef "tarolasi osztalyu" deklaraciok megadasan { tulmen}oen, az alabbiak szerint foglalhatjuk ossze preczen egy uj tpus denialasanak szabalyait. U j

tpust mindig valamilyen mar meglev}o tpusbol (elemi tpusbol, strukturakbol, vagy typedef-fel mar korabban denialt tpusbol) hozhatunk letre ugy, hogy megnevezzuk az uj tpust, es erre az uj tpusazonostora alkalmazzuk az egyes tpusmodosto operatorokat (( ), " ], *). Termeszetesen, ha egy bonyolultabb tpust akarunk deklaralni (peldaul egeszekre mutato pointert visszaado fuggvenyek tombjet), gyelembe kell vennunk a tpusmodosto operatorok precedenciajat, es ennek megfelel}oen kell a tpusdenicio soran zarojeleznunk. A tpusmodosto operatorok kozul a * prex operator (a modostando tpus el}ott all), mg a ( ) es a " ] operatorok postx operatorok (a modostando tpus utan allnak). Az tpusmodosto operatorokra vonatkozo ismereteket a 14 tablazatban foglaltuk ossze Tpusdenialasra vonatkozo peldakat talalhatunk meg a 1.91-es pontnal A 1.122-es pontban a

tpusdenialassal kapcsolatban tovabbi reszletkerdesekre terunk ki. Megjegyzend}o, hogy a tpusmodosto operatorok a szo szorosan vett ertelmeben nem operatorok, hiszen nem a C programunk futasa soran torten}o tenyleges m}uveletvegzesre adnak utastast, hanem csak a fordto program m}ukodeset befolyasoljak: arrol adnak informaciot, hogy egy adott tpust hogy, s mint kell kezelni a fordtas hatralev}o reszeben. 1.5 KIFEJEZE
SEK 27 1.5 Kifejezesek A kifejezes (expression) a C nyelv egyik kulcseleme. Az eddigiekben talalkozhattunk vele (igaz, kicsit korlatozottabb formaban) az el}ofeldolgozo #if tpusu utastasai feltetelreszeben, tombindexeknel es a denciok inicializalo reszeben. Azonban latni fogjuk majd, hogy a kifejezesek onmagukban utastas ertek}uek is lehetnek, mert a C nyelvi kifejezes joval tagabb ertelm}u, mint a mas nyelvekben megszokott. A kifejezesek formailag vagy els}odleges kifejezesek

lehetnek, vagy reszkifejezes(ek)b}ol epulnek fel operator(ok) segtsegevel. A C nyelvben letezik egyoparandusu (unary), ketoperandusu (binary) es haromoperandusu (ternary) operator. Pelda lehet az egyes csoportokra a negalas operatora (-x), a szorzas operatora (x*y) es a makroknal bemutatott felteteles operator (x < y ? x : y). A k ovetkez}okben el}oszor attekintjuk az els}odleges kifejezeseket. 1.51 Els}odleges kifejezesek Els}odleges kifejezes az azonosto { felteve, hogy mar teljeskor}uen deklaraltuk. Tpusa a deklaracionak megfelel}o. Els}odleges kifejezes tovabba minden konstans, az ott targyalt megfelel}o tpussal, beleertve a sztringkonstansokat is, amelyek tpusa karaktertomb Barmely kifejezes ( ) zarojelek koze zarva szinten els}odleges kifejezesse valik, orokolve az adott kifejezes tpusat. Els}odleges kifejezes az }ot kozvetlenul kovet}o " ] zarojelek kozt allo kifejezessel egyutt

els}odleges kifejezest alkot. Mas szoval, egy tombvaltozot indexelve szinten els}odleges kifejezest kapunk, aminek a tpusa az adott tomb alaptpusa lesz. Ebben az osszefuggesben a " ] a benne szerepl}o indexel}o kifejezessel egyutt az un indexel}o operator, amelynek hasznalata formailag hasonlt a 1.47 pontban emltett " ] tombtpust kepz}o operator megjelenesere, de mg ez utobbi a fordto programot arra utastja, hogy az alaptpusbol tombtpust hozzon letre, addig az indexel}o operatorral egy tombtpusu tarolasi egyseg egy, az alaptpusba tartozo elemet jeloljuk ki. A fuggvenyhvas is els}odleges kifejezes, ami formailag egy els}odleges kifejezes az }ot kozvetlenul kovet}o ( ) zarojelek koze zart, vessz}ovel elvalasztott kifejezeslistaval (aktualis parameterlistaval) egyutt. A fuggvenyhvas eredmenyenek tpusa az adott fuggveny deklaralt visszater}o tpusa. A tombindexeleshez hasonloan

ugy is felfoghatjuk a dolgot, hogy a postx ( ) fuggvenyaktivizalo operatort alkalmazzuk az adott fuggvenytpusu tarolasi egysegre, es ennek a m}uveletnek az eredmenye az adott fuggvenytpus deklaracioja szerinti alaptpus, azaz a fuggveny visszateresi ertekenek a tpusa lesz. (Itt megint csak a 147 pontban elmondottakra utalunk.) Ez a gondolkodasmod osszhangban van azzal, hogy egy azonosto mindig els}odleges kifejezes A fuggvenynev is els}odleges kifejezes: onmagaban lerva denicio szerint a fuggveny cmet jelenti. Ezzel mast nem lehet csinalni, mint ertekul adni egy, az adott tpusu fuggvenyre mutato pointernek (lasd 1.98), vagy a fuggvenyaktivizalo operatort alkalmazni ra, mialtal az adott fuggvenybeli programkod az aktualis fuggvenyparameterekkel lefut. A fuggvenyhvas parametereiben szerepl}o minden float ertek automatikusan double, minden signed char, vagy signed short int ertek int, minden

unsigned short int, vagy unsigned char ertek unsigned int tpusuva konvertalodik. (Ez a fajta konverzio, mint majd latni fogjuk, ennel sokkal altalanosabb a kifejezesek kezelesenel). Itt valik vilagossa, hogy fuggveny parametereit 28
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS miert ertelmes gepi szo meret}u int-re valasztani (ha garantaltan elfernek 16 bitben), es hasonloan, miert celszer}utlen egy parametert float tpusunak deklaralni. Els}odleges kifejezesek tovabba a strukturak es unionok (lasd kes}obb) mez}oire vonatkozo kivalaszto operatorok (a . es a ->) alkalmazasaval nyert olyan kifejezesek, amelyeknel az operator baloldalan els}odleges kifejezes, jobboldalan pedig azonosto all. Ezeket reszletesebben a 18-es pontban fogjuk ismertetni Els}odleges kifejezesre peldakent tekintsuk el}oszor a pelda.c-ben el}ofordulokat Ezek a kovetkez}ok: | c, getchar(), (c = getchar()), EOF, isupper(c), tolower(c),

toupper(c), putchar(c) Tekintsunk nehany peldat az el}oz}o reszben talalhato deklaraciokat ervenyben lev}onek tetelezve fel: read(0, p, 0x100), p, hiba"8], vektor, szerda Ezek tpusai sorrendben int, char *, char, float" ], int, int. (Tpust ugy kell megadni, mintha deklaralnank egy ilyen tpusu valtozot, majd elhagyjuk bel}ole az azonostot. Az gy kapott szerkezetet absztrakt deklaratornak nevezzuk) 1.52 Operatorok A C nyelv egyik er}ossege mas nyelvekhez kepest a kifejezesekben hasznalhato operatorok gazdag valaszteka. Az eddig emltett operatorokat (tpusmodosto operatorok, indexel}o, illetve fuggvenyaktivizalo operatorok) csak a C-ben nevezik operatornak. A kovetkez}okben a hagyomanyos ertelemben vett operatorokat ismertetjuk. Ezek tobbnyire elemi tpusu adatokon vegeznek m}uveleteket, de egyik-masik kozuluk szarmaztatott, illetve bonyolultabb, osszetett tpusu tarolasi egysegekre is

alkalmazhato. Az egyes operatorok felhasznalasanak lehet}oseget a C++ az objektum-orientalt tulajdonsagai reven meg tovabb szelesti Ezt majd az un. operator overloading kapcsan tekintjuk at reszletesen a 2 fejezetben. A kovetkez}okben tehat lerjuk a C nyelvben hagyomanyos ertelemben vett operatorokat, ismertetjuk azok alkalmazasat. Az operatoroknak kulonboz}o precedenciajuk lehet, a kiertekeles sorrendje ezekt}ol fugg. A fejezet vegen ezert majd osszefoglaloan felsoroljuk az egyes precedencia-osztalyokat, es megadjuk azt is, hogy mi a teend}o, ha azonos precedenciaju operatorok egyutt fordulnak el}o A legtobb ketoperandusu operator megkvanja, hogy mindket operandusa azonos tpusu legyen Peldaul a /-rel jelolt osztasi m}uvelet mast jelent egesz tpusu operandusokra alkalmazva (maradekos egesz osztas), mint lebeg}opontosakra, es kevert operandusok eseten nem donthet}o el, milyen algoritmust kell hasznalni.

Hasonlo { bar nem ennyire latvanyos { a problema kulonboz}o meret}u operandusok eseten is. Nem lenne praktikus elvaras, hogy a C fordto minden elkepzelhet}o operandusparosra adjon eljarast, de nem lenne celravezet}o a teljes uniformizalas sem (mint peldaul egyes BASIC rendszereknel, ahol minden m}uveletet lebeg}opontosan hajtanak vegre). Ezert a C nyelv tervez}oi ugy dontottek, hogy a gepi szonal rovidebb operandusokat gepi szo meret}ure b}ovtik, valamint szam}uzik a rovid lebeg}opontos m}uveleteket. Ha a m}uveletben resztvev}o ket operandus nem azonos tpusu, akkor az egyik 1.5 KIFEJEZE
SEK 29 atalakul, hogy megegyezzenek, mindig a sorszamozott tpusu alakulva lebeg}opontossa, a rovidebb valtozat a hosszabbra, az el}ojeles az el}ojel nelkulire. A pontos szabalyokat az 1.63-as szakasz tartalmazza, es a tovabbiakban ezekre mint "szokasos aritmetikai konverziok"-ra fogunk utalni. Az ismertetest az egyoperandusu

operatorokkal kezdjuk, majd folytatjuk a ketoperandusuakkal, es vegul kiterunk a C egyetlen, haromoperandusu operatorara is. Az egyoperandusu opertarok koze tartozik a " ] indexel}o, a ( ) fuggvenyaktivizalo operator, es az els}odleges kifejezest kepz}o operator, az egyszer}u zarojelpar. Ezeket az el}oz}o, 151 pontban mar ismertettuk, itt csak a teljesseg kedvert emltjuk meg o}ket ujra. Az egyoperandusu * operator, az un. dereference operator indirekciot jelez, az operandusa mutato kell, hogy legyen, eredmenyul a mutato altal megcmzett erteket kapjuk. Az indirekcio operator inverze az egyoperandusu & operator, amely az operandusa cmet szolgaltatja (address of operator). Ha az address of operator operandusanak tpusa T, akkor az eredmeny tpusa "mutato T-re" lesz. Peldaul a korabbi deklaraciokat gyelembe veve a p = &hiba"3] ertekadas utan *p erteke a lesz. Az address of operator nem

alkalmazhato register t arolasi osztalyu valtozokra. Az egyoperandusu - (minusz) operator az operandus 2-es komplemenset szolgaltatja, a szokasos aritmetikai konverziok elvegzese utan. El}ojel nelkuli egeszekre alkalmazva ezt az operatort, az eredmenyre igaz lesz, hogy hozzaadva az eredeti operandust az osszeg 2n , ahol n az operandus szelessege bitben. Peldaul -40000u  erteke 25536 lesz. A BORLAND C++ megengedi az egyoperandusu + (plusz) oper ator hasznalatat: a fordtoprogram egyszer}uen gyelmen kvul hagyja azt. A logikai tagadas operatora a !, eredmenye int tpusu 1 vagy 0, attol fugg}oen, hogy az operandus 0 volt-e vagy sem. Alkalmazhato lebeg}opontos szamokra es mutatokra is. A bitenkenti komplementalas operatoranak jele ~ (a tilde karakter), ami a { kotelez}oen sorszamozott tpusu { operandusan elvegzett szokasos aritmetikai konverziok utan kapott bitminta 1-es komplemenset adja eredmenyul, peldaul ~0xFFFE

erteke 1 lesz (16 bites gepen). Az el}otagkent alkalmazott (prex) egyoperandusu ++ operator operandusanak az erteket megnoveli 1-gyel, es eredmenyul ezt a megnovelt erteket szolgaltatja olyan tpusban, mint amilyen az operanduse. Ez az operator tehat nemcsak visszaad egy erteket, de mellekhatasa is van az operandusara. Ha x erteke 3, akkor az y = ++x * 2 eredmenyekent az x felveszi a 4 erteket, y pedig 8 lesz. Analog modon letezik egyoperandusu prex dekrementalo operator is, jele --. Ez operandusa erteket csokkenti 1-gyel, es ezt adja eredmenyul Utotagkent (postx) is alkalmazhato az egyoperandusu ++ operator. Ekkor operandusanak az erteket 1-gyel megnoveli, de eredmenyul a noveles el}otti erteket szolgaltatja olyan tpusban, mint amilyen az operanduse. Ennek az ope-
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 30 ratornak tehat szinten mellekhatasa van az operandusara, de az eredmenyben ez nem

jelentkezik. Ha x erteke 3, akkor az y = x++ * 2 eredmenyekent az x felveszi a 4 erteket, y pedig 6 lesz. (Most mar erthet}ove valik a C++ elnevezes szimbolikus jelentese: olyan C, ami egy fokkal jobb) Analog modon letezik egyoperandusu postx dekrementalo operator is, jele --. Ez operandusa erteket csokkenti 1-gyel, es eredmenyul a csokkentes el}otti erteket szolgaltatja. A tpuskonverzio (type cast) operatora az adott operandus el}ott zarojelben allo tpusnev (absztrakt deklarator). Az eredmeny erteke { a lehet}osegek hatarain belul { megegyezik az operanduseval, tpusa a megnevezett uj tpus Peldaul (int)3.14  erteke 3, (long)0 megegyezik 0L-val, (unsigned short)-1 erteke 65535, (long *)p pedig egy olyan mutat ot eredmenyez, ami ugyanarra a tarteruletre mutat, mint p, de a megcmzett memoriareszt a fordto hosszu egesznek tekinti. Ez utobbi talan a legjellemz}obb a tpuskonverzio operatoranak alkalmazasara

Igy alkthatjuk at az altalanos { ismeretlen tpusu valtozora mutato { void* "tpusu" mutatokat adott tpusu mutatokka. Erre a kes}obbiekben egy peldat is be fogunk muatatni. A sizeof egyoperandusu operator az operandusakent szerepl}o valtozo (vagy zarojelben allo tpus) byte-okban megadott meretet szolgaltatja. Ennek segtsegevel lehet gepfuggetlen modon tarteruletigenyeket meghatarozni Peldaul sizeof(int) eredm enye a BORLAND C++-ban 2, es minden implementacional igaz, hogy sizeof(char) erteke 1. Itt jegyezzuk meg, hogy mind a C, mind a C++ nyelv denicoja csak annyit kozol az egyes elemi tpusok mereteir}ol, hogy azok minden implementacioban meg kell hogy feleljenek az alabbi relacioknak: 1sizeof(char)sizeof(short)sizeof(int)sizeof(long), illetve sizeof(float)sizeof(double) A konkret meretek a nyelv adott implementaciojatol fuggenek. (A BORLAND C++-ra vonatkozo meret informaciokat a 1.2

tablazatban foglatuk ossze) A ltalaban nem erdemes a fentieknel tobbet feltetelezni az elemi tpusok mereteir}ol Peldaul nem mindig igaz, hogy az egesz tpus eleg nagy ahhoz, hogy pointerek is elferjenek benne (lasd a BORLAND C++ eseteben a near es a far, illetve huge pointereket). A kor abbi deklaratorokat gyelembe veve sizeof(p)  erteke memoriamodellt}ol fugg}oen 2 vagy 4, sizeof(hiba) erteke 11, sizeof(vektor"2])- e pedig 4. A fenti peldakbol is latszik, hogy az implementacio-fuggetlen, portabilis C, illetve C++ programozasi stlus kialaktasaban a sizeof oper atornak kulcsszerepe van. A ketoperandusu * operator a szorzas m}uvelete, a / operator pedig az osztase. A szokasos aritmetikai konverziok megtortennek A maradekkepzes operatora a %, amelynek operandusai kotelez}oen sorszamozott tpusuak Egeszek osztasanal, ha barmelyik operandus negatv, a csonktas iranya gepfugg}o, es hasonlokeppen

gepfugg}o az is, hogy a maradek az oszto vagy az osztando el}ojelet orokli-e. Pozitv egeszek osztasanal mindig lefele csonktas tortenik Minden 1.5 KIFEJEZE
SEK esetben fennall azonban, hogy (a/b)*b 31 + a%b megegyezik a-val, ha b nem nulla. A ketoperandusu + es - operator a szokasos osszeadast, illetve kivonast vegzi el, a szokasos aritmetikai konverziok utan. Specialis esetkent lehet mutato operandusuk is, ezt a pointerekkel foglalkozo 1.94 fejezetben targyaljuk majd reszletesen. A << es >> ketoperandusu operatorok bitenkenti eltolas (shift) m}uveletet vegeznek balra, illetve jobbra. Mindket operandusnak sorszamozott tpusunak kell lenni, es a szokasos aritmetikai konverziok utan az eredmeny tpusa a bal oldali operanduseval egyezik meg. A kilep}o bitek elvesznek, balra leptetesnel az ures helyekre 0-ak lepnek be. Jobbra torten}o eltolasnal a belep}o bitek garantaltan 0-ak, ha a bal oldali

operandus el}ojel nelkuli ertelmezes}u, egyebkent ertekuk gepfugg}o (a BORLAND C++ eseteben az el}ojeles jobbraleptetesnel a belep}o bitek az eredeti ertek el}ojelbitjevel egyeznek meg). Peldaul 2 << 3 erteke 16, 0xFFFDu >> 2 eredm enye 0x3FFFu, mg -3 >> 1 erteke a BORLAND C++ eseten -1. A relacios es egyenl}oseg-vizsgalo operatorok a kovetkez}ok: kisebb <, nagyobb >, kisebb vagy egyenl}o <=, nagyobb vagy egyenl}o >=, egyenl}o == es nem egyenl}o !=. E rtelmezesuk a szokasos, eredmenyul int 1-et vagy 0-at adnak, attol fugg}oen, hogy a vizsgalt feltetel teljesul-e vagy sem. A bitenkenti operatorok sorszamozott tpusu operandusaikon vegeznek a szokasos aritmetikai konverziok utan bitm}uveleteket. Ezek a bitenkenti E S (AND) operator: a ketoperandusu &, a bitenkenti kizaro VAGY (XOR) operator, a ^ es a bitenkenti VAGY (OR) operator, a j. A logikai E S operator (&&) es a

logikai VAGY operator (j j) viszont logikai ertek}u operandusokat var (0 { hamis, nem 0 { igaz). Eredmenyul int 0-at vagy 1-et szolgaltatnak a megfelel}o logikai m}uvelet elvegzese utan. Vegyuk peldakent azt az esetet, hogy a erteke 2, b erteke 1. Ekkor a & b, a j b, a && b es a j j b erteke rendre 0, 3, 1 es 1 lesz, mivel logikailag mindket operandus igaz ertek}u. A felteteles ( ? : ) operator az egyetlen haromoperandusu operator a C nyelvben, alakja kif1 ? kif2 : kif3. A kifejezes feloldasa a kif1 kifejezes kiertekelesevel kezd}odik Ha az eredmeny nem 0, akkor a kif2, egyebkent pedig a kif3 kifejezes ertekel}odik ki, es ez utobbi ertek adja a m}uvelet eredmenyet es tpusat. kif2-nek es kif3-nak a szokasos aritmetikai konverziok utan azonos tpusuaknak kell lenniuk, kiveve, ha az egyik mutato, a masik pedig konstans 0. Ekkor az eredmeny tpusa a mutato tpusa lesz. Garantalt, hogy futas kozben kif2 es

kif3 kozul csak az egyik kerul kiertekelesre. A C nyelvben explicit ertekado utastas nincs! az ertekadas operatorokon keresztul valosul meg, kifejezesek kiertekelesenek mellekhatasakent. A legygyakrabban hasznalt ertekado operator az egyszer}u ertekadas operatora, jele =. P eldaul: y = x. Kiertekelesre kerul a jobboldali kifejezes (szukseg szerint konvertalva a baloldal tpusanak megfelel}oen), majd berodik a baloldalon meghatarozott valtozoba, felulrva annak korabbi tartalmat. Az egyszer}u ertekado operator baloldalan allo kifejezest az angol terminologia alapjan balerteknek
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 32 (lvalue), a jobboldalan allo kifejezest pedig jobberteknek (rvalue) nevezzuk. A kifejezes eredmenye es tpusa az ertekadas soran atadott erteknek megfelel}o. Peldakent tekintsuk a pelda.c-ben szerepl}o alabbi feltetelt: (c = getchar()) != EOF Mivel a zarojelek kozt

allo kifejezes els}odleges kifejezes, ezert ennek kiertekelese tortenik legel}oszor. A getchar() fuggveny hvasa altal szolgaltatott visszateresi ertek berodik a c nev}u valtozoba, es ugyanez az ertek lesz a zarojelezett kifejezes erteke is, ami vegul osszehasonltasra kerul az EOF szimbolummal, 0-at eredmenyezve, ha megegyeznek, es 1-et, ha nem. A c valtozo tehat a feltetel kiertekelese kozben mellekhataskent kapott erteket. A tovabbi ertekado operatorok a kovetkez}ok: +=, -=, *=, /=, %=, >>=, <<=, &=, ^=, j= Lathato, hogy mindegyik egy ketoperandusu operatorbol es az ertekadas jeleb}ol tev}odik ossze. Egy kif1 op= kif2 formaju kifejezes kiertekeleset ugy tekinthetjuk, mintha a helyen kif1 = kif1 op (kif2) alaku ertekadas allna { ahol op a fenti ketoperandusu operatorok barmelyike lehet { fontos kulonbseg azonban, hogy kif1 kiertekelesere csak egyszer kerul sor.

Peldaul ha x erteke 1, akkor az x += 2 kifejez es erteke 3, es mellekhataskent x is 3 lesz. A vessz}ooperator (comma operator) nevet jeler}ol, a , karakterr}ol kapta. A vessz}ooperatorral elvalasztott kifejezespar sorban egymas utan kiertekel}odik, es az eredmeny erteke es tpusa megegyezik a masodik (jobb oldali) kifejezesevel. Ha a vessz}o egy adott kontextusban maskepp is el}ofordulhat (fuggveny parametereinek elvalasztasanal, kezdeti ertekek listajanal), akkor a vessz}ooperatorral feleptett kifejezest zarojelekkel kell vedeni, peldaul: fugg(a, (t = 3, t + 2), c) A fenti fuggvenynek harom parametert adunk at, amelyek kozul a kozeps}o erteke 5. Az el}oz}oekben felsorolt operatorok el}ofordulasi sorrendje megegyezik a prioritasuk sorrendjevel, az egyertelm}useg kedveert azonban alljanak itt az egyes prioritasi szintek csokken}o sorrendben a hozzajuk tartozo asszociativitasi iranynyal egyutt: 1.

Els}odleges kifejezesek Az els}odleges kifejezesek balrol jobbra csoportostanak, tehat peldaul ak"3] ertelmezese (ak)"3] Itt a (a pont karakter) az un. mez}okivalaszto operator Err}ol reszletesen az strukturakkal foglakozo 18 pontban szolunk 2. Egyoperandusu operatorok: *, &, -, +, !, ~, ++, --, tpusmodostas, sizeof Az egyoperandusu operatorok csoportostasa jobbrol balra tortenik, azaz peldaul *p++ ertelmezese (p++). 3. Multiplikatv operatorok: *, /, % A multiplikatv operatorok balrol jobbra csoportostanak. 1.5 KIFEJEZE
SEK 33 4. Additv operatorok: +, Az additv operatorok balrol jobbra csoportostanak 5. Biteltolo (shift) operatorok: <<, >> A Biteltolo operatorok balrol jobbra csoportostanak. 6. Relacios operatorok: <, <=, >, >= A relacios operatorok balrol jobbra csoportostanak. 7. Egyenl}oseg-vizsgalo operatorok: ==, != Az egyenl}oseg-vizsgalo operatorok

balrol jobbra csoportostanak. 8. Bitenkenti E S operator: & Lasd a felsorolas utani 1. es 3 megjegyzest 9. Bitenkenti kizaro VAGY operator: ^ Lasd a felsorolas utani 1. megjegyzest 10. Bitenkenti VAGY operator: j Lasd a felsorolas utani 1. megjegyzest 11. Logikai E S operator: && Lasd a felsorolas utani 2. megjegyzest 12. Logikai VAGY operator: j j Lasd a felsorolas utani 2. megjegyzest 13. Felteteles operator: ? : A felteteles kifejezesek balrol jobbra csoportostanak. 14. E rtekado operatorok: =, +=, -=, *=, /=, %=, >>=, <<=, &=, ^=, j= Az ertekado operatorok jobbrol balra csoportostanak, azaz peldaul x = y = hatasara mind x, mind y az 1 erteket veszi fel. 15. Vessz}ooperator: , A vessz}ooperator garantalja a balrol jobbra valo sorrendben torten}o kiertekelest. 1. Megjegyzes: a ketoperandusu *, +, &, ^ es az j operatorok asszociatvak. Ha egy kifejezesben azonos szinten tobb

azonos asszociatv operator szerepel, akkor a fordtonak jogaban all a kiertekelesi sorrendet tetsz}olegesen megvalasztani. Ez { a reszkifejezesek mellekhatasai miatt { kihathat az eredmeny ertekere is, ezert kerulend}ok az olyan kifejezesek, amelyek nem denit kiertekelesi sorrendt}ol fuggenek. Peldaul az a++ + b"a] kifejezesben a b tomb indexe attol fugg, hogy az els}o vagy a masodik tag kiertekelese tortenik el}obb, azaz az indexeleshez az eredeti vagy a megnovelt a-t hasznaljuk. Ugyanez a helyzet all fenn a fuggvenyhvasok parametereinel, ugyanis ezek kiertekelese sem kotott sorrend}u. Peldaul a fugg(i++, a"i]) gepfugg}oen valasztja meg adott i ertek mellett az atadando tombelemet. 2. Megjegyzes: A logikai operatorok (&&, j j) garantaljak a balrol jobbra torten}o kiertekelesi sorrendet. Ezenkvul azt is biztostjak, hogy a masodik kifejezes kiertekeleset csak akkor vegzik el, ha az

els}o operandusuk alapjan az eredmeny nem egyertelm}u Peldaul a && b eseteben b kiertekelesere nem kerul sor, 1 34
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS ha az a 0, hiszen ekkor az eredmeny mar biztosan hamis logikai ertek lesz. Ennek jelent}osegere igyekszik ravilagtani a kovetkez}o feltetel: b != 0 && a/b < 5. Ha nem lenne garantalt a fenti kiertekelesi strategia, akkor ez a feltetel hibas lenne, mert b 0 erteke eseten bekovetkezne az elkerulni kvant 0-val torten}o osztas. U gyeljunk arra, hogy a logikai kifejezesekben fellep}o mellekhatasokat ne hasznaljuk ki, ugyanis egy logikai kifejezes esetleg lerovidult kiertekelese kovetkezteben a vart mellekhatasok egy resze elmaradhat. 3. Megjegyzes: a bitenkenti operatorok precedenciaja alacsonyabb, mint az egyenl}oseg-vizsgalo operatoroke. Gyakori hiba a kovetkez}o alaku vizsgalat: c & 0xF == 8. Ez garant altan mindig 0-at ad

eredmenyul. Helyes megoldas: (c & 0xF) == 8. 4. Megjegyzes: a felteteles operator kif1 feltetelreszeben, es minden egyeb helyen, ahol feltetelt kell megadnunk, tetsz}oleges kifejezes szerepelhet, es annak 0, illetve nem 0 erteke jelenti a feltetel hamis, illetve igaz voltat. Kulonosen veszelyes ez akkor, ha tevedesb}ol osszekeverjuk az egyszer}u ertekado operator = jelet az egyenl}oseg-vizsgalo operator == jelevel. Az a = b alaku feltetel ugyanis szintaktikailag teljesen helyes, de nem a ket mennyiseg egyenl}oseget vizsgalja, hanem b 0 vagy nem 0 volta szerint szolgaltatja az ered}o feltetelt, egyben b ertekevel a-t is felulrva. Szerencsere a BORLAND C++ az ilyen felteteleknel { ha engedelyezzuk { gyelmeztetest ad (a Possibly incorrect assignment uzenettel). Ha viszont tenylegesen a fenti esetre van szuksegunk, akkor a gyelmeztetes elkerulese { es az erthet}obb felrasi forma { kedveert rjuk azt az (a = b)

!= 0 alakba. 1.6 Konverziok A BORLAND C++ a standard eljarasokat alkalmazza az egyes adattpusok kozotti automatikus konverziokra. A kovetkez}o pontok az implementaciofugg}o reszeket ill. az alkalmazott b}ovteseket ismertetik 1.61 A konverzio a char, az int es az enum tpusok kozott Karakterallandot egesz tpusu objektumnak ertekul adva teljes 16 bites ertekadast vegez a gep, mivel minden karakterallando 16 bites mennyiseg. Egy char tpusu tarolasi egyseg sorszamozott mennyiseghez valo hozzarendelese eseten el}ojelkiterjesztes tortenik, kiveve, ha a karakterekre vonatkozo alapertelmezest el}ojel nelkulire alltottuk (Default Char Type { unsigned). A signed char tpusu tarolasi egysegekre mindig el}ojelkiterjesztes tortenik, az unsigned char tpusuak pedig mindig 0 ertek}u fels}o byte-tal lesznek 16 bitre b}ovtve. Az enum es int ertekek kozotti konverzio egyszer}u ertekmasolassal tortenik, az enum

ertekek es a karakterek konverziojara ugyanaz a szabaly ervenyes, mint az int ertekek es a karakterek eseteben.
1.7 UTAS
ITASOK 35 1.62 Konverzio mutatok kozott A BORLAND C++-ban a kulonboz}o pointerek kulonboz}o meret}uek lehetnek, a memoria modellt}ol ill. a pointer explicit meretmegadasatol fugg}oen (lasd near, far, huge, cs, ds, es, ss). Minden mutato deklaralasakor meg kell adni a mutatott tpust, ami lehet void, azaz b armi is. Deklaralasuk utan a pointerekhez hozzarendelhetunk azonban tetsz}oleges mas tpusu mutatokat is Az ilyen ertekadasokra a BORLAND C++ gyelmeztet}o uzenetet ad, kiveve, ha a deklaralt tpus a void*. Az egyetlen megkotes, hogy adatpointerek es kodpointerek kozott nem lehet konverziot vegrehajtani. 1.63 Aritmetikai konverziok A Kernighan es Ritchie szokasos aritmetikai konverzionak nevezi azt az eljarast, amely megadja, hogy a kulonboz}o tpusu operandusok milyen konverzion mennek

keresztul az aritmetikai operatorokkal alkotott kifejezesekben. A kovetkez}okben lerjuk a BORLAND C++ altal alkalmazott algoritmus lepeseit: 1. A nem egesz, az int-nel rovidebb illetve a szimpla pontossagu lebeg}opontos ertekek a 15 tablazatnak megfelel}oen egessze illetve double tpusuva konvertalodnak. E lepes utan mindket operandus int, illetve double lesz, beleertve a long illetve unsigned modosto jelz}oket. 2. Ha az egyik operandus long double, a masik operandus is long doublela alakul 3. Ha az egyik operandus double, a masik is double-la alakul 4. Egyebkent, ha valamelyik operandus unsigned long, a masik operandus is unsigned long lesz. 5. Egyebkent, ha valamelyik operandus long, a masik operandus is long lesz. 6. Egyebkent, ha valamelyik operandus unsigned, a masik operandus is unsigned lesz 7. Egyebkent mindket operandus tpusa int A kifejezes eredmenyenek tpusa minden esetben megegyezik a ket operandus tpusaval. 1.7

Utastasok A C nyelvi utastasok csak valamely kodgeneralo tarolasi egyseg denciojanal, a fuggvenytorzset alkoto blokkban fordulhatnak el}o. Az utastasok vegrehajtasa lerasasuk sorrendjeben tortenik, kiveve a vezerl}outastasok eseteben, ahol ezt majd kulon jelezzuk. Minden utastas viselhet cimket, amely az utastas ele rt azonostobol es az elvalaszto : karakterb}ol all. A legegyszer}ubb utastas az ures utastas: Leggyakoribb szerepe, hogy egyes ciklusok ures ciklustorzset jelezze, valamint az, hogy cimket viseljen a blokkzaro g karakter el}ott.
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 36 T
pus Mire Elja
ra
s konverta
lo
dik char unsigned char signed char short unsigned short enum float int int int int unsigned int int double A ltalaban el}ojelkiterjesztes 0 fels}o byte-tal b}ovtve Mindig el}ojelkiterjesztes Bitminta-masolas Bitminta-masolas Bitminta-masolas Mantisszat 0-akkal b}ovtve

1.5 tablazat A szokasos aritmetikai konverzioban alkalmazott eljarasok 1.71 Kifejezes-utastasok Barmely kifejezes pontosvessz}ovel lezarva szinten utastas, es a kifejezes kiertekeleset vonja maga utan, majd a kapott ertek eldobasra kerul. Termeszetesen ennek akkor van tenyleges haszna, ha az adott kifejezesnek van valamilyen mellekhatasa, mint peldaul valtozo ertekenek modostasa vagy fuggveny meghvasa. A pelda.c-ben az alabbi kifejezes-utastasok talalhatok: c = tolower(c) c = toupper(c) putchar(c) Az els}o ket kifejezesben ket mellekhatast is kivaltottunk, egy fuggvenyhvast es egy ertekadast. (Valojaban a fenti "fuggvenyek" mind makrokent vannak megvalostva, de ez mondanivalonk lenyeget nem befolyasolja.) Szoba johetnek meg a fenti tpusuakon kvul olyan kifejezesutastasok is, amelyek inkrementalo, vagy dekrementalo operatort tartalmaznak, peldaul x++ Ezekben az esetekben

lenyegtelen, hogy a prex vagy a postx valtozatot hasznaljuk. Szeretnenk felhvni a gyelmet arra, hogy szintaktikailag a kovetkez}o utastasok is helyesek: hiba"3] 8 a == b main de nem csinalnak semmit. (Ha engedelyezzuk, a BORLAND C++ ezt is jelzi a Code has no eect gyelmeztetessel) Kulonosen a Pascal-os gyakorlattal rendelkez}ok gyelmet hvjuk fel nyomatekosan arra, hogy ha egy fuggveny nem var parametert es nem is ad vissza (tehat teljesen procedure jelleg}u), meghvasakor akkor is ki kell moge rni az ures ( ) zarojel part, hiszen ez jelzi azt, hogy a fuggvenyt aktivizalni szeretnenk (fuggvenyaktivizalo operator). A fenti utolso pelda is helyes szintaktikailag (az adott fuggveny kezd}ocmet adja, lasd a 1.51 es 198 alatt lertakat), es ha nem tor}odunk a gyelmeztetessel (vagy nem engedelyezzuk), nehezen kiderthet}o hibat szerzunk magunknak. Barhol, ahol egy utastas allhat, szerepelhet osszetett

utastas (blokk) is. A blokk formailag ket reszre oszthato. Lehet deklaracios es blokkra lokalis adatokat deninialo resze, valamint utastasokat tartalmazo resze Ez utobbiba ujabb alblokkok epulhetnek.
1.7 UTAS
ITASOK 37 1.72 A felteteles utastas A felteteles utastasnak ket formaja letezik: if (kifejez es) utastas vagy blokk illetve if (kifejez es) utastas vagy blokk else utastas vagy blokk Mindket forma vegrehajtasa a kifejezes kiertekelesevel kezd}odik, es ha az igaz (nem 0), akkor az els}o utastas vagy blokk kerul vegrehajtasra. A masodik formanal megadott masodik utastasra vagy blokkra akkor kerul a vezerles, ha a kifejezes hamis (0 ertek}u). A peldac-ben szerepl}o felteteles utastas: if (isupper(c)) { c = tolower(c) } else { c = toupper(c) } eseten a feltetel { isupper(c) { azt adja meg, hogy a c valtozoban lev}o karakter az angol ABC nagybet}uje-e vagy sem. Ha a karakter nagybet}u, akkor

a c = tolower(c) utastas segtsegevel a kisbet}us parjaval helyettest}odik, ha nem, akkor a c = toupper(c) utastas csinal a kisbet}ukb}ol megfelel}o nagybet}uket. Figyeljuk meg, hogy bar mind az igaz, mind a hamis ag egyetlen utastasbol all, megis blokkba foglaltuk }oket. Ez nem kotelez}o, de az a meggy}oz}odesunk, hogy ezzel a stlussal olvashatobb, hibavedettebb programokat rhatunk. Mindenki igazat fog nekunk adni, aki { hozzank hasonloan { csak egyszer is keresett ilyenfajta hibat: if (isupper(c)) c = tolower(c) else c = toupper() fugg(c) ugyanis ez a programreszlet { az rasmoddal is jelolt { szandekunk ellenere a fugg f uggvenyt minden esetben meghvja. A masik hasonlo hiba: if (a > b) if (a > amax) amax = a else if (b > bmax) bmax = b Az el}obbi kodreszlet els}o ranezesre arra szolgal, hogy kivalasszuk a es b kozul a nagyobbat, majd azzal { bizonyos feltetelek tejesulese eseten { a megfelel}o valtozot

felulrjuk. A kodreszletet azonban a fordto gy ertelmezi: 38
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS if (a > b) if (a > amax) amax = a else if (b > bmax) bmax = b ami teljesen mast jelent (peldaul bmax csak ugy kaphat erteket, hogy a>b teljesul). Ennek oka az, hogy a fordto minden else-t a legkozelebbi, }ot megel}oz}o, else n elkuli if-hez kapcsolja. Ha azonban az altalunk javasolt, blokkos format alkalmazzuk if (a > b) { if (a > amax) { amax = a } /* endif a>amax / } else { if (b > bmax) { bmax = b } /* endif b>bmax / } /* endif a>b / akkor a fenti hibakat nem kovethetjuk el. A blokkzaro g utan allo megjegyzesek osszetett vezerlesi szerkezetek eseten jelentenek hasznos fogodzkodot. 1.73 Ciklusszervez}o utastasok Eloltesztelt, feltetelvezerelt ciklusok szervezesere szolgal a while utastas, alakja: while (kifejez es) utastas vagy blokk A fenti ciklusba lepve a kifejezes kiertekelesre

kerul, es ha erteke 0, akkor a ciklus torzsere nem adodik egyszer sem a vezerles. Ha a kifejezes igaz, akkor vegrehajtasra kerul az utastas vagy blokk, majd ujra a kifejezes kiertekelese kovetkezik, stb. A ciklusbol tehat mindaddig nem jutunk ki, amg a ciklusfeltetel hamis nem lesz A peldac program f}o ciklusa is a while szerkezettel lett megoldva: while ((c = getchar()) != EOF) { ciklustorzs } /* endw / A ciklusban maradas feltetele itt az, hogy a terminalrol beolvasott, es a c valtozoban tarolt ertek ne a le-vege jel legyen. A fenti sema karakteres le-olvasasnal mindennapos a C-ben Vegyuk eszre azt is, hogy ha a le nem tartalmaz
1.7 UTAS
ITASOK 39 (vagy a terminal nem kuld) egyetlen karaktert sem, akkor a programunk ill}oen nem csinal semmit. Gyakran el}ofordul, hogy a ciklus feltetelreszeben minden tennivalot elvegzunk, es a ciklus torzse uresen marad, peldaul: while ((c = str"i++]) == ) Indulaskor az str

karakterlanc i-edik elemen allunk, es a ciklus vegere c felveszi a sztring soron kovetkez}o, nem szokoz karakteret, i pedig a karakterlanc rakovetkez}o elemenek indexet tartalmazza. Hatultesztelt, feltetelvezerelt ciklusokat a kovetkez}o formaban rhatunk: do utastas vagy blokk while(kifejezes) Az adott utastas vagy blokk vegrehajtasa mindaddig ciklikusan ismetl}odik, amg a ciklusfeltetelt jelent}o kifejezes igaz (nem 0) marad. Akkor celszer}u a hasznalata, ha a ciklustorzset legalabb egyszer mindenkeppen vegre kell hajtani. Mas nyelvekhez hasonloan els}osorban a for utastas szolgal arra, hogy szamlalovezerelt ciklusokat kesztsunk! ugyanakkor a C nyelv for ciklusa joval kotetlenebb. A ltalanos alakja: kifejezes feltetel kifejezes leptet}o kifejezes) utastas vagy blokk for (inicializ alo A ciklusba lepve kiertekel}odik az inicializalo kifejezes, ami valamilyen mellekhatason keresztul inicializalo

szerepet tolt be. Ezutan a feltetel kifejezes erteket hatarozza meg a gep, es ha erteke hamis (0), akkor elhagyjuk a ciklust. Egyebkent vegrehajtasra kerul a ciklus torzset alkoto utastas vagy blokk, majd a leptet}o kifejezes ertekenek meghatarozasara kerul sor (ez egy mellekhatas reven a ciklusban torten}o leptetest vezerelheti), majd visszaterunk a ciklusfejben lev}o feltetel kifejezes kiertekelesere, es a ciklus mindaddig folytatodik, amg feltetel fejezes hamis nem lesz. A fentiek alapjan lathato, hogy a for a while egy olyan kiterjesztesekent is felfoghato, ahol a ciklus el}otti inicializalo es a ciklustorzs legvegen szerepl}o leptet}o kifejezes-utastasokat egy helyre, a ciklusfejbe osszevonjuk. Els}o peldakent nezzunk meg egy, a hagyomanyos for-nak megfelel}o szamlalovezerelt ciklust: for (i = 0 { . i < dbszam i++) } /* endfor / A fenti ciklus a torzset dbszam-szor hajtja vegre, illetve

ha dbszam <= 0, akkor egyszer sem (azaz ez a valtozat is kicsit intelligensebb a hagyomanyos for utastasoknal). A kovetkez}o pelda megkeresi a float vektor"N] tombben az els}o negatv elemet: 40
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS for (i = 0 i < N && vektor"i] >= 0 i++) Ha kilepeskor i erteke N, akkor minden elem nemnegatv, egyebkent i a kerdeses elem indexe. A for ciklus fejeben lev}o kifejezesek kozul barmelyik el is maradhat. Ha a feltetel kifejezes-t hagyjuk el, akkor az allando igazat jelent A for ( ) { . } /* endfor / alaku ciklus a vegtelen ciklus, kilepes bel}ole csak egyeb vezerl}outastasokkal lehetseges. (Egy masik lehet}oseg a vegtelen ciklus letrehozasara a while(1) f.g szerkezet} u ciklus.) 1.74 Egyeb vezerlesatado utastasok A switch tpusu elagaztatas a vezerlest tobb lehetseges utastas valamelyikere adja at egy kifejezes erteket}ol fugg}oen. Alakja:

switch (kifejez es) blokk A kifejezes kiertekelesekor a szokasos aritmetikai konverziok megtortennek, a kapott tpusnak int-nek kell lenni. A blokkon belul barmely utastas rendelkezhet a kovetkez}o formatumu cmkevel (akar tobbel is): case allando kifejezes: Az allando kifejezes fordtasi id}oben kiertekelhet}o kifejezest jelent, azaz nem fugghet egyetlen valtozo erteket}ol sem. Nem hasznalhato ket egyforma ertek}u case cmke. A switch utast as vegrehajtasa a kifejezes kiertekelesevel kezd}odik, majd az gy nyert ertek osszehasonltasra kerul az osszes case allandoval. Ha valamelyikkel megegyezik, akkor a vezerles az adott case cmket kovet}o utastasra adodik. Ha a kifejezes egyik case konstanssal sem egyezik meg, akkor a vezerles a default: cmkej}u utastasra adodik, ha ilyen letezik! ellenkez}o esetben a blokk egyetlen utastasa sem lesz vegrehajtva. A blokk altalaban nem tartalmaz

deklaracios illetve dencios reszt, ha megis, akkor a denciokban esetleg szerepl}o kezd}oertekadasok hatastalanok lesznek. A break utastas befejezi switch utast as vegrehajtasat, az }ot korulvev}o legbels}o while, do, for, vagy es a vezerles az gy befejezett utastas moge kerul. A kovetkez}o pelda felhasznalja a korabban denialt enum nap tpusu ma valtozot: switch (ma) { case hetfo: amit hetf}o eseten csinalni kell
1.7 UTAS
ITASOK 41 break case kedd: case szerda: keddi, vagy szerdai teend}ok break case szombat: amit szombaton kell tenni /* nincs break! / case vasarnap: ami szombati vagy vasarnapi dolog break default: amit egyebkent csinalni kell break } /* endswitch / Figyeljuk meg, hogy az egyes esetekhez tartozo utastasokat a kovetkez}o case cmke onmagaban nem zarja le (egy cmke a vezerlest nem valtoztathatja meg, csak celpont lehet egy vezerlesatadasnal), a tenyleges lezarast a break

utastassal erhetjuk el. Ki is hasznalhatjuk ezt a tulajdonsagot, mint a peldankban ezt szombat eseten tettuk: a megfelel}o esethez tartozo utastasok vegrehajtasa utan "racsorogtunk" a kovetkez}o esetre. Termeszetesen az ilyen, nem nyilvanvalo megoldasokat felt}un}oen illik jelolni A continue utastas szolgal arra, hogy egy ciklus torzsenek vegrehajtasat felbeszaktsa, es a vezerlest az adott ciklus fejere adja vissza (ez while-nal es do-n al a feltetelvizsgalat, for-nal a leptetes). A goto utastas a vezerlest a megnevezett cmke utani utastasra adja. Egy fuggveny a hvojahoz a return utastas segtsegevel terhet vissza. Az utastasnak ketfele alakja van: vagy return return kifejezes Az els}o format a void tpusu fuggvenyeknel hasznaljuk! a masodik forma eseten a fuggveny visszateresi erteket a kifejezes hatarozza meg. Szukseg eseten az ertekado operatorhoz hasonlo modon

konvertalodik a kifejezes a fuggveny visszateresi tpusara, de nem lesz int-nel rovidebb egesz illetve double-nal rovidebb lebeg}opontos tpusu (ezert celszer}u int-nek deklaralni a fuggvenyek visszateresi erteket char vagy short helyett). Megjegyezzuk, hogy a fuggveny torzset alkoto blokk veget jelz}o g-en valo athaladas egyenertek}u a return utastas vegrehajtasaval. 42
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 1.8 Strukturak es unionok A korszer}u programozasi nyelvek a strukturalt programozast nemcsak vezerlesi, hanem adatstrukturak biztostasaval is kotelesek tamogatni, de amg a vezerlesi strukturaknak egy jol meghatarozott kore van, addig az adatstrukturak annyifelek lehetnek, ahany feladatra kell megoldast talalni. Ezert uj vezerl}outastasok letrehozasat a programozasi nyelvek ritkan tamogatjak, ellenben adatstrukturak denialasat lehet}ove kell tenniuk. (Az

objektumorientalt programozas, gy a C++ is meg ezen a gondolatkoron is tullep: az osszetett adatstrukturakhoz a hozzajuk tartozo m}uveleteket is denialva kapjuk az un. objektumokat) A C nyelvben az elemi tpusokbol feleptett adatstrukturakat aggregatumoknak nevezzuk, es alapvet}oen haromfelek lehetnek: tombok, strukturak es unionok. Ez az elhatarolas azonban nem zarja ki ezek tetsz}oleges kombinacioit, peldaul szervezhetunk struktura elem}u tombokb}ol (es egyeb osszetev}okb}ol) uj strukturat vagy uniont. Az eddig megismert egyetlen aggregatum, az egydimenzios tomb, a kovetkez}o el}onyoket biztostja: tetsz}oleges elemehez azonos id}o alatt lehet hozzaferni (random access), merete dinamikusan is beallthato (lasd kes}obb), s}ot tetsz}oleges folytonos resze onallo tombkent is kezelhet}o. Hatranya, hogy minden elemenek azonos tpusunak kell lennie A most ismertetesre kerul}o aggregatum, a struktura viszont

lehet}oseget biztost arra, hogy logikailag osszetartozo, de kulonboz}o tpusu elemeket egysegbe fogva kezelhessunk. Minden denialt adatstruktura a fordto szamara uj tpuskent jelentkezik (typedef-fel nev is rendelhet}o egy struktura tpushoz), es a tovabbiakban azonos modon hasznalhatjuk, mint az elemi tpusokat (azaz deklaralhatunk illetve denialhatunk ilyen tpusu objektumokat, alkalmazhatjuk ra a sizeof operatort, reszt vehet tpusmodosto szerkezetben, kepezhetunk ilyen tpusra mutato pointereket stb.) A korszer}u C implementaciok { mint peldaul a BORLAND C++ { lehet}ove teszik (azonos tpusu) strukturavaltozok kozt a kozvetlen ertekadast, strukturak szerepelteteset fuggvenyek parameterekent illetve visszateresi ertekekent is. 1.81 Strukturak megadasa A strukturamegadas formailag nagyon hasonlt az alakja: enum tpusu deklaraciokra, tarolasi osztaly struct tpuscmke f tpus 1

azonostolista 1 tpus 2 azonostolista 2 . g azonostolista Az enum deklaraciohoz hasonloan elmaradhat a tpuscmke (a struktura megnevezese), ha a kes}obbiekben nem kvanunk hivatkozni ra, illetve elmaradhat az azonostolista is, ha csak a struktura alakjat kvanjuk megadni. A strukturat felept}o elemek, a mez}ok (members) deklaralasa tpusuk es nevuk megadasaval tortenik. A tpuscmke tipikus alkalmazasa az onhivatkozo (rekurzv) adatstrukturak denialasa Pelda struktura megadasara:
AK
E
S UNIONOK 1.8 STRUKTUR 43 struct s1 { int float char struct s1 } sv, *s1h a, b f *s, nev"30] *link amely az s1 struktura alakjanak rogztese mellett denial ket { a dencio elhelyezeset}ol fugg}oen { globalis vagy auto valtozot, az egyiket mint a fenti strukturanak megfelel}o tarolasi egyseget, a masikat, mint egy ilyen tpusu tarolasi egyseget megcmz}o mutatot. A strukturat felept}o mez}ok

tpusa tetsz}oleges lehet, gy barmely struktura tartalmazhat ujabb strukturakat is (ezt beagyazasnak, angolul nesting-nek nevezzuk)! az egyetlen megkotes, hogy egy adott strukturan belul elhelyezked}o elem tpusa sem lehet a deklaralas alatt lev}o tpus, azaz semelyik struktura sem tartalmazhatja onmagat sajat elemekent. Lehet}oseg van viszont arra (amint az el}obbi peldaban is lathato), hogy a struktura tartalmazzon mutatot olyan tarolasi egysegre, amelynek tpusa az adott struktura (lehet}oseg listak, fak es egyeb rekurzv adatstrukturak kialaktasara). A korszer}u C implementaciok { gy a BORLAND C++ is { megengedik, hogy egy strukturaelem azonostoja megegyezzek valamely egyeb, mas programegyseg azonostojaval, hiszen a mez}okre valo hivatkozas { mint ahogy rogton latni fogjuk { mindig egyertelm}uen megadja a megfelel}o strukturat is, gy a ket azonosto hasznalata jol elkulonthet}o. Ennek megfelel}oen

lehet ket kulonboz}o strukturanak is azonos nev}u mez}oje. A struktura tpusu elemekb}ol allo egydimenzios tombok denialasa hasonloan tortenik, mint az elemi tpusokbol valo eptkezes eseten: stuct s1 s1 tomb"12] A valtozodenciok strukturak eseten szinten tartalmazhatnak kezd}oertekadast is. A C nyelvben minden aggregatum inicializatorat { mint azt az egydimenzios tomboknel lattuk { a f g zarojelpar koze zart listaval kell megadni: struct tanulo{ char nev"30] short jegy } osztaly" ] = { { "Nyilas Misi", 5 }, { "Pato Pali", 2 }, . { "Bolond Istok", 1 } } A denialando strukturatomb meretet nem explicit modon rtuk el}o, hanem az inicializalo elemek szamaval. A tomb kezd}oerteket f g zarojelpar kozott lev}o listaval adtuk meg { minden listaelem egy struktura kezd}oerteket hatarozza meg. Ezen aggregatumok inicializalasa szinten f g koze zart { ketelem}u

{ listakkal tortenik. Mivel karaktertomb alkotja a struktura els}o mez}ojet, ezert itt egyszer}ustett megadast is hasznalhattunk, sztringkonstans inicializatort alkalmazva. A masodik mez}o mar nem aggregatum, ezert hasznalhattunk az a kezd}oertekadasban kozonseges konstansokat.
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 44 1.82 Hivatkozas struktura elemekre Ha egy struktura adott elemere kvanunk hivatkozni, akkor a . mez}okivalaszto operatort hasznalhatjuk, peldaul: sv.link = svh x = sv.f osztaly"0].jegy = 5 (*svh).a = 0 Mivel pointerekkel gyakran mutatunk strukturakra, a fenti utolso peldanak megfelel}o hivatkozasi forma s}ur}un el}ofordul. Ezert erre az esetre egy uj operatort bocsatottak rendelkezesunkre a nyelv tervez}oi, ez a -> operator (mnusz jel, nagyobb jel). A bal oldalon strukturara mutato pointernek, a jobb oldalon pedig az adott struktura egy mez}oazonostojanak kell allni. A

kifejezes->azonosto forma teljesen megegyezik az alabbi alakkal: (*kifejez es).azonosto Tehat a fenti utolso peldankat a kovetkez}okeppen is rhattuk volna: svh->a = 0 1.83 A bitmez}ok A strukturak egy masik felhasznalasi terulete, hogy segtsegukkel felbonthatunk sorszamozott tpusu adatokat char-nal is rovidebb bithosszusagu reszekre. Ily modon meg arra is van lehet}osegunk, hogy egy int erteknek minden egyes bitjet kulon-kulon kezelhessuk. Az ilyen, bithosszban meghatarozott elemek neve bitmez}o (biteld), es hosszukra az egyetlen megkotes, hogy minden bitmez}onek el kell ferni egy int tarolasara szolgalo teruleten. Hasznalatuknak akkor van jelent}osege, ha nagy mennyiseg}u jelz}ot (ag-et) szeretnenk minel tomorebben tarolni, vagy ha hardverkozeli programozasban az egyes biteknek, bitcsoportoknak kulonallo funkcioja van, es egymastol fuggetlenul kvanjuk ezeket hasznalni. Jollehet, ez a

lehet}oseg eddig is rendelkezesunkre allt, hiszen a bitenkenti operatorokkal tetsz}oleges bitet kivalaszthattunk, beallthattunk illetve torolhettunk, de a bitmez}ok hasznalata ugyanerre kenyelmesebb es jobban kovethet}o lehet}oseget biztost. A bitmez}oket formailag strukturaelemkent kell denialni es hasznalni, az egyetlen elteres az, hogy a bitmez}ok azonostojat kett}osponttal (:) elvalasztva a bitben kifejezett hossz megadasa koveti: tarolasi osztaly spec.struct tpuscmke f g tpus 1 azonosto 1 : hossz 1 tpus 2 azonosto 2 : hossz 2 . azonostolista A bitmez}ok tpusa int, vagy unsigned int lehet. Eredetileg a bitmez}oket el}ojel nelkulinek terveztek, fuggetlenul a megadott tpustol! a BORLAND C++ azonban az int-kent denialt bitmez}oket el}ojeles mennyisegkent kezeli. Mindaddig,
AK
E
S UNIONOK 1.8 STRUKTUR 45 amg az egymas utan kovetkez}o bitmez}ok elfernek egy gepi szoban, a fordto ezeket egy

(unsigned vagy signed) int-be pakolja, egyebkent ujat kezd. Lehetnek meg nem nevezett bitmez}ok is, csak :-bol es hosszbol feleptve, a nem hasznalt helyek kitoltesere. A 0 specialis hosszmegadas befejezi az adott gepi szo bitmez}okkel valo feltolteset, es ujat kezd. Peldaul: struct bitmezo { int mezo 1 mezo 2 unsigned mezo 3 mezo 4 int mezo 5 } bm : : : : : : 1, 2 8, 8 0, 2 Egy szoba kerulnek a mezo 1, a mezo 2 es a mezo 3. A mezo 4 mar nem fer itt el, ezert uj szoban helyezkedik el. A mezo 5 is elferne meg ugyanitt, de a 0 szelesseg}u bitmez}o hasznalataval azt egy harmadik szoba kenyszertettuk Peldak bitmez}ok hasznalatara: bm.mezo 3 = X bm.mezo 5 = bmmezo 2 bm.mezo 4 = bmmezo 1 ? 0 : bmmezo 3 1.84 A union fogalma Egyes feladatok megoldasa soran felmerulhet annak igenye, hogy ugyanazt a tarteruletet kulonboz}o id}opontokban kulonboz}o tpussal vagy jelleggel ertelmezzuk es hasznaljuk. Vegyuk peldaul egy

binaris fa feleptesenel hasznalhato adatstrukturat: struct fa { unsigned jelzo 1 : 1, jelzo 2 : 2, jelzo 3 : 2 long info struct fa *jobb, *bal } Minden csomopontnak tartalmaznia kell a leszarmazottaira mutato pointereket. A leveleket (veg-csomopontokat) arrol lehet felismerni, hogy mindket leszarmazottuk hianyzik, tehat a jobb- es baloldali mutatok specialis, "nem hasznalt" jelzest ado ertekkel vannak feltoltve (ami, mint latni fogjuk majd, a NULL ertek). A levelekre altalaban jellemz}o, hogy a tobbi csomoponthoz kepest tovabbi informaciot hordoznak. Ilymodon a fenti adatstruktura a levelek szamara nem megfelel}o, mert ezt a tobbletadatot nem kepes hordozni. Viszont, ha egy fa uj elemmel b}ovul, akkor valamelyik korabbi level elagaztato csomopontta valhat. Nehezkes lenne ehhez megvaltoztatni tpusat es ezzel egyutt meretet. Most vehetjuk hasznat annak, hogy a leveleknek nincs utodjuk, tehat a bal es a jobb

pointer egyutt { 32 vagy 64 biten { hordozza azt az egybites informaciot, hogy ez egy level. Ha felveszunk a meglev}o bitmez}ok koze egy ujabbat, akkor felszabadthatnank a ket mutato helyet a potlolagos informacio szamara, csak a fordtot 46
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS kell ertesteni rola, hogy ilyenkor ezeket mas modon kvanjuk ertelmezni. Erre szolgal a union. Peldankat segtsegevel ilyen formaba rhatjuk: struct fa { unsigned jelzo 1 : jelzo 2 : jelzo 3 : level : long info union { struct { long 1, 2, 2, 1 struct fa *jobb, *bal } utodok levelinfo } u } A fenti felras azt jelenti a fordtoprogram szamara, hogy az u-val jelolt adatterulet ketfelekeppen is hasznalhato: vagy ket pointert kell ezen a helyen tarolni az utodok megnevezes alatt, vagy egy hosszu egesz erteket levelinfo neven. Ezert a fordto az u tpusu adatok tarolasahoz akkora helyet valaszt, amekkora garantaltan elegend}o

ahhoz, hogy mindket resz-tpust kulon-kulon (de nem egyszerre) be tudja fogadni (A BORLANDC++ near mutatok eseten 2  2, far pointereknel 2  4 byte-ot fog lefoglalni). Ha csp tpusa a fenti struktura, akkor level eseten rhato peldaul a kovetkez}o ertekadas: csp.ulevelinfo = k mg ha a levelb}ol csomopont lett csp.uutodokbal = utod felteve, hogy k hosszu egesz, utod pedig a fenti strukturaju adatra mutato pointer. A union-ok dencioja es hasznalata formailag teljesen megegyezik a strukturakkal, csak azt kell gyelembe venni, hogy strukturakat a felsorolt elemek egyszerre, egyuttesen alkotjak, mg a union-okban egyid}oben a felsorolt elemek kozul csak egy szamara van hely. Fontos, hogy mindig a programozo felel}ossege, hogy egy union-t mindig a benne aktualisan tarolt adat tpusanak megfelel}o modon hasznaljon! 1.9 Mutatok es tombok A C nyelv egyik kozponti elemet kepezik a mutatok. A pointer aritmetika kovetkezteben a

C-ben a mutatokkal sokfele m}uvelet vegezhet}o Tulajdonkeppen ebben rejlik a C egyik nagy er}ossege. A mutatokkal elerhet}o gyors memoriakezeles es a sokret}u m}uveletek teszik a C-t assembly nyelv jelleg}uve A mutatok tipizaltsaga el}osegti a hibamentes programok keszteset, de ha szukseges, megfelel}o explicit tpuskonverzioval kell}o rugalmassag biztosthato. A C programok rugalmassaga a fuggvenyekre mutato pointerekkel is novelhet}o. A kovetkez}okben lepesr}ol lepesre attekintjuk a muatokkal kapcsolatos ismereteket
E
S TOMBOK 1.9 MUTATOK 47 1.91 A mutatok hasznalata A mutatok a C nyelvben barmilyen tpusu adatra, vagy barmilyen tpust visszaado fuggvenyre mutathatnak. A mutato fontos jellemz}oje a mereten es az erteken kvul az is, hogy pontosan milyen tpusra mutat. Termeszetesen egy osszetettebb mutatotpus ertelmezesekor konnyen el lehet tevedni Hasznos "okolszabaly" szintaktikailag a

kovetkez}o kijelentes: minden helyen, ahol adott tarolasi egyseget megnevez}o azonosto allhat, ott zarojelben allhat egy mutatoazonosto az indirekcio operatorat (egyoperandusu *) kovet}oen. Peldaul az i azonosto el}ofordulhat a kovetkez}o kornyezetekben: short i i = 8 j = i + 2 i++ j = fugg(i) tehat i helyere mondjuk *ptr-t rva a kovetkez}o utastasok is helyesek szintaktikailag: short (*ptr) . (*ptr) = 8 j = (*ptr) + 2 (*ptr)++ j = fugg((*ptr)) (termeszetesen a hivatkozott mutatot korulvev}o ( ) zarojelparok { az utolso el}otti utastast kiveve { a precedenciaszabalyok gyelembevetelevel elhagyhatok). Szemantikailag az els}o pelda denialja a ptr valtozot, mint egy rovid egeszre mutato pointert. Ezt a deklaraciot a zarojelek elhagyasaval is rhatjuk: short *ptr. Ezzel a deklaracioval teljesen egyenertek}u a 1.47-bol mar ismert pelda: typedef short *short ptr . short ptr ptr Az el}oz}o pelda masodik soranak

ertekado utastasa a ptr altal megcmzett, short-nak tekintett t arteruletre berja a 8 erteket. (Meg kell jegyeznunk, hogy ebben az esetben ptr valamilyen ervenyes cmet kell, hogy tartalmazzon, mert egyebkent a (*ptr) = 8 ertekadas kovetkezmenye belathatatlan lesz. A peldaban szerepl}o helyere kell kepzelnunk azt a muveletet, amelynek soran a ptr pointerbe egy valamilyen modon lefoglalt, egyetlen short tarolasara alkalmas memoriaterulet cme kerul.) A harmadik peldaban a mutaton keresztuli indirekcioval nyert erteket hasznaljuk fel egy kifejezesben, a negyedikben megnovejuk eggyel a rovid egesznek tekintett, a ptr altal megcmzett adatot, mg az utolso utastas az indirekcioval nyert erteket adja at egy fuggvenynek. Kicsit bonyolultabb peldak a bevezet}oben emltett "okolszabaly" alkalmazasara: a) int func(double, int) ) int (*pfunc)(double, int)
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 48 Ez

a pelda azt illusztralja, hogy deklaralhatunk egy fuggvenyre mutato pointert. Esetunkben pfunc egy "int tpusu erteket visszaado, egy double  es egy int tpusu parametert varo fuggvenyre mutato pointer" tpusu valtozo. A (*pfunc) koruli zarojelek nem hagyhatok el, mert akkor pfunc-ot egy olyan f uggvenynek deklaralnank (es valoszn}uleg sehol sem denialnank), amelyik egeszre mutato pointert adna viszsza. Fuggvenyre mutato pointerek eseten is celszer}u a tpust typedef-fel denialni: typedef int (*func ptr)(double, int) . func ptr pfunc Egy adott fajta fuggvenyre mutato tpust minden fuggveny-fajta eseteben egyedileg kell "osszeraknunk" . A tpusmodosto operatorokban valo gondolkodas itt is sokat segt: Az uj tpus a func ptr lesz Ezt az int-b}ol szarmaztatjuk a kovetkez}okeppen. A (double, int) postx tpusmodosto operatorral el}oalltunk egy { onmagaban semmire sem hasznalhato {

int-et visszad o fuggveny tpust. Ebb}ol a tpusbol a * operator segtsegevel letrehozzuk a vegs}o, tpust: egy ilyen fuggvenyt megcmz}o pointer tpusat. Fontos a zarojelezes Ha a fenti peldaban a *func ptr-t nem vedenenk zarojelekkel, akkor egy int tpusu visszateresi ertekkel rendelkez}o fuggvenytpust denialnank. (A ( ) tpusmodosto operator precedenciaja magasabb, mint a * tpusmodosto operatore, lasd a 1.4 tablazatot) Termeszetesen erthet}obbe valik minden, ha a fenti tpusdeklaraciot reszeire bontjuk: typedef int int fv(double, int) typedef int fv *func ptr b) a = func(0.0, 81) ) a = (*pfunc)(0.0, 81) Ezzel a peldaval azt igyekszunk megmutatni, hogy "okolszabalyunkat" alkalmazva hogy aktivizalhatunk indirekt modon fuggvenyeket. A pfunc valtozo tpusa az a) pelda alapjan (akar a typedef-es deklaraciot, akar az anelkuli deklaraciot tekintve) "egesz erteket visszaado, egy

dupla pontossagu valos, es egy egesz tpusu parametert varo fuggvenyre mutato" tpus. Az indirekcion alapulo fuggvenyhvas szemantikaja a kovetkez}o: A fuggvenyre mutato pointerre alkalmazzuk az indirekcio operatorat, a *-ot. Ekkor { az  altalanos szabalyoknak megfelel}oen { a *pfunc kifejezes nem mas, mint maga a tarolasi egyseg, mely esetunkben egy fuggveny. Egy "fuggveny tpusu" kifejezessel nem tudunk mit kezdeni, ugyhogy az indirekciot kovet}oen alkalmazzuk az fuggvenyaktivizalo operatort, a ( )et (termeszetesen a szukseges fuggvenyargumentumokkal egyutt). Mivel ez utobbi operator precedenciaja magasabb, mint az indirekcio operatore, *pfunc kifejez est zarojelekkel kell vedenunk. c) float vektor"20] ) float *(pvekt"20])
E
S TOMBOK 1.9 MUTATOK 49 Itt float tpusu tarolasi egysegekre mutato pointerek tombjet deklaraltuk. A short ptr deklaraciojahoz hasonloan egy

kisse logikusabban atcsoportostva az egyes tpusmodosto operatorokat, pvekt-et gy is deklaralhatjuk: float* pvekt"20] Ennek a peldanak a logikaja nagyon hasonlt az a) pontban lertakhoz. Jelen esetben a modostott typedef-es alak a kovetkez}o lehet: typedef float* float vekt ptr"20] . float vekt ptr pvekt vagyis a megnevezett uj tpus a flaot vekt ptr. Ezt a float* tpusbol szarmaztatjuk ugy, hogy alkalmazzuk a postx "20] tombtpus kepz}o operatort. d) x = vektor"2] ) x = *(pvekt"2]) Most azt lathatjuk, hogy a c) pont szerint deklaralt pvekt valtozo felhasznalasaval hogy erhetunk el egyes adatokat. El}oszor a "2] indexel}o operatorral el}oalltjuk pvekt megfelel}o elemet (mely termeszetesen float* tpus u), majd az indirekcio operatorat alkalmazva megkapjuk a kvant lebeg}opontos erteket. A short *(pptr) pelda "okolszabalyunk" rekurzivitasat mutatja be, azaz egy mutato

denciojaban lecserelve az azonostot egy (itt feleslegesen) zarojelezett indirekt pointerre, sikerult egy mutatot megcmz}o pointert denialnunk. Termeszetesen ezt tovabb, tetsz}oleges szintig folytathatnank, legalabbis elvileg. Termeszetesen nagyon korultekint}oen kell eljarnunk az osszetettebb tpusu pointerek deklaralasakor. Ha a fenti c) peldanal a zarojeleket mashova tesszuk ki, egeszen masfajta valtozo lesz a pvekt: a float (*pvekt)"20] deklaracio ertelmeben pvekt egy 20 elem}u float tpusu tombre mutato pointer lesz. 1.92 E rtekadas mutatoknak Egy mutato erteket olyan ertekadason keresztul kaphat, ahol a jobb oldalon allo kifejezes tpusa megegyezik a mutatoeval. Pointer tpusu kifejezest legegyszer}ubben az egyoperandusu & operator (address of operator) segtsegevel keszthetunk, vagyis konkretan megadva azt, hogy a mutato milyen valtozora mutasson, peldaul (a 1.91 deklaracioit

feltetelezve): ptr = &i pptr = &ptr Specialis eset, ha fuggveny cmet akarjuk berni egy pointerbe. A fordto ilyen esetben nem igenyli az & operator alkalmazasat (s}ot, gyelmeztet}o uzenetet is ad erte), ugyanis dencio szerint egy fuggvenyazonosto az }ot kovet}o parameterzarojelek nelkul az adott fuggveny cmet jelenti. Helyes tehat a kovetkez}o ertekadas: pfunc = func 50
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS Mutato tpusu kifejezes el}oalltasanak masik modja az, hogy korabban ertekkel feltoltott pointer(ek)b}ol megfelel}o m}uveletekkel alltjuk el}o. A pointereken vegezhet}o aritmetikat rovidesen ismertetni fogjuk, itt csak legegyszer}ubb esetkent tekintsuk a szimpla ertekadast: *pptr = ptr A leggyakrabban alkalmazott modszer mutatok feltoltesere a dinamikus teruletfoglalas soran nyert cmek felhasznalasa. A BORLAND C++ tobb standard konyvtari fuggvenyt is rendelkezesunkre

bocsat, amelyekkel futasi id}oben lehet tarterulet foglalast vegezni. Ezek kozul a legegyszer}ubb a malloc, amely parameterkent a lefoglani kvant terulet nagysagat varja (sizeof egysegben) Az altala visszaadott ertek (megfelel}o tpuskonverzio utan) barmilyen pointernek atadhato. Peldaul a ptr = (short *)malloc(sizeof(short)) hvas hatasara futasi id}oben a tarkezel}o eljaras lefoglal egy akkora teruletet a memoriabol, ahol egy rovid egesz tpusu adat elfer, majd az gy kapott terulet cme berodik ptr-be. A lefoglalt teruletet azutan a pointeren keresztul tetszes szerint manipulalhatjuk, eppugy, mintha az eddig megszokott modon hoztunk volna letre egy short valtozot. A futasi id}oben torten}o teruletfoglalas el}onye, hogy pontosan az igenyeknek megfelel}o meret}u teruletet vehetjuk birtokba. Ennek els}osorban a dinamikus tomboknel (peldaul karakterlancoknal) van nagy jelent}osege. Mutatoknak torten}o

ertekadasnal kiemelt jelent}osege van a NULL szimbolumnak. (Ez a szimbolum tobbek kozott az stdioh standard include le-ban van denialva). Az a mutato, amely NULL erteket kapott, ugy tekintend}o, mint egy sehova sem mutato pointer, es a NULL garantaltan megkulonboztethet}o minden legalis cmt}ol. A malloc is NULL ertekkel ter vissza, ha a teruletfoglalasi kerelmet nem tudja teljesteni A NULL minden letez}o megvalostasnal a 0 ertek (vagy inkabb a (void*)0 ertek), de portabilitasi es stilaris okokbol el}onyben kell reszesteni a NULL szimbolum hasznalatat. A fenti teruletfoglalo peldat is a kovetkez}okeppen illik "tisztessegesen" megvalostani: if ((ptr = (short *)malloc(sizeof(short))) == NULL) { a memoriafoglalasi hiba lekezelese } /* endif / 1.93 Mutatok fuggvenyparameterkent Mutatokat igen gyakran hasznalunk fuggvenyhvasoknal. Ennek oka az, hogy a hagyomanyos C nyelvben minden, fuggvenynek

atadott parameter ertek szerint kerul at. A fuggvenynek jogaban all parametereinek erteket modostani, de a modostas nem hat vissza a parameterkent allo valtozora. Ha az f1 fuggveny dencioja a kovetkez}o: void f1(long a) { a += 2L } /* end f1() /
E
S TOMBOK 1.9 MUTATOK 51 akkor a fuggveny semmi hasznosat sem fog csinalni (a BORLAND C++ gyelmeztet is ra), azaz a kovetkez}o kodreszlet utan alfa = 0L f1(alfa) erteke nulla lesz. Hogyan lehet akkor olyan fuggvenyt rni, amelyiknek kimen}o vagy atmen}o parameterei is vannak? Termeszetesen a pointerek felhasznalasaval. Az adott mutato ugyan ertek szerint kerul at, de az altala mutatott tarterulet tartalmat a hvott fuggveny indirekcio utjan megvaltoztathatja Ilyen fuggvenyt a pointerekre vonatkozo "okolszabalyunk" segtsegevel keszthetunk, azaz a fuggvenyben a modostando parameter minden el}ofordulasat a zarojelezett indirekcios

formaval helyettestjuk: alfa void f1(long (*a)) { (*a) += 2L } /* end f1() / es a hvasban is ennek megfelel}oen a valtozo helyebe annak cme kerul: alfa = 0L f1(&alfa) A fenti kodreszlet utan alfa 2-t fog tartalmazni. A C++ az un. reference type segtsegevel sokkal attekinthet}obb megoldast nyujt a cm szerinti parameteratadasra. Ezzel majd a 212-es pontban foglakozunk b}ovebben 1.94 Pointer aritmetika Pointerekkel kulonboz}o aritmetikai m}uveleteket vegezhetunk, ezek a kovetkez}o formajuak lehetnek:
pointer + int,
pointer - int,
pointer - pointer, illetve az els}o ket m}uvelet specialis esetekent
++pointer,
--pointer,
pointer++,
pointer-Minden mutatoval vegzett m}uvelet eseten kepzeljuk el azt, hogy a memoria csak olyan tpusu adatokbol all, mint amilyet az adott mutato megcmez, es ezek egyesevel vannak megszamozva. Tehat peldaul a ptr azonostoju pointerrel valo m}uveletvegzes eseten azt

tetelezzuk fel, hogy a memoria legkisebb megcmezhet}o egysege a rovid egeszt tartalmazo szo. Ha most a mutatohoz hozzaadunk, vagy bel}ole levonunk egy egesz szamot, akkor az a megadott szamu adattal valo el}ore-, vagy hatralepest fogja jelenteni, azaz peldaul a ptr+5 52
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS erteke az a cm lesz, ahol az aktualisan mutatott short utani 5-dik rovid egesz szo elhelyezkedik! a --ptr pedig a megel}oz}o short-ra alltja ptr-t. Mas szoval, ha egy mutatott adat kepzeletbeli sorszama i, akkor a mutatohoz valo n egesz ertek hozzaadasa utan az eredmenyul kapott mutato az i+n sorszamu adatot fogja megcmezni. A fentieket legkonnyebb egydimenzios tombok segtsegevel szemleltetni. Tekintsuk az alabbi denciokat: float vekt"20], *pv = &vekt"4] A pv azonostoju mutatot egy adott adat cmevel inicializaltuk. Ez alkalmazhato statikus helyfoglalasu valtozokra is, mert

csak azt kotottuk ki, hogy ezek inicializatorai nem fugghetnek mas valtozok erteket}ol, de itt nem az ertek, hanem az elfoglalt cm lett felhasznalva. A fenti denciok utan a pv, pv + 3, pv - 2, pv + 20 kifejez esek sorban a vekt tomb 5-odik, 8-adik, 3-adik es { nem letez}o { 25-odik elemenek cmet adjak meg (az utolso tehat szintaktikailag helyes ugyan, de szemantikailag hibas). A pointer - pointer alaku kifejezesnek csak akkor van ertelme, ha a ket mutato altal megcmzett tpus azonos! ekkor az eredmeny a ket adat tavolsaga adat-meretnyi egysegben, vagyis itt is alkalmazzuk a fenti feltetelezest a memoriarol, es az eredmenyt a ket mutato altal kijelolt ket adat sorszamainak kulonbsegekent kapjuk. Peldakent tekintsuk az alabbi fuggvenyt, amely egy karakterlanc hosszat adja vissza: int strlen(s) char *s { register char *p = s while (*p != EOS) { p++ } /* endw / return (p - s) } /* end strlen() / A p mutatot

raalltjuk a sztring elejere, es mindaddig leptetjuk el}ore egyesevel (egy mutatott adattal, jelen esetben egy karakterrel), amg el nem erjuk a karakterlanc veget jelz}o EOS erteket. Eredmenyul eppen azt adjuk vissza, hogy mennyit leptunk el}ore, amg elertuk a sztring veget, vagyis hany "igazi" karakter van a sztringben. A fenti szabvanyos konyvtari fuggveny egy felhasznalasi lehet}osege: char int . l1 = l2 = hiba" ] = "Nincs eleg memoria!" l1, l2 strlen(hiba"0]) strlen(&hiba"6]) Ekkor l1 erteke 19, l2-e 13 lesz. A BORLAND C++ rendelkezik huge mutatokkal, amelyeknel lehet}oseg van arra, hogy ne csak int mennyisegeket adhassunk hozzajuk, illetve vonhassunk le bel}oluk, hanem hasznalhatjuk a pointer + long, illetve pointer - long alaku m}uveleteket is. Ez nem portabilis lehet}oseg, ezert hasznalatanal erre legyunk
E
S TOMBOK 1.9 MUTATOK 53 gyelemmel. Hasonloan, bar ket mutato

kulonbsege C nyelvi dencio szerint int, huge pointerek eset en ez az ertek meghaladhatja a 16 bites hatart. A fordto ezert a kovetkez}o format felismeri es 32 bites kulonbseget szamol (p, q azonos tpusu huge pointerek, l pedig long): l = (long)(p - q) A mutatok kozotti barmifele osszehasonltas (<, >, ==, stb.) csak akkor ad garantaltan helyes es portabilis eredmenyt, ha a mutatok azonos tpusuak, es mindkett}o egy, a mutatott tpusbol feleptett tombre mutat (lasd strlen-nel p  es q, mindketten a hiba" ] tombre mutatnak). Hasonloan garantalt, hogy minden pointer biztonsagosan osszevethet}o NULL-lal, annak eldontesere, hogy a mutato ervenyes cmet tartalmaz-e, vagy sem. 1.95 Tombok hasznalata Tobbdimenzios tombok A C nyelv megengedi, hogy barmilyen adattpusbol tombot hozhassunk letre. Letezhetnek tehat strukturakbol allo tombok, pointerek tombjei, s}ot, tombokb}ol alkotott tombok is. Ezek

deklaratorai illetve kifejezesei a mutatoknal megismert "okolszabaly" analogiajara hozhatok letre: minden szinkaktiakailag helyes kifejezesben barmely azonosto lecserelhet}o egy azonosto"kifejezes] alakra { mas szoval alkalmazzuk a ratort a deklaracional. Peldaul: int i struct tanulo tan char *p int (*pf)(int) float vekt"20] " ] tombtpust kepz}o tpusmodosto ope- int ti"4] struct tanulo osztaly"40] char *tp"10] int (*tpf"5])(int) float mat"5]"20] Az els}o ket pelda mar ismer}os, a kovetkez}o kett}o mutatokbol allo tombok deklaraciojat illusztralja. A tp karaktermutatok 10 elem}u tombje, tpf pedig olyan pointerekb}ol feleptett 5 elem}u tomb, amelyek egeszeket viszszaado es egy egesz parametert varo fuggvenyekre mutatnak. A fenti deklaraciok szerint ervenyes kifejezesek a kovetkez}ok: p = tp"2] tp"0] *(tp"8] + 1) --tp"8] pf =

tpf"4] (*tpf"2])(0) Az utolso pelda tobbdimenzios tombok denialasat mutatja be. A C fordto nem ismeri ugyan a tobbdimenzios tomboket, de a tombok tombjeit igen. Az alabbi mat valtozo egy 5 sorbol es 20 oszlopbol allo matrixnak tekinthet}o: float mat"5]"20] Ez peldaul a kovetkez}o kifejezesekben szerepelhet: 54
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS vekt"3] = mat"1]"2] mat"i]"j] = 0.0 Tobbdimenzios matrixoknak kezd}oerteket adni a szokasos aggregatum inicializalo szintaxissal lehet: short tomb" ]"3] = { { { { { 1, 2, 3 4, 5, 6 7, 8, 9 -1, -2, }, }, }, -3 } } A tomb valtozo e dencio hatasara egy 4 sorbol es 3 oszlopbol allo ketdimenzios tomb lesz a fenti kezd}oertekekkel. Figyeljuk meg, hogy az indexmeretek kozul csak az els}ot hagytuk el, a fordtora bzva annak meghatarozasat a kezd}oertekek alapjan. A masodik (es esetleges tovabbi)

indexhatarok megadasa mindig kotelez}o. Pontosan ez a tobbdimenzios tombok legnagyobb hatranya, nem lehet }oket dinamikusan kezelni. Nem rhatunk segtsegukkel peldaul olyan fuggvenyt, amely egy n  r-es matrixot oszszeszoroz egy r  m-essel, ahol a matrixokon kvul n, r es m is parameterek. 1.96 Kapcsolat tombok es mutatok kozott A kovetkez}okben a pointerek es tombok kozotti szoros kapcsolatot mutatjuk be. Vegyuk el}o az egyik fenti peldat ujra, kicsit mas formaban: float vekt"20], *pv = &vekt"0] Az aritmetikai szabalyok gyelembevetelevel ezek utan a kovetkez}o parostasokat rhatjuk fel: *(pv+0) *(pv+1) *(pv+2) vekt"0] vekt"1] vekt"2] ahol tehat az egyes parosok mindket tagja ugyanarra az tarolasi egysegre hivatkozik. Ha most egy pillanatra elfelejtjuk, hogy pv mutato, akkor a fenti analogia a kovetkez}okeppen tehet}o teljesse: pv"0] pv"1] pv"2] vekt"0] vekt"1]

vekt"2] Ez osszhangban van azzal, hogy a tombbeli indexek az elemeket eppugy sorszamozzak meg, mint ahogy a pointer aritmetikanal a memoria felosztasat elkepzeltuk, azaz egy el}orelepes az indexben egy adattal valo el}orehaladast eredmenyez a memoriaban. A vekt tomb tehat a pv melle elkepzelt memoriastrukturaban helyezkedik el, azaz a kett}ot mintegy egymasra fektettuk. A fenti analogia erdekeben a C nyelv megengedi azt, hogy a pointereket indexelhessuk a fent lert modon, preczen megfogalmazva, a pointer"egesz]
E
S TOMBOK 1.9 MUTATOK 55 alaku kifejezest a fordto *(pointer + egesz) ertelemben alkalmazza. Azert, hogy az indexkifejezes ertelmezese fuggetlen legyen attol hogy tombre vagy mutatora alkalmazzuk, a vekt"0] ertelmezese is legyen *(vekt + 0), azaz vekt, tehat vekt onmagaban a vekt" ] tomb els}o elemere mutato pointer: vekt == &vekt"0]. A kifejezesekben barhol el}ofordulo

tombazonostot a fordto azonnal atalaktja a tomb els}o elemet megcmz}o mutatova, es ha indexkifejezes koveti, akkor azt a pointerek indexelesenek szabalyai szerint ertelmezi. (Innen is latszik, hogy ilyen osszefuggesben a " ] tenyleg az indexel}o operator.) A fenti strlen()-t alkalmazo peldakat is rhattuk volna { es a kes}obbiek folyaman hasonlo esetekben rjuk is { a kovetkez}okeppen: l1 = strlen(hiba) l2 = strlen(hiba + 6) Ebb}ol viszont jol latszik az, hogy egydimenzios tombot fuggvenynek parameterkent tulajdonkeppen nem is lehet atadni, csak egy olyan mutatot adhatunk at, amely az adott tomb els}o (vagy barmelyik) elemere mutat. Hasonloan, ha van a memoriaban egy elegend}oen nagy terulet, es arra mutat egy pointer, akkor az adott pointert ugy tekinthetjuk, mintha tomb volna. Ez a mutatok es tombok kozti szoros kapcsolat teszi lehet}ove, hogy egydimenzios tomboket dinamikus indexhatarral kezelhessunk,

azaz a meretuket elegend}o futasi id}oben rogzteni. Peldaul a fenti vekt hasznalhato a kovetkez}o formaban is: float *vekt, seged . vekt = (float *)malloc(n sizeof(float)) ahol n erteket eleg futasi id}oben meghatarozni. Az gy denialt vekt es az eredeti valtozat hasznalata kozott semmi kulonbseg nincs, csak az indexhatar mas A kovetkez}o ciklus peldaul kinullazza a tombot: int i, n = MERET . for (i = 0 i < n { vekt"i] = 0.0 } /* endfor / i++) A fenti peldaval teljesen ekvivalens az alabbi: for (i = 0, seged = vekt { *seged = 0.0 } /* endfor / i < n i++, seged++) A kulonbseg a ket pelda kozt mindossze annyi, hogy a seged pointer a for ciklus inicializalo reszeben vekt-b}ol megkapja a valos tombunk baziscmet, a ciklusmagban mindig a seged altal aktualisan megcmzett memoriateruletre rjuk be a nullat, es seged-et a for ciklus leptet}o utastas-reszeben inkrementaljuk. Az i ciklusv altozo ebben a

megoldasban csak szamlalokent szerepel. 56
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS Tombok dinamikus kezelesere egy masik peldakent rjunk olyan fuggvenyt, amelyik visszaadja a parameterkent kapott tomb maximalis elemet: double maximum(tomb, m) float tomb" ] register m { float max register i max = tomb"0] for (i = 1 i < m i++) { if (tomb"i] > max) { max = tomb"i] } /* endif / } /* endfor / return max } /* end maximum() / Figyeljuk meg a tomb parameter deklaraciojat, ez egyenertek}u a float *tomb alakkal, de erzekelteti, hogy a pointert tombkent kvanjuk hasznalni. A fuggveny meghvasa peldaul a kovetkez}o formaban tortenhet: m = maximum(vekt, n) Mivel a pointerm}uveletek gyorsabbak az indexeleseknel { ez utobbiak gepi szinten szorzast is igenyelnek { a fenti fuggvenyt a gyakorlatban a kovetkez}okeppen rnank meg: double maximum(tomb, m) register float *tomb int m { float max register float

*veg = tomb + m max = *tomb while (++tomb < veg) { if (*tomb > max) { max = *tomb } /* endif / } /* endw / return max } /* end maximum() / 1.97 A ltalanos mutatok A fentiekben azt lattuk, hogy a mutatoknal a mutatott tpus ismerete milyen fontos, hiszen az aritmetikanak is csak gy van ertelme (peldaul p++ eseten a 1.10 BEVITEL E
S KIVITEL 57 erteke, mint zikai byte-cm annyival n}o meg, mint a mutatott adat merete byte-ban). Ennek ellenere gyakran van szuksegunk "altalanos pointer tpusra" Gondoljunk a malloc fuggvenyre: ennek erteke egy olyan pointer, aminek a tpusat nem ismerjuk, de nem is erdekes, ugyis atalaktjuk explicit konverzioval, miel}ott barmilyen m}uveletet vegeznenk vele. De a malloc-ot is deklaralni kell valaminek! Mi legyen az? A hagyomanyos C implementacioknal az ilyen altalanos pointereket char* tpusunak deklaraltak, ami miatt nem lehetett roluk egyb}ol latni, hogy semmi kozuk sincs a

karakterekhez. A korszer}u fordtok erre a celra bevezettek egy uj tpust: void*. Ezekkel a pointerekkel csak a kovetkez}o m}uveletek vegezhet}ok: tetsz}oleges mutatoertekkel feltolthet}ok, ertekuk tpusdeklaracioval tetsz}oleges pointerre atalakthato, vizsgalhato, hogy tartalmuk NULL-e, vagy sem. Minden egyeb pointerm}uvelet (peldaul indirekcio) tilos p 1.98 Fuggvenyekre mutato pointerek 1.10 Bevitel es kivitel Bar maga a C nyelv denicioja az eddig lertakon kvul lenyegeben nem tartalmaz egyebet, maga a szabvany denial un. standard konyvtarakat, illetve standrd konyvtari fuggvenyeket. Ezek olyan el}oredenialt makrok, illetve lefordtott es targykodu konyvtarakba szervezett fuggvenyek, amelyek majdnem minden C, vagy C++ rendszerben megtalalhatok, es hvasi modjuk, illetve deklaraciojuk az ANSI szabvanynak megfelel. A kovetkez}okben a be- es kimenetet megvalosto szabvanyos fuggvenyek alapelveit, illtve a

fuggvenyek kozul nehanyat tekintunk at. (Maguk a fuggvenydeklaraciok, illetve a kapcsolodo makrodeniciok szabvanyos include le-okban talalhatok) Ezek a fuggvenyek { a UNIX lozoajat atveve { eszkozfuggetlenek, tehat egy program mindig ugy tekintheti az adatatvitel, hogy le-bol olvas es le-ba r, jollehet egy konkret alkalmazasnal a program bemenete valojaban tobbnyire a terminal billenty}uzete, kimenete pedig a tarminal keperny}oje, vagy egy nyomtato. A masik altalanos alapelv, hogy az adatatvitel egysege a byte, es a le-ok hossza is byte-ban meghatarozott. A C nyelvben a byte, mint fogalom nem letezik, ezert itt char hasznalando. A be- es kivitel targyalasat ket f}o csoportba oszthatjuk: az alacsony szint}u (low-level) es a folyam jelleg}u (stream) adatatvitelre. A C-ben a le-ok kezelesenek az MS-DOS operacios rendszer alatt ketfele modja van. Ennek az az oka, hogy a C nyelvben denialt nn ujsor karakternek

az operacios rendszerben a CR-LF karakterparos felel meg Azert, hogy szovegle-okat portabilis modon olvashassunk, a megfelel}o C rutinok elvegzik a szukseges konverziokat, eltuntetve szamunkra ezt a rendszersajatossagot. Ha viszont binaris adatokat kezelunk, akkor a fenti konverzio osszekeveri es elrontja azokat. Ezert minden le-hoz hozza kell rendelni egy kezelesi modot megnyitaskor, ha ezt nem tesszuk meg, az alapertelmezes altalaban a szoveges, konverzios uzemmod, de ez beallthato binarisra is. Az el}ore megnyitott standard allomanyok kezelesi modja szoveges A le kezelesi modja fuggetlen attol, hogy alacsony szint}u, vagy folyam jelleg}u fuggvenyekkel manipulaljuk. 58
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 1.101 Alacsony szint}u I/O Az alacsony szint}u be/ki m}uveletek a le-lero (le descriptor, le handle) segtsegevel hivatkozhatnak a hasznalni kvant allomanyokra. A le-lero egy kis egesz szam,

amely ketfele lehet: az operacios rendszert}ol indulaskor kapott, vagy egy konyvtari fuggveny hasznalataval nyert. Az indulaskor kapott (predened) le-lerok a 0, 1 es 2. A 0 az un standard bemenet (altalaban a terminal, de DOS szinten atiranythato, lasd <,j), az 1-es a standard kimenet (altalaban a keperny}o, de szinten atiranythato), a 2-es pedig a standard hibakimenet, amely mindig a keperny}ore kerul. Ezek portabilisak minden implementacional A BORLAND C++-ban rendelkezesunkre all a fentieken kvul a 3-as lero, amely a COM1 soros vonalat, es a 4-es, amelyik a PRN printert kezeli. A 0 es 3 hasznalhato bevitelre, a tobbi { es a 3-as is { kivitelre Tetsz}oleges le megnyithato az open konyvtari fuggveny segtsegevel { lerasat lasd a fuggvenyek ismertetesenel { es a visszaadott ertek sikeres megnyitas eseten a le-lero (egyebkent -1). A le-lero birtokaban tetsz}oleges helyr}ol tetsz}oleges

szamu byte-ot kirhatunk az adott allomanyba az aktualis pozciotol kezdve a write fuggveny segtsegevel, illetve az aktualis le-pozciotol olvashatunk adott teruletre tetsz}oleges szamu byte-ot (legfeljebb a le vegeig) a read hasznalataval. A read es a write az atvitelt minden konverzio nelkul vegzi. Vigyunk ki peldaul az fd leroval kezelt le-ba egy lebeg}opontos tombot: float vekt"20] . n = write(fd, (char *)vekt, sizeof(vekt)) A forrasteruletet karaktermutatokent varja a fuggveny, ezert alkalmaztunk tpuskonverziot, a kiviend}o byte-ok szamanak meghatarozasat a fordtora bztuk. Ha a visszaadott ertek ezzel nem egyezik meg, akkor le-kezelesi hiba tortent. Az adatok visszaolvasasa analog modon tortenik. Hasznos lehet meg az lseek fuggveny is, ezzel a le-ba ras illetve le-bol olvasas aktualis pozciojat allthatjuk a kvant helyre (a le-t mint egy lassu eleres}u tombot hasznalhatjuk).

Ha egy allomanyt le akarunk zarni, a close fuggvenyt hvjuk meg. 1.102 Folyam jelleg}u I/O A folyam jelleg}u allomanykezelesnel az alapvet}o m}uvelet egy karakter beolvasasa es kirasa. A folyamok azonostasa le-mutatokkal tortenik, amelyek szerepe hasonlo az alacsony szint}u kezelesnel hasznalt le-lerokehoz. A FILE egy, a rendszer altal az stdio.h include le-ban denialt struktura, es a le-mutato egy ilyen strukturat megcmz}o pointer. A le-mutatok kozott szinten vannak el}oredenialtak, ezek az stdin, stdout, stderr, es ugyanaz a jelentesuk, mint a 0-as, 1-es es 2-es le-leroknak. (A 3-as es 4-es leroknak az stdaux es stdprn el}ore denialt le-mutatok felelnek meg.) Egyeb le-mutatok a FILE* fopen(const char name, const char mode) deklar acioju konyvtari fuggveny hvasaval nyerhet}ok egy adott allomany megnyitasa kapcsan. (A name sztring a megnyitando allomany neve, mode pedig az allomany kezelesi

modjat { ras, olvasas, hozzaf}uzes { hatarozza meg.) A le-megnyitasi hibakat a visszaadott NULL  ertek jelenti. Egy karakter beolvasasat a getc() makro vegzi: c = getc(fp) 1.10 BEVITEL E
S KIVITEL 59 Itt fp egy korabbi fopen hvas altal visszaadott erteket tartalmazo, FILE *fp dencioju valtozo. A getchar() makro a getc(stdin) makrohvasnak egy rovidtett formaja. Ha a visszaadott ertek az stdioh-ban denialt EOF szimbolum, akkor az adott le vegere ertunk A kivitel a putc(c, fp) makroval tortenik, ahol c a kiirando karakter. A putchar(c) hasonloan a putc(c, stdout) r ovidtesere szolgal. Ezekben makrokban a parameter csak egyszer kerul kiertekelesre,gy nem kell tartanunk kellemetlen mellekhatasoktol, ha bonyolultabb kifejezeseket hasznalunk aktualis parameterkent. E makrok hasznalatara vonatkozo peldakat a pelda.c programban talalhatunk Formatumozott outputot a int printf(const char* format, .),

illetve az int fprintf(FILE* outfile, const char format, .) deklaracioju fuggvenyekkel allthatunk el}o Az el}obbi a standard outputra (stdio), mg az utobbi az outfile le-pointer altal meghatarozott, rhato le-ba nyomtat. A nyomtatasi kepet a format sztring hatarozza meg. A fuggvenyek visszateresi ertekul a formatum specikacio szerint kinyomtatando parameterek szamat adjak. A format sztring ketfele karaktert tartalmazhat. Egyreszt normal karaktareket, amelyek minden tovabbi nelkul a kimeneti allomanyba masolodnak, masreszt konverzio specikaciokat. A konverzio specikaciok hatasara a format sztringet k ovet}o tovabbi argumentumok kerulnek rendre kinyomtatasra az egymast kovet}o specikaciok alapjan. Minden specikacio egy szazalekjel (%) karakterrel kezd}odik, es egy vezerl}o karakterrel zarul. A % es a vezerl}o karakter kozott meg az alabbi karakterek allhatnak (a felsorolas szerinti sorrendben):


Egykarakteres jelz}o ag. Elhagyasa eseten vezet}o nullakkal, vagy szokoz karakterekkel kitoltve, az adott mez}oben jobbra igaztva keletkezik az output. Ha megadunk valamilyen ag-et, akkor az a kovetkez}o lehet: Egy - (minusz jel), ami azt jelenti, hogy a konvertalt argumentumot balra igaztva kell kinyomtatni, vagy egy + (plusz jel), ami egeszek eseteben el}orja, hogy az el}ojel mindig ki legyen nyomtatva. Ha ag-kent a # (hash-mark) karaktert adjuk meg, akkor egy un. alternatv nyomtatasi kepet kapunk Az o vezerl}o karakter eseten minden nem nulla szam vezet}o 0-val, x, vagy X vezerl}o karakterek eseten minden esetben 0x, illetve 0X el}otaggal lesz kinyomtatva. Az e, E es f vezerl}o karakterek eseten mindig kapunk tizedes pontot, g es G eseten szinten, de a vezet}o 0-k elmaradnak.
Mez}osz
eless
eg Ez egy egesz szam, amelyik a minimalis mez}oszelesseget adja meg. A konvertalt argumentum legalabb ilyen szeles mez}on lesz kinyomtatva, szukseg

eseten az ures helyek szokoz karakterrel lesznek kitoltve. Ha 0-val kezd}odik a mez}oszelesseg, akkor a kinyomtatott szamok vezet}o 0-kat kapnak Ha a * karaktert adjuk meg mez}oszelessegkent, akkor a tenyleges mez}oszelesseg erteket az argumentumlistaban soron kovetkez}o adat hatarozza meg. (Ez az ertek nem kerul konvertalasra)
Egy pont, ami a mez}oszelessegt}ol elvalasztja a pontossagot el}oro erteket.
Pontoss
ag Ez egy egesz szam, amelyik megadja, hogy egy sztringb}ol maximalisan hany karakter keruljon kinyomtatasra, vagy megadja egy lebeg}opontos
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 60 szam tizedes pontja utan nyomtatando ertekes jegyek szamat, vagy egy egesz szam minimalisan nyomtatando jegyeinek a szamat rja el}o. Ha a pontossag a specikaciobol kimarad, akkor a konvertalas soran az alapertelmezes szerinti ertek (6) lesz gyelembe veve. Ha 0-t runk el}o, akkor a d, i, o, u, x, illetve X vez

erl}o karakterek eseten az alapertelmezes szerinti szamu jegy lesz kinyomtatva, az e, E es f vezerl}o karakterek eseten elmarad a tizedes pont. A * karakter megadasa azt jelenti, hogy a tenyleges pontossag erteket az argumentumlista soron kovetkez}o eleme tartalmazza. M
odos
t
o el}otag A modosto el}otag karakter kozvetlenul a vezerl}o karakter el}ott all. Lehetseges ertekei a kovetkez}ok: Egy h, ha egy egesz szamot short-kent, vagy egy l (ell bet}u), ha long-kent kell nyomtatni. A BORLAND C++ban pointerek nyomtatasa eseten alkalmazhatjuk meg az N, illetve az F el}otagokat is. Az el}obbi hatasara near, mg az utobbi hatasara far pointer-formatumu lesz a konvertalt ertek Mint emltettuk, a mez}oszelesseg vagy a pontossag helyett megadhatjuk a * karaktert is. Ebben az esetben a megfelel}o erteket az eddig feldolgozott argumentumokat kovet}o els}o argumentum { ami egy int tpusu kifejezes kell legyen { fogja meghatarozni. Peldaul

a
printf("%.*s",max,str) utastas hatasara az str sztringb}ol a max valtozoban lev}o ertek altal meghatarozott szamu karakter kerul a standard kimenetre. A formatum sztringben hasznalhato vezerl}o karaktereket a 1.6 tablazatban foglatuk ossze. Figyelem! A printf fuggveny az els}o parametere alapjan hatarozza meg, hogy meg hany, es milyen tpusu tovabbi parametere van. Mindenfele "szemet" kerulhet az outputra, ha a formatum sztringet nem a specikacionak megfelel}o szamu, vagy tpusu parameter koveti. A printf-r}ol elmondottak termeszetesen a printf-fuggvenycsalad tobbi tagjara (fprintf, sprintf) is vonatkoznak (Az sprintf fuggveny ugyanazt vegzi, mint az fprintf, de le helyett egy karaktertombbe "nyomtat"). Az int scanf(const char * format, .) deklaracioju fuggveny a printf f uggvenynek megfelel}o beolvaso rutin. Ez a fuggveny az stdin allomanyrol olvas be adatokat, es az esetek

tobbsegeben a printf konverziok fordtottjat hajtja vegre. A scanf karaktereket olvas a standard inputrol, a format formatumspecikalo sztring szerint ertelmezi es konvertalja azokat, es a tovabbi argumentumai { amelyek a formatum specikacionak megfelel}o tpusu tarolasi egysegekre mutato pointerek { altal meghatarozott memoria helyekre rja be a beolvasott ertekeket. A scanf befejezi az olvasast, ha a specikacionak megfelel}o szamu adatot mar beolvasott, vagy ha az input valamilyen oknal fogva nem felel meg formatum-specikacionak. Visszateresi ertekul a sikeresen beolvasott adatok szamat adja meg a scanf. Ez jol hasznalhato arra, hogy ellen}orizzuk, tenyleg annyi adatot olvasott-e be a programunk, mint ahanyat kellett. Ha le vege utan olvasnank a scanf-fel, akkor visszateresi ertekul az EOF-ot (end of le) kapjuk. Az EOF szimbolum az stdioh include le-ban van denialva Ha viszszateresi ertekul 0-t kapunk, ez azt

jelzi, hogy a soron kovetkez}o beolvasando 1.10 BEVITEL E
S KIVITEL 61 Karakter Argumentum Nyomtata
si k
ep t
pus d, i int el}ojeles decimalis egesz o int el}ojel nelkuli oktalis egesz x, X int u int el}ojel nelkuli decimalis egesz c int unsigned char-r a s char* f double e, E double g, G double p void* % | hexadecimalis egesz a vezet}o 0x, vagy 0X el} otag nelkul valo konvertalas utan a megfelel}o karakter sztring karaktereit nyomtatja EOS-ig, vagy az adott mez} oszelesseg hataraig. -]m.dddddd, ahol a d-k szama az el}ort pontossagtol fugg. A pontossag alapertelmezesben 6, a 0 pontossaggal a tizedes pont nyomtatasa elnyomhato -]m.dddddd e xx, vagy -]m.dddddd E xx, ahol a d-k szama az el}ort pontossagtol fugg. ugyanaz, mint %e, vagy %E, ha az exponens kisebb, mint -4, vagy nagyobb-egyenl}o, mint a pontossag egyebkent ugyanaz, mint %f. Nincsenek vezet}o 0-k, vagy szokozok. pointer-ertek!

implementacio fugg}o, a BORLAND C++-ban tarmodellt}ol is fugg. nincs konverzio, maga a % karakter nyomtatodik 1.6 tablazat A printf fuggvenycsalad formatum-specikalo sztringjeinek vezerl}o karakterei 62
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS karakter nem felel meg a formatum-specikacionak. A format sztring az alabbi karaktereket tartalmazhatja:
Tetsz} oleges whitespace karakter, amelyeket a a scanf gyelmen kvul hagy.
Normal karakterek a % kivetelevel. Ezek meg kell hogy egyezzenek az input folyam els}o nem whitespace karakterevel.
Konverzio specik aciok. Ezek a % karakterrel kezd}odnek es opcionalisan tartalmazhatjak a * karaktert (melynek hatasara a beolvasott adatot atugorja a scanf), egy mez}oszelesseget megado szamot, a beolvasott adat tarolasi meretere (peldaul short vagy long egesz, float vagy double lebeg}opontos szam) utalo h, l (kis ell), vagy L karaktereket es vezerl}o karaktereket. A scanf form

atum-specikalo sztringjenek vezerl}o karaktereit a 1.7 tablazatban foglatuk ossze. A BORLAND C++ lebeg}opontos szamok beolvasasa eseten az L adatszelessegre utalo karaktert a long double tpus szamara tartja fenn. A BORLAND C++-ban megadhato meg az N es az F karakter is, amellyel a beolvasando pointerek near, illetve far ertelmezesere utalhatunk. A d, i, o es x konverziot vezerl}o karakterek el}ott allhat a h el}otag, amely azt jelzi, hogy int* helyett short tpusu pointer all az argumentum-lista megfelel}o helyen, illetve az l, vagy L el}otaggal azt jelezhetjuk, hogy int* helyett longra mutatato pointer talalhato az argumentum-listaban. Ez utobbi esethez hasonloan az e, f es g vezerl}o karakterek el}ott allo l, vagy L el}otag arra utal, hogy float helyett double adattal van dolgunk. A BORLAND C++-ban az L el} otag a long double tpusu adatok specikalasara szolgal. Ahogy a formatumozott outputtal kapcsolatban fuggvenycsaladrol

beszeltunk, ugyangy letezik a beolvasasra is a scanf fuggvenycsalad. Ha stdin helyett egy valamilyen mas allomanyra vonatkozo adatfolyambol szeretnenk olvasni, akkor az fscanf fuggvenyt hasznaljuk. Sztringb}ol valo "olvasasra" az sscanf fuggveny szolgal. Mind a printf, mind a scanf fuggvenycsalad eseteben a n vezerl}o karakter hatasara a mar konvertalt karakterek szama a specikaciohoz tartozo int* tpusu az argumentum altal megcmzett memoriahelyre kerul! nem tortenik semmifele konverzio, es a konvertalt adatok szamlaloja sem inkrementalodik. 1.10 BEVITEL E
S KIVITEL 63 Karakter Input adat d i Argumentum t
pus decimalis egesz int* egesz szam akar oktalis (vezet}o 0), akar hexadecimalis (vezet}o 0x, vagy 0X) form aban o oktalis egesz a vezet}o 0 el}otag nelkul u el}ojel nelkuli decimalis egesz x hexadecimalis egesz, akar a 0x, vagy el}otaggal, akar anelkul karakter(ek). A soron

kovetkez}o karakter (alapertelmezesben csak 1) kerul a megfelel}o memoriateruletre. A whitespace karakterek is beolvasasra kerulnek kovetkez}o nem whitespace karakter olvasasahoz a %1s specikaciot hasznaljuk. int* int* unsigned int* int* 0X c s f, e, g p % sztring beolvasasa. A specikaciohoz tartozo pointer egy olyan tombre kell mutasson, amely elegend}oen nagy a beolvasando karakterek es a sztring veget jelz}o EOS tarolasara. E harom vezerl}o karakter szolgal lebeg}opontos szamok beolvasasara. Az el}ojel, a tizedes pont es az exponens opcionalis Ha a specikacioban az l, vagy az L el}otag is szerepel (peldaul %lf), akkor az argumentum tpusa: a printf altal produkalt formatumu pointer erteket olvassa be nincs hatasa char* char* float* double* void* | 1.7 tablazat A scanf fuggvenycsalad formatum-specikalo sztringjeinek vezerl}o karakterei 64
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 1.11 A main fuggveny

Minden C program kotelez}oen tartalmaz egy main nev}u fuggvenyt. Denialasanak helye lenyegtelen, akarmelyik forrasle tartalmazhatja tetsz}oleges elhelyezesben, a vezerlest a program indulasakor { a megfelel}o inicializalo rendszerrutin (startup kod ) lefutasa utan { mindenkepp a main kapja meg. A main visszateresi tpusat ketfelekeppen is meg lehet adni: int-nek es voidnak deklaralva. (Ne feledjuk, ha nem adunk meg tpust a denicioban, a fordto automatikusan int-et tetelez fel.) A visszaadott ertek, ha van, a program un statuszkodja lesz. Ezt a program futasa utan megvizsgalhatjuk a DOS-ban az ERRORLEVEL batch funkci oval. Amennyiben programunkat nem a COMMAND.COM indtotta el, hanem egy masik felhasznaloi program hvta (lasd a spawn es exec fuggvenycsaladot a process.h include le-ban), akkor az megkapja a visszaadott st atuszkodot, es felhasznalhatja annak eldontesere, hogy programunk sikeresen futott-e le, vagy sem.

Megallapodas szerint a 0 statuszkod sikeres vegrehajtast jelent, az ett}ol elter}o ertekekkel pedig a hiba jelleget is lehet kozolni (peldaul fatalis hiba, lekezelesi hiba, CTRL BREAK, stb.) Minden komolyabb programnak illik viszszaadni statuszkodot { erre legtobbszor az exit fuggvenyt hasznaljuk (melyet szinten a process.h le-ban denialtak) Ennek el}onye, hogy a hibat eszlel}o barmely rutinbol meghvhato az exit, nem szukseges a vezerlest { a hibainformacio cipelesevel { visszajuttatni a main-hez, bar sokszor eleg nehez megtalalni egy eldugott exit hvast. A main meghvasakor 3 parametert kap, de ezek kozul csak annyit kell atvennie, amennyire tenylegesen szuksege van. Elhagyni azonban csak hatulrol el}ore haladva lehet a parameterlistarol. A main komplett deklaracioja: | int main(int argc, char *argv" ], char env" ]) Az argc parameter megadja a parancssorban atadott argumentumok szamat. Az argv" ] az

egyes parametereket tartalmazo sztringekre mutato pointerek tombje, az env" ] pedig az un. kornyezeti valtozokat (environment variables) es ertekuket tartalmazo sztringek mutatotombje. Ha programunk neve PROG, akkor a SET KV=ALMA PROG alfa beta GAMMA DOS parancssorok hatasara a PROG-ban lev}o main parameterei gy alakulnak:
argc erteke 4,
argv"0] a PROG teljes eleresi u tjara mutat (bar megjegyzend}o, hogy a DOS 3.0-as, vagy korabbi verzioi eseten argv"0] ures sztringre mutat),
argv"1] az "alfa" sztringre mutat,
argv"2] a "beta" sztringre mutat,
argv"3] a "GAMMA" sztringre mutat,
argv"4] erteke NULL,
env"n] a "KV=ALMA" sztringre mutat.

1.12 TOVABBI MAGYARAZATOK 65 Az n erteke fugg attol, hogy milyen kornyezeti valtozok voltak mar korabban denialva (peldaul PATH, COMSPEC, PROMPT). Az env tomb veget szinten a NULL ertek}u elem

jelzi. 1.12 Tovabbi magyarazatok 1.121 A balertek es jobbertek fogalma Egy tarterulet-foglalo tarolasi egysegre vonatkozo kifejezest balerteknek (angolul lvalue) nevezzunk. Ez nyilvanvaloan konstansokat, valtozokat es dinamikusan lefoglalt memoriateruleteket jelent. (A konstansok olyan tarterulet-foglalo egysegek, amelyeknek nincs azonostojuk) Szorosabb ertelemben veve a balertek egy olyan tarolasi egysegre vonatkozo kifejezes, amelynek ertek adhato. Nyilvanvaloan balertek egy megfelel}o tpusu es tarolasi osztalyu valtozo azonostoja. Vannak olyan operatorok, amelyek eredmenyul balerteket szolgaltatnak. Peldaul ha E egy tarterulet-foglalo tarolasi egysegre mutato pointer tpusu kifejezes, akkor *E egy olyan valtozo, amire E mutat. A balertek elnevezes az ertekado operatorral kapcsolatos: az %E = E2 tpusu ertekado m}uveletek bal oldalan allo %E operandus balertek kell legyen. Roviden

ugy is fogalmazhatunk, hogy minden olyan kifejezes, amelynek ertek adhato, balertek. Minden olyan kifejezest, amit ertekul adhatunk, jobberteknek (angolul rvalue-nak) nevezunk. A fentiek alapjan persze az is nyilvanvalo, hogy nem minden balertek szerepelhet ertekadas baloldalan (lasd a konstansokat) Tekintsuk az alabbi deniciokat: char buffer"256] char *chptr, ch1 const char xchar = x char *get buff pos(int i) { if (i < 0 || i > 255) { return &ch1 } else { return buffer+i } } A fenti deniciok szerint helyes ertekadasok lehetnek az alabbiak: chptr = get buff pos(12) ch1 = xchar *get buff pos(1) = b /* &buffer"12] lesz / A fenti ertekadasokban szerepl}o balertek kifejezesek rendre chptr, ch1, *get buff pos(1). Az els}o ket pelda trivialis: mindket esetben egyszer}u valtozorol van szo, melyeknek minden tovabbi nelkul ertek adhato. A harmadik pelda azt mutatja 66
A BORLAND C++-BAN 1. FEJEZET C

PROGRAMOZAS be, hogy hasznalhatjuk ki azt, hogy egyes operatorok balerteket kepeznek. A fuggvenyek visszateresi erteke a C-ben nem hasznalhato fel balertekkent (ezen valtoztat majd a C++-ban az un. referencia tpusu visszateresi ertek { lasd a 2.12-es reszt), de az indirekcio oeratorral, a *-gal a get buff pos fuggveny karakterre mutato pointer tpusu visszateresi ertekeb}ol azonnal egy tenyleges valtozot { a buffer tomb 1. index}u elemet { alltjuk el}o, amely mar termeszetesen felhasznalhato balertekkent Felmerulhet az a kerdes, hogy xchar miert nem szerepelt a fenti ertekado utastasok kozt baloldalon. Nos azert, mert ezt a "valtozo"-t a const modosto szoval denialtuk, es mint mar emltettuk, az gy denialt tarolasi egysegeket konstansnak tekinti a fordto, azaz ertekuk modostasat nem teszi lehet}ove, bar maga az xchar kifejezes balertek. 1.122 Meg egyszer a

deklaraciokrol es a tpusokrol Amint arra a 1.91-es reszben utaltunk, az alaptpusokbol (es persze a felhasznalo altal denialt tpusokbol is) a tpusmodosto operatorok felhasznalasaval (lasd a 1.4-es tablazatot) ujabb tpusokat szarmaztathatunk A szarmaztatott tpusok jelolesevel es precedenciajaval kapcsolatos ismereteket is attekintettuk. Ezek megerteset talan nehezti, hogy a * tpusmodosto operator prex operator, mg a tombtpust kepz}o " ] operator es a fuggvenytpust kepz}o ( ) operator postx operator. Ennek kovetkezteben sokszor zarojelezni kell, hogy egy adott denicio az elkepzeleseink szerinti tpust eredmenyezze Bonyolultabb tpusok eseten celszer}u a typedef hasznalata, de egyszer}ubb esetekben ez sokszor elmarad. Gyakori, hogy egy szarmaztatott tpusu tarolasi egysege deklaracioja soran tortenik a tpusdenialas is. Erre tipikus pelda a pointer valtozok deklaralasa,

mint peldaul int* ip vagy egyszerre tobb tpusmodosto operatort is alkalmazva, amint azt az alabbi peldak szemleltetik: int* v"10] int (*p)"10] A fenti deklaraciok szerint v egy 10 elem}u pointer-tomb, p pedig egy egy 10 elem}u vektorra mutato pointer. (Mivel a " ] precedenciaja magasabb, mint a * tpusm odosto operatore, a p ponter deklaraciojakor zarojeleznunk kellett.) Elegge faradtsagos dolog lenne, ha egy program minden egyes azonostojat egyenkent kene deklralni. Ez kulonosen igaz abban az esetben, ha az egyes tarolasi egysegek azonos tpusuak. Amint azt a 144-es alfejezetben lattuk, lehet}osegunk van arra, hogy egy deklaracioban azonostolistat alkalmazzunk: a int x, y deklar acio egyenertek}u az int x int y deklar aciokkal. Fontos azonban megjegyezni, hogy amikor a fenti peldahoz hasonlo szarmaztatott tpusu valtozokat deklaralunk, akkor a tpusmodosto operatorok csak egyetlen

listaelemre vonatkoznak. Tehat peldaul az int* p, y deklaracio az int* p int y

1.12 TOVABBI MAGYARAZATOK 67 deklaracioval egyenertek}u, azaz y tpusa int lesz, nem pedig egeszre mutato pointer. Az a velemenyunk, hogy minden osszetettebb tpust denialjuk onallo tpuskent a typedef kulcsszo segtsegevel, keruljuk az adatdeklaracio soran a tpusszarmaztatast. 1.123 Fuggvenyek valtozo szamu parameterrel A 1.102-es reszben ismertetett printf, illetve scanf fuggvenyek (fuggvenycsaladok) tipikus peldai a valtozo parameterlistaju fuggvenyeknek A tovabbiakban a printf fuggveny egy minimal implementaciojan keresztul mutatjuk be, hogyan keszthetunk portabilis, valtozo hosszusagu parameterlistaval rendelkez}o C fuggvenyeket. Fuggvenyunket a kovetkez}okeppen deklaraljuk: void minprintf(const char *fmt, .) Azert void tpusu a fuggveny, mert az egyszer}useg kedveert ebben a peldaban a

konvertalt adatok szamaval nem foglakozunk, gy azt visszateresi ertekul sem tudjuk szolgaltatni. A deklaracioban a csak a formalis parameterlista utolso elemekent szerepelhet, es legalabb egy megnevezett argumentumot kell deklaralnunk ahhoz, hogy a valtozo hosszusagu parameterlistat majd kezelni tudjuk. A szabvanyos stdarg.h include le tartalmazza azokat a makrokat, amelyek a valtozo hosszusagu parameterlistak kezelesehez szuksegesek. Az egyes makrok megvalostasa gepr}ol gepre valtozhat, de a makrok egyseges feluletet teremtenek a poblema kezelesehez. A va list tpus szolgal arra, hogy a soronkovetkez}o fuggvenyargumentumra vonatkozo informacio tarolasara valo valtozot { egy argumentum-pointert { deklaralhassunk. A va start( ) makroval inicializalhatunk egy ilyen valtozot Az inicializalas eredmenyekeppen az argumentum-pointer az els}o azonosto nelkuli argumentumra fog mutatni. Mint emltettuk,

legalabb egy azonostoval rendelkez}o elemet kell hogy tartalmazzon a formalis parameterlista Ezt hasznalja fel a va start( ) makro az argumentum pointer inicializalasahoz. A va arg( ) makroval lephetunk tovabb a kovetkez}o azonosto nelkuli argumentumra. Ez a makro a soron kovetkez}o aktualis parametert szolgaltatja ertekul. Ennek a makronak ket parametere van Az els}o az argumentum-pointer, a masodik pedig egy tpusazonosto, amely megszabja, hogy milyen legyen a visszateresi ertek tpusa, es hogy az argumentum-pointert milyen mertekben (hany byte-tal) kell tovabbleptetni. A va end( ) makro szolgal arra, hogy "rendet rakjon" egy valtozo hosszusagu parameterlistaval rendelkez}o fuggvenyb}ol valo visszateres el}ott. Ezt a makrot mindig meg kell hvni egy ilyen fuggvenyb}ol valo kilepes alkalmaval. Ezek utan nezzuk meg az egyszerustett printf fuggveny listajat!
A BORLAND C++-BAN 1. FEJEZET C

PROGRAMOZAS 68 #include <stdarg.h> /*/ void minprintf(const char *fmt, .) /* */ /* Valtozo hosszusagu parameterlista kezelesenek bemutatasa / /* a minimalis printf funkciok kapcsan. Mezoszelesseg, stb */ /* kimarad, konverzio es nyomtatas az eredeti printf-fel. */ /*/ { va list ap /* argumentum pointer */ char *p, /* fmt-n szalad majd vegig */ *sval /* ->sztring tipusu parameter erteke */ int ival /* int tipusu parameter erteke */ double dval /* double tipusu parameter erteke */ va start(ap, fmt) /* ap az fmt utani elso arg.-ra mutat for (p = fmt, *p, p++) /* p-t EOS-ig lepteti { if (*p != %) { putchar(p) } / Csak masolas else /* specifikacio feldolgozasa: { switch(*++p) { case d: ival = va arg(ap, int) printf("%d", ival) break */ */ */ */ case f: dval = va arg(ap, double) printf("%f", dval) break case s: for(sval = va arg(ap,char*) { putchar(*sval) } break default: *sval sval++) putchar(*p) break } } } va end(ap) /* Takaritas a fuggveny vegen */ }

/*/ 1.13 Osszetett mintapelda Jelen peldank egy igen exibilis menukezel}o rendszer vazat tartalmazza. Az itt felhasznalt megoldasok sokat segthetnek a tpusdeniciokkal, strukturakkal, pointerekkel, fuggveny-pointerekkel kapcsolatban lertak megerteseben. E pelda f}o celja a portabilis programozasi stlus bemutatasa, masreszt igyek- 1.13 OSSZETETT MINTAPE
LDA 69 szunk ravilagtani arra, hogy egy celszer}uen megtervezett adat- es szubrutinstruktura mennyire attekinthet}ove es konnyen modosthatova teszi a felhasznaloi programjainkat. Felhvjuk az olvaso gyelmet, hogy ezzel a peldprogrammal nem azt akarjuk sugallni, hogy ez az igazi menukezel}o, illetve felhasznaloi felulet. Leteznek olyan objektum-orientalt konyvtarak, amelyek az itt lertaknal sokkal fejletteb felhasznaloi feluletet valostanak meg { termeszetesen hasznalatukhoz ismerni kell a C++-t, illetve ha Windows alkalmazoi programot kesztunk, a

programvezerlesr}ol es a menukr}ol alkotott kepunket mindenkeppen at kell alaktanunk. 1.131 A tervezes egyes fazisai Minden programfejlesztesi munka soran el}ojon az a feladat, hogy az adott program szamara egy felhasznaloi feluletet (user interface-t) kell rni. Ez a felulet az esetek legnagyobb reszeben valamilyen menurendszert jelent. Egy menurendszert ugy celszer}u kialaktani, hogy az altala nyujtott szolgaltatasok az egesz felhasznaloi programban igenybevehet}ok legyenek, es a felhasznaloi program tobbi reszeben lehet}oseg szerint ne kelljen a keperny}o- es billenty}uzetkezelessel foglalkozni. Az egesz felhasznaloi program, illetve a hozzakapcsolodo menurendszer tervezesekor egy masik fontos szempont az, hogy a program bels}o vezerlesi szerkezetei tukrozzek azt a vezerlesi szerkezetet, amit a felhasznalo eszlel a program hasznalata soran. Maskeppen ezt ugy fogalmazhatjuk meg, hogy ne az egyes programfunkciok

aktivizaljanak kisebbnagyobb menurutinokat, hanem egy atfogo, hierarchikus menurendszer gondoskodjon arrol, hogy mindig a felhasznalo kvansaga szerinti programfunkciok legyenek aktivizalva. Portabilitasi megfontolasok Ha faradtsagos munkaval megtervezunk es letrehozunk egy, a fenti kvanalmaknak megfelel}o felhasznaloi feluletet, celszer}u azt ugy programozni, hogy ne csak IBM-PC kompatibilis szamtogepeken, a DOS operacios rendszer alatt, BORLAND C++ fordtoval lefordtva fusson, hanem jol korulhatarolt modostasok utan barmely, C fordtoval rendelkez}o geptpuson, barmely operacios rendszeren (pl. VT100-as terminalokkal rendelkez}o VAX gepeken Ultrix operacios rendszerben) is hasznalhassuk a megrt rutinjaink tobbseget Ennek erdekeben celszer}u a megrando menurendszert 3 reszre osztani. Az els}o resz tartalmazza a legmagasabb szint}u fuggvenyeket, amelyek vatoztatas nelkul portabilisak. A masodik,

kozbens}o szint tartalmazza azokat a fuggvenyeket, amelyeknek torzset az aktualis C fordto es operacios rendszer rendszerfuggvenyei, illetve az aktualis szamtogep-konguracio keperny}oje szerint modostani kell. A harmadik, legalacsonyabb szinten celszer}u elhelyezni a teljesen hardver-specikus fuggvenyeket Ilyenek lehetnek peldaul az IBM PC BIOS rutinhvasok. Jelen peldankban csak a legmagasabb szint}u reszeit mutatjuk be menukezel}o rendszerunknek. A masodik, es harmadik csoprtba tartozo fuggvenyek kozul csak a kozvetlenul felhasznalt fuggvenyek deklaracioit kozoljuk rovid magyarazatokkal. 70
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS A latvany (look-and-feel) megtervezese Alapvet}oen a BORLAND C++ integralt fejleszt}oi kornyezetenek menukoncepciojat igyekszunk megvalostani a hot key-k kivetelevel. Igyekszunk egy egyszer}u help-rendszert is megvalostani, de nem celunk a BORLAND C++ kornyezetfugg}o

rendszerenek a lemasolasa. A menurendszert ugy latja a felhasznalo, hogy tobb alfanumerikus ablak van a keperny}on. A BORLAND C++ erre tenylegesen is lehet}oseget nyujtana, de a hordozhatosag miatt ezt nem hasznaljuk ki. A menukezel}o rendszerben az osszes karakternyomtato utastas az egesz keperny}ore vonatkozik, mi magunk gyelunk arra, hogy csak a keperny}o bekeretezett reszen tortenjen nyomtatas. A keperny}on mi magunk hozunk letre keretezett reszeket, dobozokat az IBM PC kiterjesztett karakterkeszletevel. A felhasznalt jobb fels}o sarok, bal fels}o sarok, fugg}oleges vonal, stb. karakterek egyes szamtogep terminalokon is leteznek, "termeszetsen" mas kodokkal, gy celszer}uen ezeket peldaul a #define direktvaval szimbolumokhoz rendeljuk. Minden menu egy ilyen dobozba kerul, az egyes almenuk dobozai a szul}o menu dobozatol egy kicsit lejebb kerulnek a keperny}ore. Kesztunk egy f}omenu keretet is Ennek a

legfels}o sora lesz a f}omen}u, azaz az egymastol fuggetlen menufak gyokerenek a gy}ujt}ohelye A f}omen}ub}ol az egyes menupontokat vagy egy dedikalt billenty}u leutesevel, vagy a kurzor-mozgato nyilak (, illetve ! nyilak) es az Enter billenty}u segtsegevel valaszthatjuk ki. A kivalasztas hatasara a menupont alatt megjelenik a megfelel}o almenu kerete, benne az egyes almenupontokkal. Egy almenuponthoz vagy egy kozvetlenul vegrehajthato programresz, vagy egy tovabbi almenu tartozik Az almenuk pontjait a " # kurzorvezerl}o billenty} uk es az Enter, illetve dedikalt billenty}uk segtsegevel valaszthatjuk ki. Egy almenub}ol az Esc, vagy a minden menuben szerepl}o eXit menuponthoz rendelt X billenty}u leutesevel lephetunk ki. (Az eXit menupontot es a hozza tartozo X billenty}ut a portabilitas miatt denialtuk: egyes terminalokon az Esc billenty}u kodja terminalvezerl}o karakterszekvenciak resze, gy e billenty}u

leuteset vagy nem tudjuk erzekelni, vagy a terminal "megbolondul" t}ole.) Egy menupontkent aktivizalt programreszb}ol, vagy egy almenub}ol visszaterve a hvo menu kepe mindig regeneralodik, es az utoljara aktivizalt menupont marad kivalasztva, azaz egyszer}uen csak az Enter billenty}u leutesevel ujra aktivizalhato. Lekepezes adatstrukturakra es vezerlesi szerkezetekre Az el}obb vazolt megjelenes a keperny}on, illetve kezelesi mod azt sugallja, hogy szuksegunk van egy, a f}omenut lero adatstrukturara es az azt kezel}o f}omenu fuggvenyre, illetve letre kell hozni egy olyan adatstrukturat, amellyel lerhatjuk, hogy egy almenu hol helyezkedik el a keperny}on, milyen menupontjai vannak, azokhoz milyen funkcio (milyen vegrehajtando programresz, vagy milyen tovabbi almenu) tartozik, stb. Nyilvanvalo tehat, hogy kell egy adatstruktura, ami az egyes menupontokra vonatkozo informaciokat tartja nyilvan (a

menupont neve, a hozza tartozo help-informacio, a hozzarendelt kivalaszto billenty}u, kivalasztottak-e, milyen feladatot lat el, esetleges parameter). A menupontokat menulistakba kell szerveznunk Egy ilyen listat ki kell egesztenunk a keperny}on valo megjelenesre vonatkozo informaciokkal (milyen hosszu a lista, hany karakter szeles, a listat 1.13 OSSZETETT MINTAPE
LDA 71 tartalmazo doboz hol helyezkedik el a keperny}on, stb.), es megadhatjuk azt is, hogy egy adott menu milyen hierarchia szinten helyezkedik el a menu-fan. A look-and-feel-re vonatkozo meggondolasokbol kovetkezik, hogy az almenuket kezel}o menufuggvenyt ugyanolyan funkciokent erdemes felfogni, mint a programunk tenylegesen vegrehajtando egyes reszeit. Igy tehat celszer}u az egyes menulistakat megszamozni, es a menukezel}onk ezen szam alapjan tudja eldonteni, melyik menulistat kell megjelentenie es kezelnie. Termeszetesen az is celszer}u, hogy az

egyes menupontok a vegrehajtando programreszletekre vonatkozo default parametereket tartalmaznak, es a menupont kivalasztasakor ezen parameterrel hvja meg a menukezel}o a megfelel}o reszprogramot. Ilyen meggondolasok mellett egy almenu megjelentese bels}o vezerlesi szerkezetkent ugy nyivanul meg, hogy a menukezel}o fuggveny onmagat hvja meg ugy, hogy a rekurzv hvas alkalmaval az almenu azonostojat, mint parametert hasznalja. Hogy valostsuk meg egy adott menuponthoz tartozo fuggveny aktivizalasat? A valasz igen egyszer}u: indirekt fuggvenyhvast kell alkalmaznunk, azaz a menupont lero strukturaban egy fuggvenyre mutato pointermez}ot kell deklaralnunk. Az egyes menupontok denialasakor ezt a strukturamez}ot a tenylegesen meghvando fuggveny cmevel kell majd inicializalnunk. A konkret deklaraciok Most tekintsuk tehat az egyes tpusdeklaraciokat! A menurendszerunk kulonboz}o menukb}ol all,

a kulonboz}o menuk pedig tobb menupontbol. Egy menupont legfontosabb jellemz}oje az a fuggveny, amit a menupont kivalasztasakor aktivizalni kell. Ezek a fuggvenyek igen sokfelek lehetnek, gy hagyomanyos C-ben celszer}u a fuggvenyek cmeit nyilvantartani. Ehhez ket lepcs}oben denialjuk a fad (function address) tpust: typedef int intfunc(int) /* int-et visszaado, 1 int-et varo * fuggvenytipus */ typedef intfunc *fad /* intfunc tipusu tarolasi * segre mutato tipus egy- * */ A fent denialt intfunc tpust felhasznalhatjuk a majdan meghvando egyes fuggvenyek el}ozetes deklaralasara. A vegrehajtando fuggvenyen kvul egy menupont fontos jellemz}oje az illet}o menupont neve (azonosto szovege), az a nyomtathato karakter, amivel Enter megnyomasa helyett kivalaszthato a menupont. Celszer}u megengednunk, hogy a menupont altal meghvando fuggvenynek egy, a menupont lerasaban tarolt parametert is atadjunk. Ha a

menurendszerunkhoz alkalmas help-rendszert is szeretnenk, celszer}u az egyes menupontokhoz rendelt help-szovegre utalo informaciot (peldaul egy le-indexet) is tarolni. Ezeket az informaiokat { a menuponthoz rendelt fuggveny cmevel egyutt { az alabb deklaralt menuitem (menupont) strukturaba szerveztuk: typedef struct { char *text /* A menupont azonosito szovege */ 72
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS char key int helpindex fad function int param } menuitem /* /* /* /* A A A A menupontot kivalaszto betu menuponthoz rendelt help-kod menuponthoz tartozo fv-re mutat *function fuggveny parametere */ */ */ */ A gyeljuk meg, hogy a fenti struktura denicobol kimaradt a tpuscmke, hiszen typedef-fel eleve azonost ot rendelunk hozza { rekurzv adatdenicorol pedig szo sincs. Most lassuk, hogy szervezhetunk egy menut a fenti modon deklaralt menuitem strukt urak segtsegevel. A menupontjainkat celszer}uen egy

menuitem tpusu tombben taroljuk, amelynek meretet is tudnunk kell. A menu tartalma mellett fontos annak megjelenese is. Szuksegunk lehet arra, hogy a menut keretez}o doboz tetejen esetleg egy menunevet, egy fejlecet (header-t) is megjelentsunk Fontos azt is tudnunk, hogy melyik x-y karakterpozicioba kerul a menudoboz (annak peldaul a bal fels}o sarka) a keperny}on, es az is lenyeges informacio, hogy hany karakterpoziciot foglal le a menudoboz vzszintes es fugg}oleges iranyban. Azt is nyilvantarthatjuk egy menur}ol, hogy melyik menupontot valasztottuk ki benne utoljara es fontos lehet az is, hogy az adott menu hol helyezkedik el egy hierarchikus menu-fan. Ezeket az informaciokat foglaltuk egybe az alabbi menutype strukturaban: typedef struct { char *header int x int y int xs int ys int itemno menuitem *items int hierarch int lastitem } menutype /* /* /* /* /* /* /* /* /* A menu fejlecszovegere mutat A menudoboz bal felso sarkanak x es

y koordinatai, valamint a menudoboz x es y iranyu merete. A menupontok szama A menupontok listajara mutat. Ha 1, kozvetlenul a fomenu hivja Utoljara kivalasztott pont szama */ */ */ */ */ */ */ */ */ A menuitem tpusbol egy-egy inicializalt tombot szervezve hozhatjuk letre az egyes menuk tartalmara vonatkozo adathalmazt. Egy ilyen lista kezd}ocme kerul egy menutype struktura items mez}ojebe Egy-egy menutype struktura egy komplett menu lerasat tartalmazza. Ezekb}ol a strukturakbol szinten egy tombot szervezunk, ez lesz a menus tomb E tomb els}o nehany eleme egy-egy menufa gyokeret (azaz a f}omenu egyes pontjaikent aktivizalando menuket) reprezentalja, a tobbi elem pedig az egyes fakra felf}uzott almenuket rja le. Tekintsuk at tehat a teljes menurendszert denialo adatstrukturat: /* Kulso fuggvenyek deklaracioja extern intfunc data, regr, save, */ r data, w data, statf, linf, barf, load /* A a menukezelo fuggveny prototipus

erteku deklaracioja */ 1.13 OSSZETETT MINTAPE
LDA intfunc menu intfunc dir, shell 73 /* El-ore hivatkozashoz /* Tovabbi fv-ek el-ore hivatkozshoz /* Az egyes menulistak (items 0 . items 3) es a menuk: menuitem items 0" ] = { /* text key hlp func. param */ "Directory", D, 1, dir, 0, "Os shell", O, 2, shell, 0, "File", F, 3, menu, 3,/*a 3.sz menu almenu lesz exitxt, X,-1, NULL, 0 /*-1-es parameter: exit } /* Tombmeret: #define N0 sizeof(items 0)/sizeof(menuitem) */ */ */ */ */ */ menuitem items 1" ] = { "Default", D, 4, data, 7, "Read data", R, 5, r data,1, "List data", L, 6, w data,2, "Statistics",S, 7, statf, 3, exitxt, X,-1, NULL, 0 } #define N1 sizeof(items 1)/sizeof(menuitem) menuitem items 2" ] = { "Regression",R, 8, regr, 4, "Plot", P, 9, linf, 5, "Bar", B,10, barf, 6, exitxt, X,-1, NULL, 0 } #define N2 sizeof(items 2)/sizeof(menuitem) menuitem items

3" ] = { "Save", S,11, savef, 0, "Load", L,12, loadf, 0, exitxt, X,-1, NULL, 0 } #define N3 sizeof(items 3)/sizeof(menuitem) /* A teljes menurendszer leirasa: menutype menus" ] = {/* head. x y xs ys itemno items hier. last "", 9, 2, 13, N0+3, N0, items 0, 1, 0, "", 35, 2, 14, N1+3, N1, items 1, 1, 0, "", 61, 2, 14, N2+3, N2, items 2, 1, 0, "Files",11, 6, 8, N3+3, N3, items 3, 0, 1 } */ */ 74
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS Figyeljuk meg, hogy a menulistak meretenek meghatarozasat a fordto programra bztuk: a sizeof operator segtsegevel megkapjuk mind az egyes menulistakat tartalmazo tombok helyfoglalasat byte-okban, mind a menuitem tpus meretet! ezek hanyadosa adja meg a menulista tombok logikai meretet (azaz azt, hogy hany elem}u egy menulista). Ezeket a kifejezeseket #define makrokent denialjuk, es az gy kapott kifejezeseket hasznaljuk fel a menus

tomb inicializalasara Ez egy igen exibilis megoldas, ugyanis egy menulista b}ovtese soran a menus tomb inicializalasakor a menudoboz meretere es a menulista hosszara vonatkozoan automatikusan helyes adatot fog a fordto felhasznalni. A menus tomb kitolteset legfeljebb csak akkor kell modostani, ha egy uj menulista-elem hossza nagyobb, mint az adott menudobozhoz megadott xs ertek. Sajat include le-ok Menurendszerunk egy fuggvenyekre mutato pointerekb}ol allo tomb segtsegevel aktivizalja az egyes menupontokhoz rendelt fuggvenyeket. Ahhoz, hogy ezt a pointertombot ki lehessen tolteni, szukseg van a sajat fuggvenyeink prototpusaira. Fontos, hogy csak int tpust visszaado, egyetlen int tpusu parametert varo fuggvenyeket illeszthetunk be a menurendszerbe. Ha ett}ol elter}o rutinjaink vannak, akkor azokat "fejeljuk meg" ugy, hogy ennek a kovetelmenynek eleget tegyenek. Ezeket a fuggvenyeket vagy ugy

deklaraljuk, ahogy azt az adatstruktura lerasakor tettuk, vagy egy include le-ba foglajuk a deklaraciokat A kett}o egyszerre is alkalmazhato, felteve, ha a ketfele deklaracio osszhangban all egymassal. Mi most a menukezel}o rendszerben torten}o deklaraciot alkalmazzuk, es csak a menukezel}o rutinok deklaracioit helyezzuk el a sajat le-ban. A bevezet}oben emltett, nem portabilis keperny}okezel}o fuggvenyeinket egy onallo .c le-ban erdemes tarolni, prototpusaikat szinten a fuggveny rpototpusokat tartalmazo include le-unkban erdemes elhelyezni Ezt az include le-t, amit peldaul myfunc.h-nak nevezhetunk { majd a menukezel}o rendszert tartalmazo c le fogja behvni a #include "myfunc.h" preprocesszor utastassal. E rdemes a menukezel}o rendszerunk altal hasznalt kulonfele szimbolumokat is { peldaul egyes specialis billenty}uk kodjainak szimbolikus neveit, mint peldaul RIGHT ami a ! billenty}u kodjanak,

LEFT, UP, DOWN, ESC, BEGIN, END, HELP rendre a , ", #, Esc, Enter, Home, End es az F1 billenty}u kodjanak felel meg az IBM PC-n { egy szimbolum le-ba foglalni. Legyen ennek a le-nak a neve peldaul mysymb.h Ezt a le-t szinten az #include direktvaval epthetjuk be a rendszer minden egyes .c le-jaba (Megjegyezzuk, hogy ez a le akar #definenal deklaralt makroszer}u konstansokat tartalmazhat, akar const-kent denialt konstansok deklaracioit tartalmazhatja { az itt kozolt programreszletek szempontjabol ez lenyegtelen. Egy masik megjegyzes az egyes billenty}ukhoz rendelt kodokra vonatkozik: A specialis billenty}ukhoz celszer}u 128-nal nagyobb kodokat rendelni. Igy a billenty}uzet kezel}o fuggveny altal visszadott billenty}ukodok kozul konnyen kisz}urhet}ok a kozvetlen ASCII karakterkodok. A menukezel}o rendszerben ezzel a feltetelezessel elunk. 1.13 OSSZETETT MINTAPE
LDA 75 1.132 A menukezel}o rendszer listaja /* * File:

menu.c * * Tartalom: Menukezelo mintaprogram * */ #include #include #include #include <stdio.h> <string.h> <stdlib.h> <ctype.h> /* /* /* /* Standard i/o csomag Sztring- es memoriakezelo rutinok Altalanos celu standard fuggvenyek Karakterkezelo makrok */ */ */ */ #include "myfunc.h" /* Sajat fuggvenyek prototipusai */ #include "mysymb.h" /* Szimbolumok (spec. billentyuk kodjai)*/ /* ======================================================== / /* Tipusdeklaraciok */ typedef int intfunc(int) /* int-et visszaado, 1 int-et varo * fuggvenytipus */ typedef intfunc *fad typedef struct { char *text char key int helpindex fad function int param } menuitem typedef struct { char *header int x int y int xs int ys int itemno menuitem *items int hierarch int lastitem } menutype /* intfunc tipusu tarolasi * segre mutato tipus /* /* /* /* /* /* /* /* /* /* /* /* /* /* A A A A A egy- * */ menupont azonosito szovege menupontot kivalaszto betu

menuponthoz rendelt help-kod menuponthoz tartozo fv-re mutat *function fuggveny parametere */ */ */ */ */ A menu fejlecszovegere mutat A menudoboz bal felso sarkanak x es y koordinatai, valamint a menudoboz x es y iranyu merete. A menupontok szama A menupontok listajara mutat. Ha 1, kozvetlenul a fomenu hivja Utoljara kivalasztott pont szama */ */ */ */ */ */ */ */ */ /* ======================================================== / /* Tarolasi egysegek deklaracioi, definicioi: */ static char exitxt"~] = "eXit" 76
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS /* Majd sokszor kell ez a sztring. /* Kulso fuggvenyek deklaracioja extern intfunc data, regr, save, */ r data, w data, statf, linf, barf, load /* A a menukezelo fuggveny prototipus erteku deklaracioja intfunc menu intfunc dir, shell */ /* El-ore hivatkozashoz /* Tovabbi fv-ek el-ore hivatkozshoz /* Az egyes menulistak (items 0 . items 3) es a menuk: menuitem items 0" ] = { /* text key hlp func.

param */ "Directory", D, 1, dir, 0, "Os shell", O, 2, shell, 0, "File", F, 3, menu, 3,/*a 3.sz menu almenu lesz exitxt, X,-1, NULL, 0 /*-1-es parameter: exit } /* Tombmeret: #define N0 sizeof(items 0)/sizeof(menuitem) menuitem items 1" ] = { "Default", D, 4, data, 7, "Read data", R, 5, r data,1, "List data", L, 6, w data,2, "Statistics",S, 7, statf, 3, exitxt, X,-1, NULL, 0 } #define N1 sizeof(items 1)/sizeof(menuitem) menuitem items 2" ] = { "Regression",R, 8, regr, 4, "Plot", P, 9, linf, 5, "Bar", B,10, barf, 6, exitxt, X,-1, NULL, 0 } #define N2 sizeof(items 2)/sizeof(menuitem) menuitem items 3" ] = { "Save", S,11, savef, 0, "Load", L,12, loadf, 0, exitxt, X,-1, NULL, 0 } #define N3 sizeof(items 3)/sizeof(menuitem) */ */ */ */ */ */ */ 1.13 OSSZETETT MINTAPE
LDA /* A teljes menurendszer leirasa: menutype menus" ] = {/* head. x y xs ys

itemno items hier last "", 9, 2, 13, N0+3, N0, items 0, 1, 0, "", 35, 2, 14, N1+3, N1, items 1, 1, 0, "", 61, 2, 14, N2+3, N2, items 2, 1, 0, "Files",11, 6, 8, N3+3, N3, items 3, 0, 1 } 77 */ */ /* Mivel a f}omenunek semmi m
as funkci
oja nincs, mint a menu fuggv
enynek
atadni a vez
erl
est a megfelel}o menuindexszel, komolyabb adatstrukt
ur
akat nem deni
altunk a sz
am
ara. Csak az al
abbiakra van szuks
eg a f}omenuhoz: */ static char main header" ] = /* A fomenu fejlecszovege " Highly Portable Menu System " */ static char options" ]=/*Az egyes menuk kivalaszto gombjai / "FDP" /*Sorrendjuk ugyan-az, mint az alab- / /*bi sztring-tomb el-emeinek sorrendje/ /* Az options sztring hossza adja meg, hogy a menus tomb h
anyadik elem
eig tekintjuk a menuket a f}omenu r
eszeinek. */ static char *headers" ]= { "File", / A fomenube felvett "Data", /* menuk fejlec szove"Plot" / gei. }

static int mainselect = 0 /* Az utoljara kiv.fomenu elem static char buffer"81] /* Ide generaljuk a fomenut static int xp,yp,j /* Segedvaltozok a rutinokhoz static char inpbuff"256] /* Altalanos input buffer */ */ */ */ */ */ */ /* A magyar
azatok
es deklar
aci
ok ut
an kovetkezzenek maguk a fuggv
enyek! A menukezel}o rendszert u
gy hoztuk l
etre, hogy programunk main-je csak ilyen rovid legyen: */ /*/ void main(void) /* Ez tetszoleges program main-je lehet */ /*/ { displ ini() /* A kepernyokezelo rendszer inicializalasa / main frame() /* Keretrajzolas a fomenuhoz: mint az IDE */ main menu(0) /* Fomenu. Addig fut, amig ESC-pel ki nem szallnak belole */ displ end() /* A kepernyo alapallapotanak
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 78 exit(0) helyreallitasa /* OK hibakod visszadasa az operacios rendszernek */ */ } /* Most tekintsuk mag
at a menukezel}o rutincsomagot! */ /*/ int menu(int index)/*Az aktualisan hasznalando menu indexe / /* Funkci
o: A

fuggv
eny a menus"index]-ben adott menut megjelen
ti a k
eperny}on. Az egyes menupontokat a menule
r
as szerinti dobozban jelen
ti meg. A menus"index]lastitem index} u menupont kiemelve l
atszik a k
epen. A kiemelt menupontot a "
es # kurzorvez
erl}okkel v
altoztathatjuk Ha leutjuk az Enter billenty}ut, akkor a kiemelt szin}u menupont fuggv
eny
et hivjuk meg, ha pedig valamelyik menuponthoz rendelt nagybet}ut utjuk le a billenty}uzeten, akkor az illet}o menupont fuggv
enye lesz aktiviz
alva a menus"index].items"selected]param parameterrel, ahol index a kiv
alasztott menupont indexe. Amint a megh
vott fuggv
eny visszaadja a vez
erl
est, a menu szubrutin regener
alja az aktu
alis menulist
at a keretezett dobozban. Ha menus"index]hierarch == 1 akkor a menu fuggv
eny visszat
er
esi
ert
eke { RIGHT ha a ! kurzorvez
erl}o gombot nyomt
ak meg, { LEFT ha a  kurzorvez
erl}o gombot nyomt
ak meg. Minden egy
eb esetben a visszat
er
esi
ert
ek 0, teh
at amikor

{ az ESC gombot nyomt
ak meg (kil
ep
es a menu fuggv
enyb}ol), { olyan menupontot v
alasztottak ki, amelynek a helpindex-e -1 */ { int i, /* A menupontok szamat tesszuk bele */ l, /* for-ciklushoz ciklusvaltozo */ exit, /* Kilepest jelzo flag */ par, /* A kivalasztott fv. parametere */ cmd /* A vezerlo-karakternek */ /* . E L O K E S Z I T E S E K */ j = menus"index].lastitem /* j-ben az aktualis index i = menus"index].itemno if (!i) return 0 /* Nulla meretu menuvel nem torodunk */ menu regen(index,1) /* A menut kiiratjuk a kepernyore exit = FALSE /* A kilepest jelzo flag kezdoerteke */ */ /* . F O */ C I K L U S . */ 1.13 OSSZETETT MINTAPE
LDA while (! exit) /*Addig tart,amig exit igaz nem lesz / { cmd = 0 /* Kezdetben ures parancs */ while (!(cmd == SELECT || cmd == CR)) { cmd = getkey() /* VT100-on ketfele ENTER van, */ switch(cmd) /* ezert van CR is es SELECT is. */ { case BEGIN: o gotoxy(xp,yp+j) /* HOME-ot nyomott */

printf("%s",menus"index].items"j]text) j = 0 o gotoxy(xp,yp) highlight(EMPHAS,menus"index].items"j]text) break case END: o gotoxy(xp,yp+j) /* END-et nyomott */ printf("%s",menus"index].items"j]text) j = i-1 o gotoxy(xp,yp+j) highlight(EMPHAS,menus"index].items"j]text) break case UP: /* fel nyil */ { o gotoxy(xp,yp+j) printf("%s",menus"index].items"j]text) if (j > 0) j-- else j = i - 1 o gotoxy(xp,yp+j) highlight(EMPHAS,menus"index].items"j]text) } break case DOWN: /* le nyil */ { o gotoxy(xp,yp+j) printf("%s",menus"index].items"j]text) if (j < i-1) j++ else j = 0 o gotoxy(xp,yp+j) highlight(EMPHAS,menus"index].items"j]text) } break case HELP: /* F1-et nyomtak */ menus"index].lastitem = j menu help(menus"index].items"j]helpindex) if (menus"index].items"j]helpindex >= 0 && menus"index].y + menus"index]ys > 11) menu

regen(index,0) break case ESC: /* ESC-et nyomtak */ exit = 1 cmd = SELECT 79 80
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS break case LEFT: case RIGHT: /* Ha main menu hivta menu-t, akkor a jobbra, balra nyilak eseten a menut toroljuk, es a nyil-gomb kodjat visszaadjuk. Igy a fomenu a roll-in menut felvaltja egy masikkal: */ if (menus"index].hierarch == 1) { menu remove(index) return cmd } default: /* Kilepunk, ha dedikalt gombot nyomtak */ if (cmd < 128) { cmd = toupper(cmd) for(l = 0 l < i l++) { if (menus"index].items"l]key == cmd) { o gotoxy(xp,yp+j) printf("%s",menus"index].items"j]text) cmd = SELECT j = l break } } } break } /* . end switch */ } /* . end while */ if (! exit) { exit = (menus"index].items"j]helpindex == -1) } /* Ezen a ponton m
ar eld}olt, hogy ki akarunk-e l
epni. Ha nem, akkor viszont tudjuk, hogy melyik menupont fuggv
eny
et kell aktiviz
alni: */ if (! exit) { /* Az eXit pontnak mindig -1 helpindexe

legyen! */ /* . A kivalasztott fuggveny aktivizalasa: /* (j indexeli a kivalasztott fuggvenyt) */ */ o gotoxy(xp,yp+j) highlight(EMPHAS,menus"index].items"j]text) 1.13 OSSZETETT MINTAPE
LDA 81 menus"index].lastitem = j par = menus"index].items"j]param (*menus"index].items"j]function)(par) menu regen(index,0) } else { menu remove(index) } /* A menu-box regeneralasa */ } return 0 } /*/ void menu regen(int index, /* A regeneralando menu indexe */ int rem) /* TRUE: torolni kell a dobozt */ /* Funkci
o: A menus"index] menu regener
al
asa (
ujra rajzolja a dobozt, ki
rja a menulist
at
es kiemel}o szinnel nyomtatja az utolj
ara kiv
alasztott menupontot.) Ha rem == 1 akkor a menu
altal elfoglalt k
eperny}oteruletet torli a menulista ki
r
asa el}ott, ha rem == 0, akkor nem torol. */ { int i,k,l,m,n,xx,yy int x1,x2 xp = menus"index].x /* Pozicio, meret el-ovetele */ yp = menus"index].y i = menus"index].itemno xx =

menus"index].xs yy = menus"index].ys /* Dobozrajzolas */ box draw(menus"index].header,xp,yp,xx,yy,rem) xp += 2 yp += 2 for (k = 0 k < i k++) /* A menulista megjelenitese { o gotoxy(xp,yp+k) if (k == menus"index].lastitem) { highlight(EMPHAS,menus"index].items"k]text) j = k } else printf("%s",menus"index].items"k]text) } } */ 82
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS /*/ void menu remove(int index) /* A torlendo menu indexe */ /* Funkci
o: A menus"index] menu torl
ese a k
eperny}or}ol */ { int xx,yy,x1,y1 x1 = menus"index].x y1 = menus"index].y xx = menus"index].xs yy = menus"index].ys box delete(x1,y1,xx,yy) } /*/ void box draw(char* header, /* ->a doboz fejlec-szevege / int xp, int yp,/* a doboz pozicioja, */ int xs, int ys,/* merete */ int rem) /* 1, ha torles kell, egyebkent 0 */ /* Funkci
o: Egy xs, ys m
eret}u dobozt rajzol az xp, yp pozici
oba. A keret fels}o r
esz
enek kozep
ere a

header fejl
ecet
rja ki. Ha rem == 1, akkor a doboz rajzol
asa el}ott torli a doboz
altal elfoglaland
o teruletet. */ { int l,n,xx,yy int x1,x2 l = strlen(header) /* A fejlec hossza */ xx = xs-2 /* Egyeb adatok el-okeszitese */ x1 = (xx - l)/2 x2 = xx - (x1 + l) yy = ys-2 if (rem) box delete(xp,yp,xs,ys) o gotoxy(xp,yp) /* A legfelso sor a fejleccel printf("%c",UPLEFT) for (n = 0 n < x1 n++) printf("%c",HORIZ) */ highlight(REVERSE BRIGHT,header) for (n = 0 n < x2 n++) printf("%c",HORIZ) printf("%c",UPRIGHT) yp++ for (n = 0 n < yy n++) /* Maga a doboz { o gotoxy(xp,yp+n) */ 1.13 OSSZETETT MINTAPE
LDA 83 printf("%c",VERT) o gotoxy(xp+1+xx,yp+n) printf("%c",VERT) } o gotoxy(xp,yp+yy) /* A doboz legalso sora printf("%c",DOWNLEFT) for (n = 0 n < xx n++) printf("%c",HORIZ) printf("%c",DOWNRIGHT) */ } /*/ void box delete(int xp, int yp, /* Egy dobozt torol */ int xs, int ys) /*

Pozicio, meret */ /* Funkci
o: Egy xs, ys m
eret}u dobozt torol az xp, yp pozici
or
ol. */ { int n, m for (n = ys-1 n >= 0 n--) { o gotoxy(xp,yp+n) for (m = 0 m < xs m++) putc( ) } } /*/ void menu help(int index) /* A menupont help-indexe */ /* Funkci
o: Az index
altal meghat
arozott help-szoveget kikeresi egy help-le-b
ol,
es ki
rja a k
eperny}ore. A ki
r
ashoz egy 7 soros ablakot nyit, a szoveget 7 soronk
ent
rja ki. Ha van m
eg kiirand
o szoveg, akkor a More uzenet ut
an egy billenty}uleut
esre v
ar, ha nincs, akkor a Press any key uzenet ut
an torli a k
eperny}or}ol a help-dobozt,
es visszat
er. A help-le form
atuma a kovetkez}o: index i sor 1 i sor 2 i . sor n i index j . n i n j ahol index i az i-edik help-index, n i az ehhez az indexhez tertoz
o help-szoveg sorainak a sz
ama, valamint sor 1 i, . sor n i a help-szoveg egyes sorai Form
atum hiba, vagy le v
ege eset
en szint
en hibajelz
es tort
enik. 84
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS */ {

static char hunex"] = "Unexpected end of the help-file!!!" #define YP 24 FILE *fp int i,j,k,err if (index < 0) return /* Negativra visszater box draw(" HELP ",2,11,76,9,1) /* Help-box rajzolasa fp = fopen(helpdat,"r") /* Help-file megnyitasa */ */ */ if (fp == NULL) /* Ha nem letezik a file, hibajelzes */ { o gotoxy((80-(21+strlen(helpdat)))/2-1,16) printf("Help-file %s not found!",helpdat) goto helpend1 } i = -1 while (i != index) /* Help-index keresese a file-ban */ { err = fscanf(fp,"%d%d",&i,&j) if (err == EOF) /* Nem talaljuk: hibajelzes */ { o gotoxy(19,16) printf("No help is available for this menu item!") goto helpend0 } if (err != 2) { o gotoxy((79-(31+strlen(helpdat)))/2,16) printf("Format error in the %s help-file!",helpdat) goto helpend0 } if (i != index)/* Ha meg nem talalja, tovabb olvas. */ { for ( j >= 0 j--) { if (NULL == fgets(inpbuff,74,fp)) { o

gotoxy((79-strlen(hunex))/2,16) printf(hunex) goto helpend0 /* A goto-t legfeljebb igy */ } /* hasznaljuk! */ } } } for (k = i = 0 i < j i++) 1.13 OSSZETETT MINTAPE
LDA 85 { if (NULL == fgets(inpbuff,74,fp)) { o gotoxy((79-strlen(hunex))/2,16) printf(hunex) goto helpend0 } o gotoxy(4,12+k) printf(inpbuff) k++ if (k == 7)/*Megvan a helpszoveg. 7-esevel kiirjuk: { o gotoxy(66,YP) highlight(BRIGHT,"More .") bell() err = getkey() o gotoxy(66,YP) printf(" ") if (err == ESC)/* ESC-re kiszallunk { fclose(fp) box delete(2,11,76,9) return } box draw(" HELP ",2,11,76,9,1) k = 0 } } helpend0: /* Minden befejezeskor ezeket a muveleteket fclose(fp) /* kell elvegezni, tehat takarekos meghelpend1: /* oldas a goto hasznalat. Csinjan banpress key() /* junk az ilyennel, hogy olvashato maradbox delete(2,11,76,9) / jon a programunk! */ */ */ */ */ */ */ } /*/ void main frame(void) /* Funkci
o: Keretet rajzol a f}omenunek. Ha valamelyik fuggv
eny torli az eg
esz

k
eperny}ot, akkor main frame megh
v
as
aval helyre
all
thatja azt. */ { erase() box draw(main header,0,0,80,23,0) /* Main box fejleccel */ main menu(1) /* Fomenu statusz-sora / } /*/ void main menu(int stl)/*Ha 1, akkor a statusz-sort kiirja /
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 86 /* Funkci
o: A menukezel}o rendszer f}o rutinja, ezt kell a main-b}ol megh
vni. A menus tombb}ol annyi menut kezel kozvetlenul, amennyi az options sztring hossza A menuopci
okat a k
eperny}o m
asodik, kivil
ag
tott sor
aban jelen
ti meg Egy menupont a szok
asos m
odon v
alaszthat
o (kurzorral kiemel
es, majd Enter, vagy a kezd}o bet}u leut
ese). Ha egy almenu
el (azaz l
atszik a k
eperny}on), akkor a , illetve ! nyilakkal a szomsz
edos menure v
althatunk. */ { int i,j,k,l, posinc, hno,xp, cmd,flag /* buffer-ben lesz az inverzen kiirando statusz-sor */ hno = sizeof(headers)/sizeof(char*) posinc = 78/hno xp = posinc/2 if (stl) { for (i = 0 i < 78 buffer"i++] = ) for (j = 0

j < hno j++) { l = strlen(headers"j]) for(k = 0 k < l k++) buffer"xp+j*posinc+k] = (headers"j]+k) } buffer"78] = o gotoxy(1,1) highlight(REVERSE,buffer) } /* A kivalasztott menut normal modon jelenitjuk meg: i = mainselect xp++ if (stl) { o gotoxy(xp+i*posinc,1) printf(headers"i]) return } */ 1.13 OSSZETETT MINTAPE
LDA /* A fo parancs-ciklus. Csak ESC-re lephetunk ki belole dontquit: /* Ide ugrunk, ha megse lepunk ki. flag = cmd = 0 while (cmd != ESC) { if (! flag) cmd = getkey() flag = 0 switch (cmd) /* Nincs el-o almenu. Kurzorvezerlok { /* feldogozasa, status-sor modositasa case RIGHT: o gotoxy(xp+i*posinc,1) highlight(REVERSE,headers"i]) if (i < hno-1) i++ else i = 0 o gotoxy(xp+i*posinc,1) printf(headers"i]) break case LEFT: o gotoxy(xp+i*posinc,1) highlight(REVERSE,headers"i]) if (i) i-- else i = hno-1 o gotoxy(xp+i*posinc,1) printf(headers"i]) break case SELECT: crselect: /* Kivalasztottak egy almenut. Megje*/ /*

gyezzuk indexet mainselect-ben */ mainselect = i flag = menu(i) /* A menu rutin behivasa switch (flag) /* Mi a visszateresi ertek? { case RIGHT: /* Stat.sor modositas o gotoxy(xp+i*posinc,1) highlight(REVERSE,headers"i]) if (i < hno-1) i++ else i = 0 o gotoxy(xp+i*posinc,1) printf(headers"i]) break case LEFT: o gotoxy(xp+i*posinc,1) highlight(REVERSE,headers"i]) if (i) i-- else i = hno-1 o gotoxy(xp+i*posinc,1) printf(headers"i]) break } l = strlen(headers"i]) o gotoxy(xp+i*posinc+l,1) break 87 */ */ */ */ */ */ */
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 88 default: if (cmd < 128) /*Kezdobetuvel valasztottak { cmd = toupper(cmd) for (l = 0 l < hno l++) if (cmd == options"l]) { o gotoxy(xp+i*posinc,1) highlight(REVERSE,headers"i]) i = mainselect = l o gotoxy(xp+i*posinc,1) printf(headers"i]) */ /* Ugy teszunk, mintha nyil+Enter-rel valasztottak volna. */ cmd = SELECT goto crselect } } break } } /* Az ESC-pel valo kilepes

szandekat meg-erosittetjuk: box draw("",28,5,24,3,0) o gotoxy(30,6) highlight(BRIGHT,"Are you sure? (y/n) ") cmd = yesno() box delete(28,5,24,3) o gotoxy(1,1) if (!cmd) goto dontquit /*Nem lep ki, vissza az elejere erase() */ */ } */ /* K
et gyakori funkci
o port
abilis megval
os
t
as
at tal
aljuk itt. Ezek az akt
v konyvt
ar tartalm
anak kiirat
asa a k
eperny}ore, illetve az oper
aci
os rendszer parancs
ertelmez}o burk
anak (command shell) az aktiviz
al
asa Mindkett}ot a system fuggv
eny seg
ts
eg
evel oldjuk meg. A system argumentuma egy oper
aci
os rendszernek sz
ol
o parancsot tartalmaz
o sztring Ezek a mi esetunkben egy-egy #define makr
ok
ent lettek megadva,
gy azok oper
aci
os rendszert}ol fugg}o felt
eteles ford
t
assal megfelel}oen be
all
that
ok. Tah
at a system fuggv
enynek (processh)
atadand
o oper
aci
os endszer parancsok: */ #ifdef MSDOS #define DIRSTR "dir /w/p" /* A burok (shell) dir parancsa */ 1.13 OSSZETETT

MINTAPE
LDA #define SHELL "COMMAND.COM" /* Maga az operacios r. burok (shell) 89 */ #endif /* A fenti sztringeket csak a DOS-ban adhatjuk
at a system-nek, ez
ert haszn
altuk az #ifdef MSDOS ford
t
asvez
erl}o direkt
v
at. UNIX-ban a megfelel}o sztringek
ert
eke rendre "ls -Cjmore", illetve "sh" lenne */ /*/ int dir(int d) /* Az aktiv konyvtar tartalmat nezzuk meg */ /* d: Dummy parameter */ /*/ { displ end() system(DIRSTR) /* Az op. rendszer DIR parancsat kerjuk Ennel lehetne hatekonyabb meg-oldast is talalni, de ez igy portabilis. */ displ ini() press key() erase() main frame() return d } /*/ int shell(int d)/* A parancsertelmezo burok hivasa */ /* d: Dummy parameter */ /*/ { displ end() printf(" Type exit to return! ") system(SHELL) displ ini() erase() main frame() return(x) } 90
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS A sajat include le tartalma A kovetkez}o lista a myfunc.h include le javasolt tartalmat mutatja be:

/* * File: myfunc.h * * Tartalom: Menukezelo mintaprogram fuggveny proto* * tipusai: el-orehivatkozasokhoz, illetve a * * kepernyokezelo rendszer hasznalatahoz. * */ /* ======================================================== / /* A menukezelo rendszer fuggvenyeinek deklaracioi */ void main menu(int stl) /* Fomenu-rutin. Ezt kell a mainbol meghivni */ void main frame(void) /* A fomenuhoz keretet rajzol a kepernyore */ int menu(int index) /* Ez a menurutin: az adott sorszamu menut kezeli */ void menu regen(int index) /* Az adott sorszamu menut regeneralja a kepen */ void menu remove(int index) /* Az adott sorszamu menut letorli a keprol */ void menu help(int index) /* Adott menuponthoz helpet ir ki egy file-bol */ void box draw(char *header, / Adott fejleccel, */ int xp,int yp,/* adott xp,yp poxicioban, */ int xs,int ys,/* adott xs,ys meretben dobozt / int rem) /* rajzol, ha kell, torol alatta/ void box delete(int xp, /* Adott helyrol adott meretu */ int yp, /* dobozt torol */ int xs,

int ys) /* ======================================================== / /* A keprnyokezelo rutinok prototipusai magyarazatokkal */ void o gotoxy(int x, int y) void home(void) void erase(void) void displ ini(void) void displ end(void) void cursor left(int n) void cursor right(int n) /* Sajat pozicionalo. x=0.24, y=079 /* A kurzort a 0,0 pozicioba helyezi /* Torli a kepernyot es a 0,0-ba pozicional /* Bekapcsolja a kepernyokezelo rendszert, torol /* Kikapcsolja a kepernyokezelo rendszert, torol /* A kurzort egy pozicioval balra viszi /* A kurzort egy pozicioval jobbra viszi */ */ */ */ */ */ */ 1.13 OSSZETETT MINTAPE
LDA /* A kurzort egy pozicioval feljebb helyezi void cursor down(int n) /* A kurzort egy pozicioval lejebb helyezi void highlight(unsigned mode,/* mode szerinti attributumchar string) / mal string-et nyomtatja int read in(char* string) /* Egy sztringet olvas be 91 void cursor up(int n) int yesno(void) /* y/Y/I/i/N/n (igen/nem) valaszt var. 0, ha nem input(char*

string, int pos,int len) /* Sor-editor. Adott pozicion, adott hosszt edital void press key(void) /* A Press a key kiirasa utan gombnyomasra var void bell(void) /* Egy BEL karaktert kuld az stdout-ra: igy beep-el int getkey(void) /* A billentyuzetet kezeli, ASCII-t, illetve #define erteket ad vissza (pl. UP) */ */ */ */ */ int */ */ */ */ 92
A BORLAND C++-BAN 1. FEJEZET C PROGRAMOZAS 2. fejezet Programoz
as C++-ban A C++ nyelv a C programozasi nyelv egy tovabbfejlesztett valtozata, gy nehany reszlett}ol eltekintve, felulr}ol kompatibilis a C-vel. A C nyelv lehet}osegein tulmen}oen, a C++ igen exibilis es hatekony eszkozoket nyujt a programozonak uj adatstrukturak denialasara. A C++ lehet}ove teszi, hogy a programozo munkajat olyan jol kezelhet}o reszekre oszthassa fel, amelyek szorosan kot}odnek az alkalmazoi program alapkoncepciojahoz. Maskepp fogalmazva: a C++ megteremti annak a lehet}oseget, hogy egy problemat adattpusokra,

es az adott adattpusokhoz szorosan hozzarendelt m}uveletekre kepezhessunk le. Igy a valosaghoz kozel allo objektumokat denialhatunk a C++ programban Ezek az objektumok aztan kenyelmesen es biztonsagosan hasznalhatok olyan kontextusban is, amikor tpusuk a program fordtasakor meg nem allapthato meg. Ezt a fajta programozasi technikat objektum-orientalt programozasnak (roviden OOP-nek) nevezzuk. Ha jol hasznaljak, az OOP rovidebb, attekinthet}obb, es konnyebben karbantarthato programokat eredmenyez, mint a "hagyomanyos" programozasi stlus. A C++ alapelemei az osztalyok (classes). Egy osztaly nem mas, mint egy felhasznalo altal denialt uj tpus, amely a szukseges adatstrukturat, es az adott strukturaju adatokkal vegezhet}o m}uveleteket denialja. Az osztalyok hasznalata lehet}ove teszi az informaciorejtest (tehat azt, hogy bizonyos dolgokrol csak a hasznalatukhoz szukseges ismereteket tesszuk masok

altal is hozzaferhet}ove), garantalja az adatok inicializalasat, implicit tpuskonverziot biztost a felhasznalo altal denialt adattpusok eseteben, az egyes operatorokhoz ujabb jelentest rendelhetunk altaluk, stb. C++-ban sokkal hatekonyabb eszkozok allnak rendelkezesre a modularitas kidombortasara es a tpusellen}orzesre, mint a C-ben Tovabbi olyan b}ovteseket is tartalmaz a C++, amelyek nincsenek kapcsolatban az objektum-orientalt programozassal. Ilyenek peldaul az un inline fuggvenyek, a cm szerint atadhato fuggvenyparameterek, az inicializalt fuggvenyparameterek, stb. A C++ megtartja a C-nek azt a tulajdonsagat, hogy igen hatekonyan kezeli a hardver kozeli adattpusokat (bitek, byte-ok, szavak, cmek), gy ez az uj nyelv tovabbra is jol felhasznalhato rendszerprogramozoi feladatok megoldasara. A C++ nyelv tervez}oi els}odlegesnek tekintettek a C egyszer}usegenek meg}orzeset, es a C-vel valo

kompatibilitast, valamint a regi C szintaxisanak tisztabba tetelet. A C++-ban nincsenek magas szint}u adattpusok es hozzajuk rendelt m}uveletek. Peldaul nem letezik a C++-ban matrix tpus es matrix invertalo 93 94
C++-BAN 2. FEJEZET PROGRAMOZAS operator. Ha a felhasznalonak szuksege van ilyen tpusra, a nyelv lehet}ove teszi annak denialasat Valojaban a C++ programozoi tevekenyseg alapvet}o, lenyegi reszet a megfelel}o adattpusok denialasa teszi ki. Egy jol megtervezett felhasznaloi adattpus nem abban kulonbozik egy beeptett tpustol, hogy hogyan lehet hasznalni, hanem csak abban, hogy mikepp van denialva. Az objektumok tpusanak ismereteben a fordtoprogram megfelel}oen tudja kezelni a bel}oluk alkotott kifejezeseket, mg a hagyomanyos C-ben a programozonak kn-keservvel kell lernia minden egyes m}uvelet vegrehajtasi modjat. A tpusok pontos ismerete azt is el}osegti, hogy mar

programfordtaskor kideruljenek olyan hibak, amelyek egy hagyomanyos C program eseteben csak a teszteles soran talalhatok meg. Ebben a reszben { ahogy a 1. fejezetben attekintettuk a BORLAND C++ implementacio ANSI C kompatibilis elemeit { ismertetjuk a nyelv AT&T C++ 2.0 kompatibilis reszeit A C++-ra vonatkozo alapreferenciakent ajanljuk Bjarne Stroustrup konyvet 4] Fel kell azonban hvnunk az olvaso gyelmet arra, hogy ez a konyv "csak" az 1.0-as verzioju C++ egzakt referenciaja Mivel az AT&T a 2.0-as C++ valtozatban a korabbi verziot tovabb b}ovtette, mi olyan nyelvi elemekr}ol is emltest teszunk, amelyekr}ol Stroutstrup fenti konyve (ertelemszer}uen) nem szol. A C++-ra vonatkozo legfrissebb referenciakent Stroustrup egy ujabb munkajat ajanljuk 5]. A C++ nyelv BORLAND C++ implementaciojanak teljes referenciajat az eredeti programdokumentacio Programmers Guide cm}u kotete 2] tartalmazza. 2.1 U j elemek

a C++-ban Miel}ott komolyan foglakoznank az objektum-orientalt programozas alapjaival es azoknak C++-beli megvalostasaval, tekintsuk at a C++ altal nyujtott azon ujdonsagokat, amelyek b}ovtest jelentenek a hagyomanyos ANSI C-hez kepest, de meg nem igenylik az OOP gondolkodasmodot. 2.11 Alternatvak a #define direktva helyett A 1.3-as reszben megismerkedtunk a #define preprocesszor utastassal Ez a direktva harom celt szolgal:
felteteles fordtast vezerl}o szimbolumokat denialunk vele az el} ofeldolgozo #if . #elif #else #endif, illetve #ifdef, #ifndef szerkezetei szamara,
programjaink szam-, vagy szovegkonstansaihoz, illetve konstans-kifejezeseihez szimbolikus neveket rendelhetunk, ezaltal novelve a programkod rugalmassagat es olvashatosagat, es vegul
f uggveny-jelleg}u makrokat denialhatunk segtsegevel. Az utobbi ket alkalmazast celszer}u elvalasztani a fordtasvezerl}o funkcioktol. Ahhoz,

hogy ezt megtehessuk, a C++ ket lehet}oseget knal. Az egyik a const kulcsszo hasznalata. (Megjegyzend}o, hogy a const kulcsszo az ANSI C-nek is resze, lasd 146-os szakaszt) Minden olyan konstanst, amit nem fordtasvezerlesre akarunk hasznalni, celszer}u a const deklaracioju valtozoknak kezdeti ertekul adni. Ezek utan a const
ELEMEK A C++-BAN 2.1 UJ 95 deklaracioju valtzokat ugyanugy hasznalhatjuk, mint a jol megszokott #define konstansokat, azzal a nem mellekes kulonbseggel, hogy mentesulunk a #define konstansok feldolgozasokor torten}o egyszer}u szoveghelyettestes esetleges kellemetlen mellekhatasaitol. Ezaltal biztonsagosabba valhatnak forrasprogramjaink A const modosto szoval deklaralt valtozok mellett a felsorolt tpusu (enum) valtozok alkalmazasa is hatekony alternatva a #define direktva helyett. C++ az enum tpust kicsit maskepp ertelmezi, mint a hagyomanyos C. A kulonbseg az, hogy mg a

hagyomanyos C az enum es int tpusokat kompatibilisnek tekinti, addig a C++ a kulonboz}o enum tpusokra vonatkozolag is szigoru tpusellen}orzest vegez. Igy peldaul egy enum tpusu valtozonak nem adhatunk int tpus}u erteket. A #define-nal torten}o makrodenciokkal szemben hatekony alternatvat jelentenek az un. inline (sorok kozotti) fuggvenyek Roviden: egy inline fuggveny eleg kis terjedelm}u ahhoz, hogy helyben (in situ), a fuggvenyhvas helyere behelyettestve le lehessen fordtani. Ebben a tekintetben egy inline fuggveny olyan, mintha makro lenne, azaz a fuggvenyhvasokkal jaro adminisztraciora nincs szukseg. Rovid, egy-ket soros fuggvenyek eseteben ez sokkal hatekonyabb, sokkal olvashatobb megoldast jelent, mint a makro-dencio. Az un explicit inline fuggvenyek deklaralasara szolgal a C++ inline kulcsszava. (Az implicit inline deklaraciorol az un. fuggvenymez}ok kapcsan egy kes}obbi fejezetben

lesz szo.) Tehat az inline fuggvenyek a hagyomanyos C el}ofeldolgozo #define direktvajaval denialhato makrokhoz hasonltanak. Annyival fejlettebbek a makroknal, hogy egy ilyen fuggveny meghvasa nem pusztan szoveghelyettestes, hanem a dencio szerint generalt kod masolodik be a hvasok helyere, gy a makrokkal kapcsolatban emltett mellekhatasok jelentkezesenek is kisebb a veszelye. Vegul az explicit inline fuggveny-denciora alljon itt egy pelda: inline int abs(int x) { return (x < 0) ? -x : x } 2.12 Cm szerint nyilvantartott tpusu, vagy referencia tpusu valtozok A 1.93-as reszben, a hagyomanyos C nyelv ismertetesenel emltettuk, hogy a fuggvenyek ertek szerint veszik at az aktualis parametereiket. (A tomboket ebb}ol a szempontbol tekintsuk olyan pointereknek, amelyek adott szamu ertekes adat szamara lefoglalt tarteruletre mutatnak { lasd a 1.96-os szakaszt Igy a tombok is belefernek az

"ertek szerint" fogalmaba, hiszen a mutatokat tenyleg ertek szerint adjuk at.) Ha egy valtozot cm szerint akartunk parameterkent atadni, akkor a formalis parameterlistaban az adott tpusra mutato pointert kellett deklaralnunk, a fuggvenytorzsben az indirekcio operatorat kellett alkalmaznunk, es a fuggveny meghvasakor az aktualis parameterlistaban magunknak kellett explicit modon gondoskodnunk arrol, hogy a megfelel}o parameterhelyre a megfelel}o valtozo cme keruljon. Ennek a dolognak az a nagy hatranya, hogy a fuggvenytorzsben nem kulonulnek el szintaktikailag az igazi tombok es a cm szerint atadott skalarjelleg}u valtozok.
C++-BAN 2. FEJEZET PROGRAMOZAS 96 A C++-ban ilyen, es hasonlo jelleg}u problemak athidalasara bevezettek az un. cm szerint nyilvantartott, vagy referencia tpus (reference type) fogalmat es ehhez denialtak a & tpusmodosto operatort. Igy peldaul a int& r

deklaracio azt jelenti, hogy r olyan valtozo, amely egy egesz tpusu valtozora vonatkozo referenciat tartalmazhat. U gy is felfoghatjuk a dolgot, hogy egy ilyen fajta valtozo egy olyan konstans pointer-kifejezes, amelyre vonatkozolag automatikusan vegrehajtodik egy indirekcio-m}uvelet, amikor az adott referencia tpusu valtozora hivatkozunk. Ez harom dolgot von maga utan Az egyik, hogy a fenti pelda szerinti r valtozo minden olyan helyen allhat, ahol egy int tpusu valtozo is allhat, azaz egesz tpusu kifejezesekben akar balertek, akar jobbertek lehet. A masodik, hogy a referencia tpusu valtozokkal semmilyen m}uvelet nem vegezhet}o, hiszen minden hivatkozas alkalmaval minden egyebet megel}oz az implicit indirekcio m}uvelet (dereference operation, lasd a 1.52 alatt az egyoperandusu * operatorrol lertakat). Ezzel all szoros osszefuggesben a harmadik fontos dolog, hogy nincs ertelme egy cm szerint nyilvantartott tpusu

valtozot inicializalas nelkul denialni. Tehat csak az alabbihoz hasonlo dencionak van ertelme: int ii = 0 int& rr = ii Ekkor az rr++ utastas szintaktikailag ugyan helyes, de nem az rr valtozo inkrementalodik, hanem az az int tpusu tarteruletfoglalo tarolasi egyseg, amelyiknek a cmet rr tartalmazza. Ez a fenti peldaban eppenseggel az ii valtozo Ez az ertelmezes trivialis akkor, amikor az inicializalo kifejezes egy balertek, de nem kotelez}o, hogy az inicializator balertek legyen, s}ot, az sem kotelez}o, hogy a referncia tpus alaptpusaba tartozzon. Ilyen esetekben a) el}oszor tpuskonverzio hajtodik vegre, ha az szukseges, b) aztan a tpuskonverzio eredmenye egy ideiglenes valtozoba kerul, c) es vegul ennek az ideiglenes valtozonak a cme kerul felhasznalasra az adott referencia tpusu valtozo inicializalasahoz. Tekintsuk az alabbi deklaraciot: double& dr = 1 Ez a fentiek alapjan a

kovetkez}okeppen ertelmezhet}o: double* drp double temp temp = (double)1 drp = &temp A hasznalat soran a (*drp) kifejezes egyenertek}u a dr-rel. A referencia tpus igazan kellemes felhasznalasi terulete a bevezet}oben is emltett fuggvenyparameter-deklaracio. Ez azt jelenti, hogy a formalis parameterlistaban mar lehet}osegunk van arra, hogy egy parametert ne a rea mutato
ELEMEK A C++-BAN 2.1 UJ 97 pointer segtsegevel adjunk at cm szerint, hanem jelezzuk, hogy egy olyan valtozorol van szo, amit cm szerint kell atadnuk (mert peldaul kimen}o parameterkent is szuksegunk lesz ra), ugyanakkor a fuggvenytorzsben a tobbi, ertek szerint atadott valtozohoz hasonlo modon { ugyanolyan szintaktikaval { szeretnenk kezelni. A 193-as reszben kozolt egyszer}u pelda a referncia tpus felhasznalasaval gy nez ki: void f1(long& a) { a += 2L } Ekkor az alfa = 0L f1(alfa) kodreszlet szintaktikailag helyes, es

hatasara alfa erteke 2L lesz. A kulonboz}o parameteratadasi lehet}osegeket szemlelteti a kovetkez}o kis program: #include <stdio.h> // * int any function(int par by value, //Ertek szerinti int int* use for arrays,//Ertek szerinti pointer int& par by address)//Cim szerinti int // * { int work work = par by value par by value *= 3 *use for arrays = par by address work par by address = work * work return par by value } // * main() // * { int x = 2, y" ] = { 1, 2 }, z = 10, w = 0 w = any function(z,y,x) printf("%d %d %d %d ",x,y"0],z,w) } Az any function fuggveny harmadik parameteret deklaraltuk referencia tpusunak, erre a tpusnev (int) utan allo & tpusmodosto operator utal. Tekintsuk at a fenti program m}ukodeset. A main-ben any function meghvasa el}ott az x, y"0], z es w valtozok erteke rendre 2, 1, 10 es 0, a w-nek fuggvenyhvassal torten}o ertekadas eredmenyekeppen (mellekhataskent)

pedig x, y"0], z, valamint w a 100, 20, 10 es 30 ertekeket veszik fel! a szabvanyos kimeneten ezek a szamok fognak sorra megjelenni. Lathato, hogy az ertek szerint atadott parameter (z) nem valtozott meg, y"0] uj erteket kapott, hiszen a rea mutato pointeren keresztul indirekt modon cmezve belertunk, es a cm szerint atadott skalar, x is uj ertekkel br a fuggvenyhvas utan. Lathato az is, hogy par by value es par by address hasznalata szintaktikailag azonos 98
C++-BAN 2. FEJEZET PROGRAMOZAS Az any function deklaraciojakor a par by address parmeternel hasznalt megoldas hasonlt ahhoz, amit a Pascal nyelv alkalmaz. Pascal-ban is alapertelmezes szerint ertek szerint adodnak at a parameterek! ott a VAR kulcsszoval jelezhetjuk a cm szerinti parameteratadast, ugyanakkor a FUNCTION, vagy PROCEDURE t orzseben az ertek, vagy cm szerint atadott parameterek hasznalataban nincs szintaktikai kulonbseg. A

referencia tpust fuggvenyek visszateresi tpusakent is nagyon jol fel lehet hasznalni. Gondoljunk csak a 112-es pontban a balertekek kapcsan deklaralt char *get buff pos(int i) f uggvenyre. Ennek a fuggvenynek balertekkent valo alkalmazasa gy nezett ki: *get buff pos(1) = b Ha fuggvenyunket char & tpusu visszateresi ertekkel deklaraljuk, akkor a referencia tpus tulajdonsagai kovetkezteben a get buff pos(1) kifejezes minden tovabbi nelkul ervenyes balertek kifejezes lesz, tehat a fenti ertekado utastast gy rhatjuk: get buff pos(1) = b Vegyuk eszre, hogy a referencia tpusu visszateresi ertek miatt a char& get buff pos(int fuggveny egy ertekado utastas mindket oldalan allhat. A referencia tpusrol itt elmondottak els}osorban a fogalom megerteteset szolgaljak A referencia tpus leges-legfontosabb szerepet azonban a felhasznalo altal denialt tpusokra vonatkozo

operator-fuggvenyeknek denialasanal jatssza { ezek visszateresi erteke ugyanis az adott tpusra vonatkozo referencia-tpusu. Vegyuk eszre, hogy a referencia tpust kepz}o & operator termeszetes kiegesztese a hagyomanyos C tpusmodosto operatorainak: mg a * indirekcio operatornak, a " ] indexel}o operatornak es a ( ) fuggvenyaktivizalo operatornak volt parja a tpusmodosto operatorok kozott, addig az address of operatornak (egyoperandusu &) nem volt. i) 2.13 Inicializalt fuggvenyparameterek Valtozok eseteben mar a hagyomanyos C-ben megszoktuk, hogy a dencio soran kezdeti ertekeket is megadhatunk. A C++ lozoa a kezdeti ertekadast kiemelt fontossaggal kezeli (lasd peldaul a konstruktorokat 2.7-nel), gy szinte termeszetes, hogy ezt a lehet}oseget a fuggvenyparameterekre is kiterjeszti. A C nyelv (es a C++ is) megengedi, hogy egy fuggvenyt kevesebb aktualis parameterrel

aktivizaljunk, mint ahany parametert a formalis parameterlistaban deklaraltunk. Ez sokszor kellemes, jol kihasznalhato tulajdonsag, sokszor azonban kellemetlen, nehezen eszrevehet}o mellekhatasokat eredmenyez}o hibaforras is lehet. Gondoljunk csak a jol ismert printf fuggvenyre, melynek m}ukodese a C ezen tulajdonsagan alapul: Ha a formatum-specikalo sztringben tobb kiirando adatot hatarozunk meg, mint ahanyat aztan tenylegesen felsorolunk a printf aktu alis parameterlistajaban, akkor mindig valami "szemet" kerul standard outputra. Ehhez hasonloan hatarozatlan parameterertekekkel dolgozhat akarmilyen mas fuggveny is, ha veletlenul hianyos aktualis parameterlistaval hvtuk meg. Az ilyen { esetleg fatalis hibat okozo { szituaciok elkeruleset szolgalja az a lehet}oseg, hogy egy fuggveny deklaraciojakor a formalis parameterlistan az egyes parameterekhez alapertelmezes-szer}u (default) kezdeti ertekeket

rendelhetunk. Tekintsunk erre egy peldat: 2.2 AZ OOP ALAPJAI 99 double triangle(double a=0, double b=0, double gamma=90) Ha a fenti deklaracio szerinti fuggvenyt arra hasznaljuk, hogy egy haromszog harmadik oldalanak hosszat kiszamtsuk a koszinusz-tetel segtsegevel (ugy, hogy a ket ismert oldal altal kozbezart szoget fokokban kell megadnunk), akkor a gamma param eter kihagyasaval a Pithagorasz-tetelre egyszer}usodhet a problema. Tehat a triangle(3,4,135) fuggvenyhvaskor az aktualis parameterek erteke rendre 3, 4 es 135, a triangle(3,4) hvaskor 3, 4 es 90, triangle(3) hatasara 3, 0, 90 lesz, es vegul a triangle() fuggvenyhvas eseteben teljesen az alapertelmezes szerinti 0, 0, 90 szamharmas lesz ervenyben. 2.14 C ++ kommentek Figyeljuk meg a 2.12-es resz peldaprogramjaban, hogy a C++-ban ket slash (/) karakterrel egysoros kommentarokat rhatunk. Ez igaz minden C++ rendszerre A BORLAND C++ eseteben ezt a

kommentezesi stlust alkalmazhatjuk akkor is, ha csak egyszer}u C fordtokent akarjuk hasznalni a rendszert, mindazonaltal megjegyzend}o, hogy az egysoros kommentarok ilyen jelolese altalaban nem portabilis (mert a regebbi C fordtok nem fogadjak el //-t. Termeszetesen a /* . */ p aros es a // alkalmazasa vegyesen is lehetseges. 2.2 Az OOP alapjai Az objektum-orientalt programozas (roviden OOP) a termeszetes gondolkodast, cselekvest kozelt}o programozasi mod, amely a programozasi nyelvek tervezesenek termeszetes fejl}odese kovetkezteben alakult ki. Az gy letrejott nyelv sokkal strukturaltabb, sokkal modularisabb es absztraktabb, mint egy hagyomanyos nyelv. Egy OOP nyelvet harom fontos dolog jellemez Ezek a kovetkez}ok:
Az egysegbez aras (encapsulation) azt takarja, hogy az adatstrukturakat es az adott strukturaju adatokat kezel}o fuggvenyeket (Smalltalk, illetve a TURBO Pascal terminologiaval elve metodusokat)

kombinaljuk! azokat egy egysegkent kezeljuk, es elzarjuk }oket a kulvilag el}ol. Az gy kapott egysegeket objektumoknak nevezzuk. Az objektumoknak megfelel}o tarolasi egysegek tpusat a C++-ban osztalynak (class) nevezzuk.
Az orokles (inheritance) azt jelenti, hogy adott, meglev} o osztalyokbol levezetett ujabb osztalyok oroklik a denalasukhoz hasznalt alaposztalyok mar letez}o adatstrukturait es fuggvenyeit. Ugyanakkor ujabb tulajdonsagokat is denalhatnak, vagy regieket ujraertelmezhetnek. Igy egy osztalyhierarchiahoz jutunk
A t obbret}useg (polymorphism) alatt azt ertjuk, hogy egy adott tevekenyseg (metodus) azonostoja kozos lehet egy adott osztalyhierarchian belul, ugyanakkor a hierarchia minden egyes osztalyaban a tevekenyseget vegrehajto fuggveny megvalostasa az adott osztalyra nezve specikus lehet. Az un. virtualis fuggvenyek lehet}ove teszik, hogy egy adott metodus konkret vegrehajtasi

modja csak a program futasa soran deruljon ki. Ugyancsak a tobbret}useg fogalomkorebe tartozik az un. overloading, aminek egy sajatsagos esete a C nyelv standard operatorainak atdenialasa (operator overloading).
C++-BAN 2. FEJEZET PROGRAMOZAS 100 Ezek a tulajdonsagok egyutt azt eredmenyezik, hogy programkodjaink sokkal strukturaltabba, konnyebben b}ovthet}ove, konnyebben karbantarthatova valnak, mintha hagyomanyos, nem OOP-technikaval rnank }oket. Hogy a C++ el}onyeit elvezhessuk, kicsit modostanunk kell a programozasrol alkotott kepunket. Ehhez segt hozza a fenti harom tulajdonsag reszletesebb targyalasa 2.3 Egysegbezaras A C++ egyik fontos tulajdonsaga, hogy lehet}osegunk van az adataink es az }oket manipulalo programkod osszeforrasztasara, egy egysegbe zarasara, egy osztalyba foglalasara. (Ez az un encapsulation) Peldaul tegyuk fel, hogy denaltunk egy karakterkeszletet (font-ot) lero

adatstrukturat (peldaul egy fejreszt es az egyes karakterek tulajdonsagait lero tombot), amely kell}o informaciot tartalmaz ahhoz, hogy a karaktereket kirajzolhassuk a keperny}ore, es vannak fuggvenyeink, amelyekkel a karaktereinket megjelenthetjuk, atsznezhetjuk es mozgathatjuk a kepen. A hagyomanyos C-ben az a szokasos megoldas, hogy az adatstrukturainkat es a hozzajuk tartozo fuggvenyeket egy onallo, kulon fordthato forrasmodulban helyezzuk el. Ez a megoldas mar eleg elegans, de az adatok es az }oket manipulalo fuggvenyek kozott meg nincs explicit osszerendeltseg, tovabba mas programozok egy masik modulbol direkt modon is hozzaferhetnek az adatainkhoz, anelkul, hogy az adatok kezelesere szolgalo fuggvenyeinket hasznalnak. Ilyen esetekben az alap-adatstruktura megvaltozasa fatalis hibat okozhat egy nagyobb project-ben. A C++-ban specialis tarolasi egysegfajtak, az osztalyok szolgalnak arra,

hogy adatokat es a hozzajuk rendelt fuggvenyeket egy egysegkent, egy objektumkent kezelhessunk. Az osztalyok alaptpusa a C++-ban a class, amely hasonlt a hagyomanyos C-b}ol ismert struct-ra es union-ra. A C++-ban a struct  es union is egy bizonyos fajta osztalyok. A union-ra a hagyomanyos ertelemben tovabbra is szukseg van, a struct-ot a kulcsszot pedig a C++-ban alapvet}oen a hagyomanyos C-vel valo kompatibilitas biztostasa vegett tartottak meg. Tehat a fenti kulcsszavak szolgalnak arra, hogy osztalyokat denialhassunk. A C++-ban egy osztaly tpusu tarolasi egyseg (class, vagy struct) fuggvenyeket (un. fuggvenymez}oket { angolul member functions) kombinal adatokkal (adatmez}okkel { angolul data members), es az gy letrejott kombinaciot elrejtjuk, elzarjuk a kulvilag el}ol. Ezt ertjuk az egysegbezaras alatt Egy class-deklaracio hasonlo a jol ismert strukturadeklaraciohoz: class font { . } A fenti deklaracio utan a

(instance) denialhato: font tpussal tetsz}oleges valtozo, objektumpeldany font times"10] font *f ptr Egy masik valtozas a hagyomanyos C-hez kepest az, hogy egy struct vagy class tpuscmke (fenti p eldankban a font) kulcsszo elhagyasaval onmagaban 2.4 OROKLE
S 101 is tpusertek}u, tehat kozvetlenul is hasznalhato valtozok denialasara, deklaralasara. A hagyomanyos C strukturak (struct) es a C++ osztalyok (class) kozott a f}o kulonbseg a mez}okhoz valo hozzaferesben van. A C-ben egy struktura mez}oi (a megfelel}o ervenyessegi tartomanyon belul) szabadon elerhet}oek, mg a C++ban egy struct vagy class minden egyes mez}ojehez valo hozzaferes onalloan kezbentarthato azaltal, hogy publikusnak, privatnak, vagy vedettnek deklaraljuk a public, private es protected kulcsszavakkal. (A hozzaferesi szinteket kes}obb reszletesebben is targyaljuk.) A C es a C++ union-jai tobbe-kevesbe hasonloak,

egy C++ union-ban minden mez}o public, azaz mindenhonnan hozzaferhet}o, es ez a hozzaferesi szint nem is valtoztathato meg. Egy struct-tal denialt osztalyban alapertelmezes szerint minden mez}o public (ennek a hagyomanyos C-vel valo kompatibilitas az oka, egyebkent a struct osztalykent valo hasznalata kerulend}o), de ez megvaltoztathato, mg egy class-szal denialt osztalyban a mez}ok alapertelmezes szerint private hozzaferes}uek, bar ez is modosthato. Az OOP-re jellemz}o az, hogy az adatmez}oket privatnak, a fuggvenymez}oket pedig publikusnak deklaraljuk. A tovabbiakban csak a class tpus}u osztalyokkal foglalkozunk, es javasoljuk, hogy a C++-ban programozok is csak a class kulcsszoval denialjanak osztalyokat. El}obbi pedanknal maradva, a font tpust class-kent (osztalykent) deklaralva elerhetjuk, hogy a privat (private) hozzaferes}u karakter-lero informaciot csak a hozzajuk rendelt publikus (public)

fuggvenyekkel lehessen kezelni. Igy, ha a karakterfont lerasaban valamit valtoztatunk, azt az adott projectben resztvev}o tobbi programozo eszre sem fogja venni (felteve persze, hogy az adatmez}okkel egyutt az azokat kezel}o fuggvenymez}oket is modostjuk). A font-dencionk tobbe mar nem egy konkret reprezentaciohoz kot}odik, hanem azokhoz a m}uveletekhez, amelyeket az egyes karakterekkel vegezhetunk. 2.4 Orokles Mi jut eszunkbe az orokles szorol? Talan az, hogy a gyermek milyen tulajdonsagokat orokolt szuleit}ol, vagy gondolhatunk egy csaladfara is. Ugyanilyen csaladfa epthet}o fel osztalyokkal is. A C++-ban deklaralhatok szarmaztatott osztalyok (derived classes), amelyek oroklik az }ostpusok, az alaposztalyok (base classes) adat- es fuggvenymez}oit. Ez lehet}ove teszi egy hierarchikus osztalystruktura letrehozasat Nezzunk meg erre egy egyszer}u peldat. Ha grakus programot kesztunk, szuksegunk lehet arra,

hogy kezeljuk a grakus keperny}on egy pont (pixel) helyenek x es y koordinatait. Hozzunk ezert letre egy location (hely) nev}u strukturat: struct location { int x int y } Tegyuk fel, hogy szuksegunk van az x, y koordinataban lev}o pont tulajdonsagara is, peldaul nyilvan akarjuk tartani, hogy egy kerdeses pont milyen szin}u. Ezt megoldhatjuk a color (szn) felsorolt tpusu valtozo bevezetesevel. Igy denialjuk a point (pont) tpust:
C++-BAN 2. FEJEZET PROGRAMOZAS 102 enum colortype { black, red, blue, green, yellow, white } struct point { int x int y enum colortype color } Ezek utan deklaralhatunk point tpusu valtozokat: struct point origin, center, current pos, new pos A C++-ban a fenti deklaraciot rovidebben is rhatjuk { leven egy osztalydeniconal megadott tpuscmke onmagaban is tpus ertek}u: point origin, center, current pos, new pos Mint lattuk, a point tpusban is felhasznaltunk olyan adatmez}oket,

amilyenek a location-ban szerepeltek. Jo lenne tehat, ha point denialasahoz felhasznalnank a location tpust Nos, hagyomanyos C-ben a point-ot a location struktura felhasznalasaval gy denialhatnank: struct point { struct location position colortype color } Ez nem mas, mint strukturak egymasbaagyazasa (nested structures). Ugyanakkor a C++ eseteben a deklaracioban jelezhetjuk, hogy a pont is egy hely Ezt ugy tehetjuk meg, hogy mind a point tpust, mind a location tpust classkent denialjuk, es point-ot a location-bol szarmaztatjuk: class location { protected: int x int y } class point : location { colortype color } Ez a deklaracio sokkal jobban kifejezi azt, hogy miben kulonbozik a point tpus a location tpustol. (A protected kulcsszo jelenteset kes}obb targyaljuk majd.) A kulonbseg teljesen nyilvanvaloan abban van, hogy a point egy hely (location), amelyhez valamilyen sznt is rendeltunk. A keperny}on a pont helyzete a point

denciojaban explicit modon nem szerepel, mert azt a location tpustol orokolte. Mivel a point tpus a location lesz armazottja, annak minden mez}ojet orokli, de ugyanakkor a sznt lero mez}ovel b}ovtettuk. Egy szarmaztatott tpus dencios blokkjaban csak az 2.4 OROKLE
S 103 uj, vagy megvaltozott tulajdonsagoknak megfelel}o mez}ok szerepelnek. Termeszetesen a point tpusbol ujabb osztalyokat szarmaztathatunk ugy, hogy tovabb b}ovtjuk tetsz}oleges tpusu mez}okkel. Az gy letrehozott tpusok termeszetesen (az uj tulajdonsagaik mellett) hordozni fogjak a point tpus minden meglev}o tulajdonsagat, es hasznalhatok lesznek minden olyan esetben, amikor point is hasznalhato. Azt az eljarast, amely altal az egyik tpus orokli a masik tpus tulajdonsagait, oroklesnek hvjak. Az orokl}o a leszarmazott tpus (descendant type) Az }ostpus (ancestor type) az, amelyt}ol a leszarmazott tpus orokol. Fenti

peldankban a location az }ostpus, a point pedig a leszarmazott tpus. Kes}obb latni fogjuk, hogy ez az eljaras korlatlanul folytathato. Denialhatjuk a point leszarmazott tpusat, majd ennek a point leszarmazott tpusanak a leszarmazottjat. A programtervezes legnagyobb resze az OOP-ben a megfelel}o osztaly-hierarchianak, azaz az osztalyok csaladfajanak a letrehozasat jelenti. A point tpus a location tpusnak egy kozvetlen leszarmazottja (immediate descendants). Fordtva, a location tpus a point tpusnak kozvetlen }ostpusa (immediate ancestor). Egy objektumtpusnak barmennyi kozvetlen leszarmazottja lehet Az orokles szintaktikailag a kovetkez}okeppen nyilvanul meg. Tegyuk fel, hogy az alfa azonostoju, point tpusu objektum x koordinatajara szeretnenk hivatkozni. Ezt a point tpus hagyomanyos C szerinti beagyazott strukturakkal torten}o dencioja eseten az alfapositionx modon tehetnenk meg, mg C++-ban, mivel a

point tpus mindent orokol a location tpustol, az alfa.x kifejezes a megfelel}o hivatkozas. Mint ahogy a C-ben egy tpussal, a C++-ban a point osztaly segtsegevel tetsz}oleges tarolasi egysegeket (ujabb osztalyokat, valtozokat, tomboket, osztalyokra mutato pointereket, stb.) denialhatunk, gy jutva kulonboz}o objektumpeldanyokhoz: point origin, line"80], point *point ptr1 = &origin point *point ptr2 = line A C++-ban egy szarmaztatott tpus nemcsak egy }ostpustol orokolhet (egy csaladfan pl. minden egyednek van apja is es anyja is) Azt, amikor egy szarmaztatott tpus tobb }ostpusbol kerult levezetesre, tobbszoros oroklesnek (multiple inheritance) nevezzuk A tobbszoros orokles csak az AT&T 20-as verzioju C++ fordtojaval kompatibilis C++ rendszerekben lehetseges Tobbszoros orokles eseten az }ostpusokat egymastol vessz}ovel elvalasztva kell felsorolnunk. Ha tehat father es mother egy-egy

letez}o osztaly (peldaul class-kent denialt tpus), akkor segtsegukkel a child tpust a kovetkez}okeppen deklaralhatjuk: class child : father, mother { // Itt jonnek a child-ra jellemzo // ujabb tulajdonsagok mezoi. } A child tehat orokli a father es a mother minden tulajdonsagat (azaz minden adat- es fuggvenymez}ojet), es egyben ujabb tulajdonsagokkal (mez}okkel) rendelkezhet.
C++-BAN 2. FEJEZET PROGRAMOZAS 104 A mez}ohozzaferes kapcsan a 2.8-as szakaszban latni fogjuk, hogy egy szarmaztatott tpusban az }ostpusoktol orokolt fuggvenymez}ok hozzaferesi szintjei modosthatok az }ostpus-listaban a tpusazonostok el}ott elhelyezett megfelel}o kulcsszavakkal (private, protected). Mivel a szarmaztatott tpusokkal mindent olyan m}uvelet elvegezhet}o, ami a denicioja soran felhasznalt }ostpusokhoz felhasznalhato, ezert egy szarmaztatott tpus mindig felulr}ol kompatibilis az }ostpusaival.  Osszefoglalva tehat

a fent lertakat: Hagyomanyos C-ben egy struktura nem tud orokolni, a C++ azonban tamogatja az oroklest. A nyelvnek ez a kiterjesztese egy uj tarolasi egyseg-fajtaban nyilvanul meg, amely hasonlo a C-ben megszokott tarteruletfoglalo tarolasi egysegekhez, a strukturakhoz es a -unionokhoz, de azoknal sokkal hatekonyabb. A tarolasi egysegek ezen uj fajtaja az osztaly. Hatekonysaga abban all, hogy mg a hagyomanyos C-ben hierarchikusan egymasbaagyazott strukturarendszerben csak adatmez}ok "orokl}odnek", addig a C++ osztalyok eseteben egy objektum egyeb tulajdonsagai { nevezetesen az, hogy az adatmez}okkel mit es hogyan lehet csinalni { is (azaz a fuggvenymez}ok is) orokl}odnek. Megjegyzend}o, hogy a hagyomanos C egymasba skatulyazott strukturai eseteben nincs szo igazi oroklesr}ol, es a skatulyazas reven denialt ujabb strukturak, es a denialashoz felhasznalt strukturak kozott semmifele

tpuskompatibiltas nincs. A C++ osztalyok tpus-kompatibilitasat a point { location paros felhasznalasaval az alabbiakban szemleltethetjuk: egy point osztalyba tartozo valtozo minden olyan esetben alkalmazhato, amikor egy location osztalyba tartozo erteket varunk. Tehat a location *a point b deklaracio mellett C++-ban az a = &b ertekadas helyes, mg hagyomanyos Cben, ha point es location egy-egy struktura, akkor a fenti ertekadas helytelen. 2.5 Tobbret}useg (polimorzmus) A tobbret}useg (vagy sokalakusag, sokoldalusag) a C++-ban azt jelenti, hogy egy adott }ostpusbol szarmaztatott tovabbi tpusok termeszetesen oroklik az }ostpus minden mez}ojet, gy a fuggvenymez}oket is. De az evolucio soran a tulajdonsagok egyre modosulnak, azaz peldaul egy oroklott fuggvenymez}o neveben ugyan nem valtozik egy leszarmazottban, de esetleg mar egy kicsit (vagy eppen nagyon) maskepp viselkedik. Ezt a C++-ban a

legexibilisebb modon az un. virtualis fuggvenyek (virtual functions) teszik lehet}ove A virtualis fuggvenyek biztostjak, hogy egy adott osztaly-hierarchiaban (szarmazasi fan) egy adott fuggveny kulonboz}o verzioi letezhessenek ugy, hogy csak a kesz program futasa soran derul, hogy ezek kozul eppen melyiket kell vegrehajtasra meghvni. Ezt a mechanizmust, azaz a hvo es a hvott fuggveny futasi id}o alatt torten}o osszerendeleset kes}oi osszerendelesnek (late binding) nevezzuk. Err}ol majd a 2.9-es reszben olvashatunk reszletesebben A tobbret}usegnek a fordtasi id}oben megvalosthato formaja az un. overloading (A szerintunk is alkalmas magyar kifejezes helyett az eredeti angol kifejezest hasznaljuk konyvunkben. U gy gondoljuk, hogy a szoszerinti fordtas, a tulterheles nem fejezi ki e fogalom lenyeget. A overloading helyett esetleg } E
G (POLIMORFIZMUS) 2.5 TOBBRE
TUS 105 hasznalhatnank az

atdenialas kifejezest, de mint kes}obb latni fogjuk, ez sem precz megfogalmazas.) Nos, lassuk, mir}ol is van szo: A hagyomanyos C-ben egy adott nevvel csak egy fuggvenyt denialhatunk. Peldaul ha deklaraljuk az int cube(int number) fuggvenyt, akkor kiszamthatjuk egy egesz szam kobet, de elkepzelhet}o, hogy egy long, vagy egy double szam kobere van szuksegunk. Termeszetesen rhatnank meg ket tovabbi fuggvenyt erre a celra, de a cube azonostot mar nem hasznalhatjuk: long lcube(long lnumber) double dcube(double dnumber) A C++-ban megis lehet}oseg van arra, hogy ugyanolyan azonostoval lassuk el mind a harom fuggvenyt. Ezt hvjak angolul overloading-nak Ez tehat azt jelenti, hogy lehet}osegunk van arra, hogy egy azonos nevvel tobb kulonboz}o fuggvenyunk legyen, melyek termeszetesen kulonboz}o adattpusokat dolgoznak fel: int cube(int inumber) long cube(long lnumber) double cube(double dnumber) Ha az azonos

nev}u fuggvenyek parameterlistaja kulonboz}o, a C++ gondoskodik arrol, hogy egy adott tpusu aktualis parameterrel mindig a megfelel}o fuggvenyvaltozatot hvja meg. Igy peldaul a cube(10) hivatkozas a cube fuggveny egesz erteket visszaado valtozatat hvja meg, mg cube(2.5) hvassal a duplapontossagu lebeg}opontos valtozatot aktivizaljuk Felhvjuk a gyelmet arra a veszelyre, hogy igen konnyen a szandekainktol elter}o fuggvenyvaltozatot is aktivizalhatjuk. Peldaul ha a double valtozatot akartuk meghvni a 20 ertekkel, de veletlenul csak 2-t rtunk, akkor az int verzio hvasat tetelezi fel a C++ fordto. Az overloading altalanosabban azt jelenti, hogy egy adatokon valamilyen operacio vegrehajtasat jelent}o szimbolumhoz (fuggvenyazonostohoz, operatorhoz) tobb, kulonboz}o tpusra vonatkozo kulonboz}o jelentest rendelunk. Hogy egy adott adathoz egy m}uvelet milyen ertelmezese tartozik, az az adott

adat tpusatol, vagy preczebben fogalmazva az adott operaciot vegrehajto fuggveny un. parameter-szignaturajatol fugg Parameter-szignaturan azt ertjuk, hogy egy fuggvenynek mennyi es milyen tpusu parametere van, es az egyes parameterek milyen sorrendben kovetik egymast. Tehat attol fugg}oen, hogy egy fuggvenyt milyen tpusu parameterekkel aktivizalunk, mindig az aktualis parameterekkel megegyez}o szignaturaju fuggvenyvaltozat hvasanak megfelel}o kodot general a C++ fordto. Ezt siganture matching-nek nevezzuk (Itt valik nyilvanvalova a hagyomanyos C programokban a modern stlusu fuggvenydeniciok, illetve fuggvenydeklaraciok fontossaga: ezek nelkul a fordto program nem tudja egyeztetni az aktualis parameterlistat a formalis parameterlistaval.) Az eddig elmondottakbol nyilvanvalo, hogy az overloading nem atdenialast jelent, hiszen amikor az overloading altal egy szimbolumhoz { a jelen

peldankban a cube fuggvenyazonostohoz { egy ujabb jelentest rendeltunk, a korabbi jelentesek nem vesztek el. 106
C++-BAN 2. FEJEZET PROGRAMOZAS 2.6 Fuggvenymez}ok denialasa Ebben az alfejezetben az orokles fogalmanal hasznalt grakus peldat folytatjuk. Az el}oz}oekben lathattuk, hogy egy osztalynak nemcsak adatmez}oi, hanem fuggvenymez}oi (function members) is lehetnek. Egy fuggvenymez}o nem mas, mint egy, a class dencion belul deklaralt fuggveny. (A fuggvenymez}oket mas OOP nyelvekben, peldaul a Smalltalk-ban, vagy a Turbo Pascal-ban metodusoknak hvjak). Most deklaraljunk egy get x azonostoju fuggvenymez}ot a point osztaly szamara. Ezt ketfelekeppen tehetjuk meg: a) vagy az osztaly-dencion belul denaljuk a fuggvenyt (un. implicit inline fuggvenykent), b) vagy az osztalydencion belul csak deklaraljuk, es azutan valahol kes}obb denialjuk. A ket modszer kulonboz}o szintaxissal

rendelkezik. Lassunk egy peldat az els}o lehet}osegre: class point { int x int y colortype color int get x(void) { return x . // implicit inline definicio } } Ez a fajta dencio alapertelmezesben inline fuggvenykent denialja a get x-et. Ez az un. implicit inline fuggveny denicio Figyeljuk meg, hogy az implicit inline fuggvenydencio szintaxisa a hagyomanyos C-ben megszokottak szerinti. A masodik lehet}osegnel a C-szintaxissal csak deklaraljuk a get x fuggvenyt a point osztalyban, es kes}obb adjuk meg a fuggveny teljes deniciojat: class point { int x int y colortype color int get x(void) // majd definialjuk . } int point::get x(void) { return x } // Itt jobb lenne az implicit inline definicio Figyeljuk meg alaposan, hogy hasznaltuk a :: hataskort denialo operatort (scope resolution operator) a point::get x fuggvenydencioban. A point osztalyazonosto szukseges ahhoz, hogy a fordtoprogram tudja, melyik osztalyhoz }

DEFINIAL
ASA
2.6 FUGGVE
NYMEZOK 107 is tartozik a get x fuggvenydencioja, valamint tudja azt is, hogy mi az ervenyessegi tartomanya. Ez tehat azt jelenti, hogy a pont::get x fuggveny (a hagyomanyos globalis valtozokon kvul) csak a point osztalyhoz tartozo objektumok mez}oihez ferhet hozza. Termeszetesen letezhet tobb, mas osztalyhoz tartozo get x fuggveny is. (Erre a lehet}osegre { bar nem explicit modon { utaltunk a tobbret}useg targyalasanal.) Az osztaly-deklaracion beluli fuggvenydenicio eseteben termeszetesen nem volt szukseg az ervenyessegi tartomanyt denialo point:: el}otagra, hiszen a get x fuggveny hovatartozasa abban az esetben teljesen egyertelm}u volt. A hovatartozas denialasan tulmen}oen a point::-nak mas szerepe is van. Hatasa kiterjed az }ot kovet}o fuggvenydenciora oly modon, hogy a get x fuggvenyen belul az x azonostoju valtozora valo hivatkozas a point struktura x

azonostoju adatmez}ojere vonatkozik, valamint a get x fuggveny a point osztaly hataskorebe kerul (lasd a 2.62-es reszt) Fuggetlenul attol, hogy a fuggvenymez}ot milyen modon denialjuk, a lenyeg az, hogy van egy get x nev}u fuggvenyunk, ami szorosan hozza van kapcsolva a point n evvel ellatott osztalyhoz. Mivel a get x-et mez}okent denialtuk a point sz amara, a point minden adatmez}ojehez hozzaferhet. Ebben az egyszer}u peldankban get x egyszer}uen csak x erteket szolgaltatja. Elkepzelhet}o, hogy egy szarmaztatott tpusban lokalisan deklaralunk egy fuggvenymez}ot, melynek azonostoja es parameterlistaja is megegyezik egy }ostpusban denialt fuggvenymez}o azonostojaval es parameterlistajaval, ugyanakkor a dencio soran fel szeretnenk hasznalni az }ostpusbeli valtozatot. Mivel a kes}obbi dencioban lev}o fuggvenymez}o a sajat hataskoreben elfedi a korabbi denciot, a szarmaztatott tpusban csak

az ervenyessegi tartomanyt denalo operator segtsegevel hasznalhatjuk az }ostpusban denialt, "elfedett" fuggvenymez}ot. Erre vonatkozoan (az eddigi peldankat egy kicsit felreteve) tekintsuk az alabbi deklaraciokat: class rectangle { int a, b // Negyszog adatai . void show(void) // Kirajzolja } class triangle { int a, b, c // Haromszog adatai . void show(void) // Kirajzolja } class house : rectangle, // Ostipusok triangle { // Egy hazat definial . // Tetszoleges mezok void show(void) // Kirajzolja } // Az egyes fuggvenymezok definicioi: void rectangle::show( ) { . } // Egy negyszoget rajzol void triangle::show( ) { . } // Egy haromszoget rajzol void house::show( ) // Egy hazat rajzol { // Itt az egyszeru show azonosito a house tipus // fuggvenymezojet jelenti, a show hivas rekurzio lenne
C++-BAN 2. FEJEZET PROGRAMOZAS 108 rectangle::show( ) // alap . triangle::show( ) // teto . ::show( ) // Egy globalis, show fuggveny hivasa } Amint az fenti

peldabol is latszik, ha egy hagyomanyos, nem egy osztaly fuggvenymez}ojekent deklaralt show fuggvenyt akarunk meghvni, akkor a fuggvenynev ele egy "ures" ervenyessegi tartomanyt denialo operatort (::) kell tennunk (azaz nem utaljuk egy osztaly hataskorebe sem, gy a teljes programra nezve globalis lesz a fuggveny). Ezutan a kiter}o utan a foglalkozzunk tovabb a megszokott point / location peldaval 2.61 Fuggvenymez}ok aktivizalasa A fuggvenymez}ok egy adott tpusu adathalmazon vegrehajtando m}uveleteket jelentenek. Amikor tehat a get x fuggvenyt meghvjuk, tudatnunk kellene vele azt is, hogy most eppen melyik denialt point tpusu objektum-peldany (object instance) x koordinataira van szuksegunk, eppen ezert valahogy ezt az informaciot is kozolnunk kell a fordtoprogrammal. A megoldas a hagyomanyos C struktura-mez}okhoz valo hozzaferes szintaktikajanak kiterjesztese. Ha origin egy point

tpusu objektum-peldany, akkor az origin.x hivatkozashoz hasonloan az origin.get x( ) kifejezes az origin objektum-peldany get x fuggvenymez}oje altal szolgaltatott erteket jelenti. A hagyomanyos C struktura adatmez}o-hozzafereshez hasonloan itt is a (pont) karakter jatssza az osztaly mez}okivalaszto operatoranak (class component selector) szerepet. Az altalanos szintaxis a kovetkez}o: objektumnev.fuggvenymez}o-nev(argumentumlista) Az el}obbiekhez hasonloan, ha p ptr egy point* tpusu mutato, akkor a p ptr->get x( ) kifejezes a p ptr altal megcmzett point tpusu objektum get x fuggvenymez}oje altal szolgaltatott erteket adja. 2.62 A this nev}u, implicit mutato Egy fuggvenymez}oben direkt modon is hivatkozhatunk arra az objektumra, amelyiknek a fuggvenymezejet aktivizaltuk. Peldaul a class cc { int m public: . int read m(void) { return m } } 2.7 KONSTRUKTOROK E
S DESTRUKTOROK 109 deklaracio eseten, ha aa

es bb cc tpusuak, akkor az aa.read m( ), illetve a fuggvenyhvasok eseten rendre az aa.m, illetve bbm ertekeket kapjuk. A fuggvenyhvas soran ugy derul ki, hogy melyik objektum adatmez}oit kell hasznalni, hogy minden fuggvenymez}o szamara implicit modon deklaralasra kerul egy this nev}u pointer. Ha tehat a read m fuggveny egy cc tpusu osztaly fuggvenymez}oje, akkor a read m-en belul this egy cc* tpusu pointer, ilyen modon az els}o read m hivatkozasnal this az aa valtozora, mg a masodik hivatkozas alkalmaval a bb-re mutat, azaz az els}o esetben this == &aa, a masodik esetben pedig this == &bb. A this mutato explicit modon is megjelenhet a fuggvenymez}ok dencioja soran: bb.read m( ) class cc { int m public: int read m(void) { return this->m } } 2.7 Konstruktorok es destruktorok Ket specialis, el}oredenialt fuggvenymez}o-fajta letezik, amelyek kulcszerepet jatszanak a C++-ban. Ezek a konstruktorok

(constructors) es a destruktorok (destructors). Hogy jelent}oseguket megertsuk, tegyunk egy kis kiter}ot A ltalanos problema a hagyomanyos nyelveknel az inicializalas. Miel}ott hasznalnank egy adatstrukturat, gondoskodnunk kell arrol, hogy megfelel}o tarteruletet biztostsunk az adatstruktura szamara es megfelel}o kezdeti ertekkel rendelkezzen a adott tpusu valtozo Tekintsuk a point osztaly egy korabbi deklaraciojat: class point { int x int y colortype color } Kezd}o programozok az egyes adatmez}oket gy inicializalnak: point a point . a point.x = 10 a point.y = 25 a point.colortype = black Ez a kezdeti ertekadas korrekt, de csak az a point valtozonak ad erteket. Ha tobb point tpusu valtozot akarunk inicializalni, akkor tobbszor meg kell ismetelni a fentihez hasonlo ertekado utastasokat. A kovetkez}o termeszetes lepes az lenne, hogyrunk egy inicializalo fuggvenyt, amely tetsz}oleges, argumentumkent atadott

point tpusu objektumot inicializal. void init point(point* target, int newx, int newy) {
C++-BAN 2. FEJEZET PROGRAMOZAS 110 target->x = newx target->y = newy target->color = black } Ezt a fuggvenyt jol terveztuk meg: tetsz}oleges point tpusu objektumot inicializal. De miert kell megadnunk az inicializalashoz az osztaly tpusat es azt a konkret objektumot, amelynek kezdeti erteket kell adnunk? A valasz egyszer}u: azert, mert nem fuggvenymez}okent deklaraltuk az inicializalo fuggvenyt. Amire igazan szuksegunk van, az egy olyan fuggvenymez}o, amelyik tetsz}oleges point tpus u objektumot automatikusan inicializal. Az ilyen fuggvenymez}ot konstruktornak nevezzuk. A C++ lozoajanak egyik lenyeges eleme, hogy a felhasznalo altal denialt adattpusok ugyanolyan integrans reszei legyenek egy programnak, mintha beeptett tpusok lennenek. Ezert a C++ kulonleges fuggvenymez}oket knal szamunkra, amelyek

meghatarozzak, hogy milyen modon hozhatok letre egy adott osztaly objektumai. Ezek a konstruktorok Egy konstruktor lehet a felhasznalo altal denialt, vagy lehet a C++ rendszer alapertelmezese szerinti. A konstruktorokat akar explicit, akar implicit modon meghvhatjuk A C++ mindig automatikusan meghvja a megfelel}o konstruktort, amikor egy adott osztallyal objektum-peldanyt denialunk. Ez akar denicio, akar egy objektum masolasa, vagy akar a new operatorral (lasd kes}obb) dinamikusan letrehozott objektumok eseteben megtortenik. A destruktorok { mint ahogy nevuk is mutatja { egy konstruktor altal korabban letrehozott objektum megszunteteseben segtenek: torlik a mez}ok tartalmat es altalaban felszabadtjak az objektum altal elfoglalt tarteruletet. A destruktorok szinten explicit modon (lasd a delete operatort kes}obb), akar implicit modon { peldaul egy automatikus valtozo megsz}unesekor { aktivizalhatok. Ha nem

denialunk mi magunk destruktort egy adott osztalyhoz, a C++ a sajat alapertelmezese szerinti valtozatat fogja hasznalni. Egy altalunk denialt destruktor egy objektum megsz}unesevel kapcsolatos kiegeszt}o m}uveleteket vegezhet, peldaul adatokat rhat diszkre, le-okat zarhat le, keperny}ot torolhet, stb. 2.71 Konstruktorok de nialasa Most tekintsuk at el}oszor a konstruktorok denialasat a megszokott point tpusunk eseteben! b}ovtsuk ki az eddigi deklaraciot egy konstruktorral. class point { int x int y colortype color int get x(void) { return x int get y(void) { return y colortype get color(void) void show(void) void hide(void) point(int newx, int newy) // konstruktor deklaracio } } 2.7 KONSTRUKTOROK E
S DESTRUKTOROK 111 } point::point(int newx = 0, int newy = 0) { // konstruktor definicio x = newx y = newy color = black } A konstruktort ugyanugy deklaralhatjuk, mint minden egyeb fuggvenymez}ot. Figyeljuk ugyanakkor meg, hogy a

konstruktor neve es az osztaly neve ugyanaz, mind a kett}o point. Innen tudja a fordtoprogram, hogy az adott fuggvenymez}o egy konstruktor. Figyeljuk meg azt is, hogy mint minden fuggvenynek, a konstruktornak is lehetnek parameterei, a konstruktor torzse pedig egy szabalyos fuggvenytorzs. Ez azt jelenti, hogy egy konstruktor hvhat mas fuggvenyeket es minden, a hataskorebe tartozo adathoz hozzaferhet. Az egyetlen, de lenyeges kulonbseg, hogy egy konstruktornak nem lehet tpusa, meg void sem! (Igy erteket sem adhat vissza.) A fenti konstruktor-deklaraciot gyelembe veve az alabbi modon deklaralhatunk egy point tpusu objektumot: point a point(100,200) Ez a deklaracio aktivizalja a fent denialt konstruktort, es ennek kovetkezteben a pont x es y koordinataja rendre 100 ill. 200 lesz Az overloading a konstruktorok eseteben is alkalmazhato, gy egy osztalynak tobb konstruktora is lehet, es mindig az aktualis parameterlista

alapjan d}ol el, hogy melyik valtozatot kell aktivizalni. Ha nem denialunk mi magunk egy konstruktort, akkor a C++ general egyet, amelynek nincsenek argumentumai Egy tovabbi C++ trukk, hogy az altalunk denialt konstruktor argumentumaihoz egy alapertelmezest rendelhetunk, mint ahogy azt a point::point fuggveny eseteben is tettuk. Ekkor a point a point(5) dencio hatasara az x koordinata erteke 5 lesz, mg az y koordinata erteke az altalunk adott alapertelmezes szerinti 0 marad. Egy specialis konstruktor az un. masolo konstruktor (copy constructor) Ha s egy oszt aly, akkor a hozza tartozo masolo konstruktor alakja s::s(s&). A masolo konstruktor jelent}oseget megerthetjuk, ha arra gondolunk, hogy sztringek tarolasara hozunk letre egy s osztalyt (tehat nem elegszunk meg a C karaktertombjeivel, hanem peldaul olyen kinomult sztringkezel}o rendszert szeretnenk kiepteni, mint amilyen miatt sokan meg mindig ragaszkodnak a

BASIC-hez). Ekkor ha a es b egy-egy s osztalyba tartozo sztringvaltozo, es elvegezzuk az a = b ertekadast, akkor nem szeretnenk azt, hogy b tartalmanak megvaltoztatasa maga utan vonja a tartalmanak megvaltozasat. Hagyomanyos, egyszer}u C sztringkezeles mellett a fenti ertekadas csak azt eredmenyezne, hogy egy karakter-pointer erteket egy masik pointer valtozoba masoljuk, gy ugyanazt a karaktertombot cmzik meg, gy a "masolat" nem vedhet}o meg az "eredeti" sztringben vegrehajtott modostasoktol. 2.72 Destruktorok de nialasa Ahogy konstruktorokat denialhatunk, ugyanugy denalhatunk sajat magunk destruktorokat is. 112
C++-BAN 2. FEJEZET PROGRAMOZAS A statikus objektumok szamara a C++ futtato rendszer a main meghvasa el}ott foglal tarteruletet es a main befejezese utan felszabadtja azt. Az auto objektumok eseteben a tarteruletfelszabadtas akkor tortenik meg, amikor az adott valtozo

ervenyet veszti (tehat az objektum deniciot tartalmazo blokk vegen). Az altalunk denialt destruktorokat akkor aktivizalja a C++ futtato rendszer, amikor egy objektumot meg kell szuntetni. A destruktor dencio hasonlt a konstruktor denciora. Ha a point tpusu objektumoknak point::point a konstruktora, akkor point::~point lesz a destruktoruk. A formai kulonbseget csak a ~ (tilde) karakter jelenti (ami a komplementalas operatora). class point { int x int y colortype color int get x(void) { return x } int get y(void) { return y } colortype get color(void) void show(void) void hide(void) point(int newx, int newy) // konstrktor ~point(void) // destruktor } A fenti pelda els}o ranezesre felesleges, hiszen eleg lenne a C++ futtato rendszer alapertelmezes szerinti destruktorara hagyatkozni. Igen am, de egy megsz}unesre telt pontot a keperny}or}ol is el kell tuntetni. Ez azt jelenti tehat, hogy egy olyan destruktor fuggvenyt kell denialnunk a

point tpus szamara, amelyik szukseg eseten (peldaul ha a hatterszin == get color() igaz) a hide fuggveny meghvasaval az adott pontot le is torli a keperny}or}ol. 2.8 Mez}ohozzaferes Ahogy a 2.1-es szakaszban az egysegbezaras kapcsan mar utaltunk ra, egy osztaly egyes mez}oihez valo hozzaferest mi magunk is kezben tarthatjuk a C++ altal nyujtott alapertelmezes felulbralasaval. A C++-ban a struct tpusu osztalyokban csak reszben ervenyesul az egysegbezaras. Nevezetesen az egyseg megvan, ugyanis az adatmez}ok es a fuggvenymez}ok egybe vannak forrasztva, de nincsenek elzarva a kulvilagtol Ennek oka az, hogy az alapertelmezes szerint egy struct minden mez}oje publikus, a kulvilagbol szabadon hozzaferhet}o. A jo C++ programtervezes szem el}ott tartja az adat- vagy meg inkabb az informaciorejtest, azaz egy osztaly egyes mez}oit privatnak, vagy vedettnek deklaralja, es ezzel egyidej}uleg jol denialt,

korulhatarolt "hivatalos" kuls}o hozzaferest biztost hozzajuk. A ltalanos elvkent tekinthetjuk azt, hogy az adatmez}ok privatak vagy vedettek es a csak bels}o m}uveleteket vegrehajto fuggvenymez}ok szinten privatak, mg a kulvilaggal valo kapcsolattartast publikus fuggvenymez}ok biztostjak. Ezert javasoljuk a class hasznalatat a struct helyett, hiszen a class alapertelmezes szerinti mez}ohozzaferesi szintjei pontosan a fenti kivanalmaknak felenek meg. }
E
RE
S 2.8 MEZOHOZZ AF 113 A C++-ban harom, a cimkekhez formailag hasonlo modon hasznalhato kulcsszo all rendelkezesunkre, hogy a mez}ohozzaferest mi magunk allthassuk be egy osztaly-dencio soran. A mez}ohozzaferes-szabalyozas altalanos szintaktikaja a kovetkez}o: hozzaferesi mod : mez}olista ahol a hozzaferesi mod a public, private, vagy protected kulcsszavak egyike lehet. Peldaul ha point-ot struct-kent deklaraljuk, celszer}u az

alabbi mez}ohozzaferest bealltani: struct point { // Ez most private: int int colortype public: int colortype point(int } csak a pelda miatt struct !!! // Privat x y color // Publikus get x(void) { return x } get color(void) newx, int newy) Egy mez}ohozzaferest modosto kulcsszo hatasa egy kovetkez}o hasonlo kulcsszoig, vagy az }ot tartalmazo blokkzaro kapcsos zarojelig tart. 2.81 Mez}ohozzaferesi szintek Mint emltettuk, harom kulonboz}o szinten erhetjuk el egy osztaly egyes mez}oit. Most tekintsuk at reszletesen, mit is jelent e harom szint. A private-kent deklaralt mez}oket csak az ugyanabban az osztalyban deklaralt fuggvenymez}ok erhetik el. A protected mez}oket az ugyanabban az osztalyban, es az adott osztalybol szarmaztatott tovabbi osztalyokban denialt fuggvenymez}ok erhetik el. A public mez}ok korlatozas nelkul elerhet}ok mindenhonnan, ahonnan az adott osztaly is elerhet}o A struct-tal denialt osztalyok

mez}oi alapertelmezes szerint mind publikusak (public eleresuek), gy ahhoz, hogy az igazi egysegbezarast megvalosthassuk, a kulvilag el}ol elzarando mez}oket mi magunk kell, hogy a private kulcsszoval privatnak deklaraljuk (a private reszt esetleg kovet}o ujabb nyilvanos reszeket megint a public kulcsszoval kell megnyitnunk a kulvilag szamara). Minthogy egy jo C++ programozo mindent privatnak tekint es csak azt mondja meg kulon, hogy mely mez}ok publikusak, osztalyok denialasara el}onyosebb a class-t haszn alni a struct helyett, ugyanis egy class minden mez}oje alapertelmezes szerint private. (Az egyetlen kulonbseg a struct es a class kozott tehat a mez}ohozzaferes alapertelmezeseben van.) A point tpust class-kent denialva gy celszer}u a mez}ohozzaferest a kovetkez}ok szerint szabalyozni: class point { // Alapertelmezes szerint privat: int x int y colortype color public: // Publikus:
C++-BAN 2. FEJEZET

PROGRAMOZAS 114 int int get x(void) { return x get y(void) { return y } } colortype get color(void) void show(void) void hide(void) point(int newx, int newy) ~point(void) } Nincs szuksegunk tehat a private kulcsszora az adatmez}ok denialasakor, ugyanakkor a fuggvenymez}oket public-nak kell deklaralni, hogy letrehozhassunk point tpus u objektumokat es hogy bel}oluk ertekeket olvashassunk ki. 2.82 Mez}ohozzaferes es orokles A mez}ohozzaferes es az orokles egymassal szoros kapcsolatban allnak. Ennek attekintesehez a point tpusnak a location-bol levezetett valtozatat hasznaljuk ugy, hogy mar a mez}ohozzaferest is szabalyozzuk. enum colortype { black, red, blue, green, yellow, white } class location { protected:// A csak vedett mezoket a szar// maztatott tipusok is elerhetik int x int y public: // Publikus fuggvenyek a kulvilagnak int get x(void) int get y(void) location(int ix, int iy) // Konstruktor ~location(void) // Destruktor }

class point : public location { // A publikus szarmaztatas azt jelenti, hogy // location mezoinek hozzaferesi szintjei // valtozatlanul oroklodnek. protected: // A leszarmazottak is lathatjak colortype color public: colortype get color(void) void show(void) void hide(void) point(int ix, iy) ~point(void) } // Konstruktor // Destruktor
FUGGVE
NYEK 2.9 VIRTUALIS 115 A location adatmez}oit { a class-ra vonatkozo private alapertelmezessel szemben { csak vedettnek deklaraljuk, hogy a szarmaztatott tpusok { peldaul a point { is hozzaferhessenek, de azert akarhonnan megse legyenek elerhet}ok. A fuggvenymez}oket (a konstruktort is ideertve) nyilvanosnak deklaraltuk, hogy barki letrehozhasson location tpusu objektumot, illetve hogy ki lehessen olvasni a koordinatakat. Egy szarmaztatott tpust altalaban a kovetkez}okeppen deklaralhatunk: class D : hozzaferes-modosto B f . g struct D : hozzaferes-modosto B f . g illetve ahol D a

szarmaztatott (derived) osztaly tpusazonostoja, B pedig az alap osztaly (base class) tpusazonostoja. A hozzaferes-modosto vagy public, vagy private lehet! haszn alata opcionalis. Mint mar emltettuk, class eseten a hozzaferes-modosto alapertelmezes szerint private, struct eseten pedig public Egy szarmaztatott osztaly mez}oihez valo hozzaferest csak szigortani lehet az alaptpus egyes mez}oinek hozzaferesi szintjeihez kepest. Egy osztalyt egy masikbol publikus vagy privat modon szarmaztathatunk. Ha a hozzaferes-modosto a private, akkor az osszes protected es public mez}o private lesz. Ha a hozz aferes-modosto a public, akkor a szarmaztatott tpus valtozas nelkul orokli az alaptpus mez}ohozzaferesi szintjeit. Egy szarmaztatott tpus az alaptpus minden mez}ojet orokli, de azok kozul csak a public es a protected mez} oket hasznalhatja korlatozas nelkul. Az alaptpus private mez}oi a

szarmaztatott tpusban direkt modon nem erhet}ok el. A legutobbi peldaban location-t  es point-ot ugy deklaraltuk, hogy megfelel}o informaciorejtes mellett tovabbi, osszetettebb osztalyokat deklaralhassunk. A hozzaferes modostot celszer}u explicit modon megadni, fuggetlenul egy osztalyfajtara (class-ra, vagy struct-ra) vonatkozo alapertelmezest}ol. 2.9 Virtualis fuggvenyek 2.91 Kes}oi osszerendeles Az el}oz}o reszekben egy osszetett grakus programrendszer lehetseges alaptpusainak peldajan mutattuk be az OOP egyes jellemz}oit. A point tpus a location-b ol lett szarmaztatva, ugyangy point-bol letrehozhatunk egy vonalakat lero osztalyt, amelyet peldaul line-nak nevezhetunk, es mondjuk line-bol szarmaztathatunk mindenfele poligont. A poligonokra ket vazlatos peldat mutattunk (triangle, rectangle), ezekb}ol feleptve pedig mar egy "valosagos" objektumok lerasara valo tpus, a house vazlatos

lerasat adtuk. (Ezek a peldak termeszetesen nem egy m}ukod}o program letrehozasara, hanem sokkal inkabb egy-egy OOP fogalom megvilagtasara voltak kihegyezve.) Az eddigi peldak tobbsegenek ugyanakkor volt egy kozos vonasa, nevezetesen az, hogy deklaraltunk bennuk egy-egy show azonostoju fuggvenymez}ot azzal a cellal, hogy az az adott tpusu objektumot a keperny}on megjelentse. Az alapvet}o kulonbseg az altalunk elkepzelt objektumtpusok kozott az, hogy milyen modon kell }oket a keperny}ore 116
C++-BAN 2. FEJEZET PROGRAMOZAS kirajzolni. Az egesznek van egy nagy hatranya: akarhanyszor egy ujabb alakzatot lero osztalyt denialunk, a hozzatartozo show fuggvenyt mindannyiszor ujra kell rnunk. Ennek az az oka, hogy a C++ alapvet}oen haromfelekeppen tudja az azonos nevvel ellatott fuggvenyeket egymastol megkulonboztetni:
a parameterlistak k ulonboz}osege (az un. parameterszignatura) alapjan,

tehat show(int i, char c) es show(char *c, float f) egymastol kulonboz}o fuggvenyek,
az ervenyessegi tartomanyt denial o operator alapjan, tehat a rectangle::show  es a triangle::show, valamint a ::show fuggvenyek kulonboz}oek,
illetve az egyes objektum-peldanyok f uggvenymez}oit a mez}okivalaszto operator(ok) segtsegevel. Az ilyenfajta fuggvenyhivatkozasok feloldasa mind fordtasi id}oben tortenik. Ezt nevezzuk korai, vagy statikus osszrendelesnek (early binding, static binding). Egy komolyabb grakus rendszer eseteben azonban igen gyakran el}ofordul az a helyzet, hogy csak az osztalydeklaraciok allnak rendelkezesre forrasallomanyban (.h kiterjesztes}u include le-okban), maguk a fuggvenymez}o denciok pedig csak targykod formajaban vannak meg (obj le-okban) Ebben az esetben, ha a felhasznalo a meglev}o osztalyokbol akar ujabbakat szarmaztatni, akkor a korai kotes korlatai miatt nem lesz konny}u dolga az

alakzatmegjelent}o rutinok megrasanal. A C++ ezt a problemat az un kes}oi kotes (late binding) lehet}osegevel hidalja at. Ezt a kes}oi kotest specialis fuggvenymez}ok, a virtualis fuggvenyek (virtual functions) teszik lehet}ove. Az alapkoncepcio az, hogy a virtualis fuggvenyhvasokat csak futasi id}oben oldja fel a C++ rendszer { innen szarmazik a kes}oi kotes elnevezes. Tehat azt a dontest, hogy peldaul melyik show fuggvenyt is kell aktivizalni, el lehet halasztani egeszen addig a pillanatig, amikor a tenylegesen megjelentend}o objektum pontos tpusa ismertte nem valik a program futasa soran. Egy virtualis show fuggveny, amely el van "rejtve" egy el}ozetesen lefordtott modulkonyvtar egy B alaposztalyaban, nem lesz veglegesen hozzarendelve a B tpusu objektumokhoz olyan modon, ahogy azt normal fuggvenymez}ok eseteben lattuk. Nyugodtan szarmaztathatunk egy D osztalyt a B-b}ol, denialhatjuk a D

tpusu objektumok megjelentesere szolgalo show fuggvenyt. Az uj forrasprogramot (amelyik az uj D osztaly denciojat is tartalmazza) lefordtva kapunk egy .obj le-t, amelyet hozzaszerkeszthetunk a grakus konyvtarhoz (a .lib le-hoz) Ezutan a show fuggvenyhvasok, fuggetlenul attol, hogy a B alaposztalybeli fuggvenymez}ore, vagy az uj, D osztalybeli fuggvenymez}ore vonatkoznak, helyesen lesznek vegrehajtva. Lassuk ezt az egesz fogalomkort egy kevesbe absztrakt peldan Tekintsuk a jol bevalt point tpust, es egesztsuk ki azt egy olyan fuggvenynyel, amelyik egy ilyen tpusu objektum altal reprezentalt pontot a keperny}o egyik helyer}ol athelyezi egy masikra helyre. A point-bol azutan szarmaztassunk egy korok lerasara alkalmas circle tpust (olyan meggondolas alapjan, hogy egy pont egy olyan kor, amelynek sugara 0, tehat a point tpust egyetlen adatmez}ovel, a sugarral kell kiegeszteni). enum colortype {

black, red, blue, green, yellow, white } class location { protected:
FUGGVE
NYEK 2.9 VIRTUALIS int x int y public: location(int ix, int iy) ~location(void) int get x(void) int get y(void) } class point : public location { protected: colortype color public: colortype get color(void) void show(void) void hide(void) void move(int dx, int dy) point(int ix,int iy) ~point(void) } // A point:: fuggvenyek definicioja: . void point::move(int dx, int dy) { // dx, dy offsetekkel athelyezi if (color) hide( ) // Ez itt a point::hide x += dx y += dy if (color) show( ) // Ez itt a point::show } class circle : public point { protected: int radius // A sugara public: // Konstruktorhoz kezdeti x,y,r circle(int ix,int iy,int ir) colortype get color(void) void show(void) void hide(void) void move(int dx, int dy) void zoom(int factor) } // A circle:: fuggvenyek definicioja: . void circle::move(int dx, int dy) { // dx, dy offsetekkel athelyezi if (color) hide( ) // Ez itt a circle::hide x += dx y +=

dy 117
C++-BAN 2. FEJEZET PROGRAMOZAS 118 if (color) show( ) // Ez itt a circle::show } . Figyeljuk meg, hogy a ket move fuggveny mennyire egyforma! A visszateresi tpusuk void es a parameter-szignaturajuk is azonos, s}ot, meg a fuggvenytorzsek is azonosnak t}unnek. Hat akkor mi alapjan tudja a fordto, hogy mikor melyik fuggvenyr}ol van szo? Ez esetben { ahogy azt a normal fuggvenymez}ok eseteben lattuk { a move fuggvenyeink abban kulonboznek, hogy mas-mas osztalyhoz tartoznak (point::move, illetve circle::move). Folvet}odik a kerdes: Ha a ket move fuggveny torzse is egyforma, akkor miert kell bel}oluk 2 peldany, miert ne orokolhetne circle ezt a fuggvenyt point-tol? Nos azert, mert csak feluletes ranezesre egyforma a ket fuggvenytorzs, ugyanis mas-mas hide, illetve show f uggvenyeket hvnak { ezeknek csak a neve es a szignaturaja azonos. Ha circle a point-t ol orokolne a move fuggvenyt, akkor az

nem a megfelel}o hide, illetve show f uggvenyeket hvna: nevezetesen a korre vonatkozo fuggvenyek helyett a pontra vonatkozokat aktivizalna. Ez azert van gy, mert a korai kotes kovetkezteben a point::hide, illetve a point::show lenne a point tpus move f uggvenyehez hozzarendelve, es az orokles altal a circle tpus move fuggvenye is ezeket fuggvenyeket hvna. Ezt a problemat ugy oldhatjuk meg, ha a show, illetve a hide f uggvenyeket virtualis fugvenyekkent deklaraljuk. Ekkor nyugodtan rhatunk egy kozos move fuggvenyt a point es a circle szamara (pontosabban fogalmazva a circle tpus orokolhetne a point tpus move fuggvenyet), es majd futasi id}oben fog kiderulni, hogy melyik show, illetve hide fuggvenyt kell meghvni. 2.92 Virtualis fuggvenyek deklaralasa A virtualis fuggvenyek deklaralasanak szintaktikaja nagyon egyszer}u: a fuggvenymez}o els}o deklaralasakor helyezzuk el a virtual tpusmodosto

szot is: virtual void show(void) virtual void hide(void) Figyelem! Csak fuggvenymez}ok deklaralhatok virtualis fuggvenyekkent. Ha egy fuggvenyt egyszer mar virtualisnak deklaraltunk, akkor egyetlen szarmaztatott osztalyban sem deklaralhatjuk ujra az adott fuggvenyt ugyanolyan parameterszignaturaval, de mas visszateresi tpussal. Ha egy egyszer mar virtualisnak deklaralt fuggvenyt egy szarmaztatott tpusban ujra deklaraljuk es az ujboli deklaracio alkalmaval ugyanolyan viszszateresi tpust es parameter-szignaturat alkalmazunk, mint a korabbi deklaracioban, akkor az ujonnan deklaralt fuggveny automatikusan virtualis fuggveny lesz. Termeszetesen egy virtualis fuggvenyt mas parameter-szignaturaval ujradeklaralhatunk, de akkor erre a valtozatra a virtualis fuggvenykezel}o rendszer nem fog m}ukodni. Az azonos szimbolumhoz rendelt kulonboz}o jelentesek (function overloading (fuggvenynev atdenialo) { lasd a

tobbret}usegnel) hasznalata sok veszelyt rejthet, ugyhogy ezt csak gyakorlott C++ programozoknak ajanljuk. 2.10 DINAMIKUS OBJEKTUMOK 119 2.10 Dinamikus objektumok Eddigi peldainkban csak statikus objektumokkal volt dolgunk (amelyek szamara a fordtoprogram foglal le tarteruletet a fordtas soran), jollehet a hagyomanyos C-ben mar megszokhattuk, hogy valtozoink egy resze szamara mi magunk foglalunk le tarteruletet, es a valtozokat megszuntetve felszabadtjuk a memoriat, ha az adott valtozokra tobbe mar nincs szuksegunk. Termeszetesen a C++-ban sem kell lemondanunk a dinamikus tarkezelesr}ol az objektumok kapcsan, akar hasznalhatjuk is a hagyomanyos C-ben megismert tarkezel}o fuggvenyeket, peldaul a malloc-ot is. Ezt megsem javasoljuk objektumok eseteben, mert a C++ a hagyomanyos tarkezel}o fuggvenyeknel joval hatekonyabb modszereket knal. Peldaul biztostja, hogy a dinamikusan kezelt objektumok eseteben is

aktivizalodjanak a megfelel}o konstruktorok es destruktorok. 2.101 Dinamikus objektumok letrehozasa Dinamikus objektumok letrehozasara a C++ new operatora szolgal. Tekintsuk erre a kovetkez}o peldat: circle *egy kor = new circle(100,200,50) Ennek hatasara az egy kor azonostoju circle tpusra mutato pointer megkapja egy sizeof(circle) darab byte meret}u, circle tpusu objektum szamara lefoglalt tarterulet cmet. A tarterulet-foglalas soran vegrehajtasra kerul a circle( ) konstruktor-hv as is. A letrehozott uj "kor" kozeppontjanak koordinatai rendre 100 es 200, mg a sugar erteke 50 lesz A new operatorral tombok szamara is foglalhatunk helyet. A new-nak ez az alternatv szintaxisa a kovetkez}o: new tpus "meret] A kifejezes erteke az adott tpus szamara lefoglalt adott meret}u tombre mutato pointer lesz. A new-val torten}o memoria-foglalaskor fellep}o hibakat a new handler pointer

(el}oredenialt globalis valtozo) altal mutatott fuggveny kezeli le. Alapertelmezesben sikertelen tarterulet-foglalasi kiserlet eseten new visszateresi erteke NULL,  es programunk futasa ugy folytatodhat, mintha mi sem tortent volna, ugyanis a new handler-en keresztul aktivizalt hibakezel}o nem csinal semmit. Ugyanakkor lehet}osegunk van arra, hogy a new handler-t egy sajat hibakezel}ore alltsuk a set new handler( ) fuggvenyhvas segtsegevel. Ezt a kovetkez}o pelda szemlelteti: #include <iostream.h> #include <stdlib.h> // * void out of store(void) // Sajat hibakezelo-fv. new-hoz // * { cerr << "operator new failed: out of store " exit(1) // cerr-t lasd 3.113 alatt
C++-BAN 2. FEJEZET PROGRAMOZAS 120 } // * typedef void (*PF)() // Fuggvenyre mutato tipus extern PF set new handler(PF) // new handler-t allitja struct pp { double x,y,z,w // Nagy struktura. Ennek prolong a,b,c,d } // balunk sok helyet foglalni

// * main() // new handler atallitasat szemlelteto program // * { set new handler(&out of store) pp *p = new pp"65535] cout << "Meghivtuk new-t, p = " << long(p) << } // cout-ot is lasd 3.113 allatt // * A fenti program soha sem fog "normalisan" lefutni, hanem mindig az operator new failed: out of store uzenetet kapjuk a keperny}on es visszaterunk 1-es hibakoddal az operacios rendszerhez. 2.102 Dinamikus objektumok megszuntetese Ha new-val dinamikusan hozunk letre objektumokat, akkor a mi felel}ossegunk, hogy meg is szuntessuk azokat, amikor mar nincs rajuk szuksegunk. Erre szolgal a delete operator. Egy nem NULL ertek}u, tetsz}oleges objektumra mutato pointerre alkalmazva a delete operatort, aktivizalodik az adott tpusu objektumhoz tartozo destruktor es a pointer altal megcmzett tarterulet felszabadul. A NULLra alkalmazott delete operatornak nincs semmi hatasa Fontos, hogy a delete csak a

new-val letrehozott dinamikus objektumok megszuntetesere hasznalhato. A delete oparatornak is van a new-hoz hasonlo alternatv szintaxisa: delete objektum "meret] Megjegyzend}o, hogy a C++ nem denial memoria-karbantarto (garbage collector) rendszert, gy az "elvesztett" dinamikus objektumokat nem tudjuk megszuntetni. 2.11 Tovabbi exibilitas a C++-ban Az eddigiekben a C++ leglenyegesebb vonasait mutattuk be. Ebben a fejezetben tovabbi, a nyelvet igen rugalmassa tev}o tulajdonsagokat ismertetjuk 2.111 Rokonok es baratok Az orokles kovetkezteben kulonboz}o }ostpusokbol kiindulva teljes szarmazasi fakat, maskepp kifejezve osztalyhierarchiakat hozhatunk letre. A tobbszoros orokles azt is lehet}ove teszi, hogy egy ujabb tpust tobb }ostpus leszarmazottjakent hozzunk letre. Ily modon egymassal ronkonsagban allo tpusok deklaralhatok Elkepzelhet}o azonban, hogy egy programon belul egymastol teljesen

fuggetlen

A C++-BAN 2.11 TOVABBI FLEXIBILITAS 121 csaladfak jonnek letre. Az egy tpuscsaladba (szarmazasi faba, csaladfaba, osztalyhierarchiaba) tartozo tpusok egymas rokonai, mg a kulonboz}o csaladba tartozok egymas szamara teljesen idegenek. Az eletben az ember termeszetesen nem csak a rokonaival ohajtja tartani a kapcsolatot, hanem szuksege van baratokra is, azaz olyan egyedekre, akikkel nincs semmifele szarmazasi kapcsolatban, de megis fontosak egymas szamara. Nos, egy C++ programban deklaralt tpusok eseteben is hasonlo a helyzet. Ha komolyan vettuk az informaciorejtest, szigoruan kezbentartottuk a mez}ohozzaferest az egyes tpuscsaladok deklaraciojakor, akkor egy adott tpus egy fuggvenymez}oje nem ferhet hozza egy nem rokon tpus adatmez}oihez. Marpedig nem zarhato ki az az eset, amikor egy ilyen hozzaferes haszonnal jarhat. Hogy egy C++ programban ezt a hasznot elvezhessuk, a friend kulcsszoval

megadhatjuk, hogy a programunk nem rokon tarolasi egysegei kozul melyek allnak egymassal baratsagban. Kicsit egzaktabban: Szuksegunk lehet arra, hogy egy adott osztaly privat adatmez}oit egy olyan fuggvennyel is manipulalhassuk, amelyik nem eleme az adott osztalynak. Ezt ugy erhetjuk el, hogy az osztaly deklaraciojakor a friend kulcsszot kovet}oen felsoroljuk azokat a kuls}o fuggvenyeket, amelyek szamara jogot szeretnenk biztostani az adott osztaly adatmez}oinek eleresere. A friend deklaracio az osztaly-deklaracionak akar a private, akar a public reszeben is lehet. Lassunk nehany peldat a "fuggveny-baratsagra": int ext func(void) { . } . class xx { protected: int data 1 private: int data 2 friend int ext func(void) public: xx(int d1, int d2) int get data 1(void) } Az el}obbi peldaban ext func egy normal C fuggveny. Az xx osztaly deklaraciojakor jogot biztostottunk szamara a data 1 es data 2 adatmez}ok

eleresere Termeszetesen egy masik osztaly fuggvenymez}oi is lehetnek baratok: class yy { . void yy func1(void) . } class zz { . void zz func(void) friend void yy::yy func1(void) . }
C++-BAN 2. FEJEZET PROGRAMOZAS 122 Itt tehat az yy osztaly yy func1 nev}u fuggvenymez}ojet deklaraltuk a zz osztaly baratjanak. Arra is lehet}osegunk van, hogy az yy osztalybol ne csak egy, hanem mindegyik fuggvenymez}ot zz baratjava tegyuk: class zz { . void zz func(void) friend class yy . } 2.112 Operator overloading A C++-nak van egy specialis tulajdonsaga, amellyel keves mas nyelv rendelkezik. Nevezetesen az, hogy a nyelv altal denialt, letez}o operatorokhoz ujabb jelentest rendelhetunk. Ez hasznos lehet abbol a celbol, hogy valamilyen osztalykent denialt uj adatstrukturan is elvegeztethessuk azt a m}uveletet, amit az illet}o operatortol megszoktunk az elemi tpusok eseteben. Ha peldaul denialunk egy halmazok reprezentaciojara

szolgalo tpust, akkor nagyon kellemes, ha a + operatorral halmazok uniojat, a * operatorral pedig halmazok metszetet kepezhetjuk. Vagy ha a es b egy-egy matrix tpusu valtozo, akkor jo lenne, ha az a * b kifejezes szinten matrix tpusu eredmenyt, nevezetesen a ket matrix szorzatat szolgaltatna. A polimorzmus targyalasakor mar utaltunk arra, hogy egy adott m}uvelet vegrehajtasat jelent}o szimbolumhoz tobbfele jelentest rendelhetunk olyan ertelemben, hogy azt a bizonyos m}uveletet tobb, kulonboz}o tpusu adaton is vegre szeretnenk hajtani { ezt neveztuk overloading-nak. Gondoljunk bele, hogy az overloading nem egeszen C++ tulajdonsag, hiszen a hagyomanyos C-beli operatorok is kepesek kulonboz}o adattpusokon is ugyanazt a m}uveletet vegrehajtani. Erre egy igen kezenfekv}o pelda az ertekadas operatora (amelyik mind kulonboz}o sorszamozott tpusu adatokon, mind pedig lebeg}opontos szamokon ertelmezett m}uvelet),

vagy gondoljunk az egyes aritmetikai operatorokra, amelyek a hagyomanyos C kulonboz}o elemi tpusain nagyjabol egyforman m}ukodnek. Az operator-overloading lehet}oseget a C++ kiterjeszti ugy, hogy az egyes operatorokhoz a felhasznalo is megadhat ujabb ertelmezest egy un. operator fuggveny segtsegevel. Ez ugy lehetseges, hogy az operator kulcsszot kovet}oen rjuk azt az operator-szimbolumot, amelyikhez az ujabb jelentest szeretnenk rendelni. Igy peldaul az operator+ annak a fuggvenynek lesz az azonostoja, amelyikkel a + operatorhoz rendelunk egy ujabb jelentest. Nezzunk erre egy peldat! 2.12 C++ I/O konyvtarak Az stdio.h include le-ban deklaralt szabvanyos folyam jelleg}u formatumozott I/O fuggvenyek (mint peldaul printf, scanf, stb.) mellett a C++ ujabb hasonlo, folyam-orientalt fuggvenyeket tartalmaz az iostreams konyvtarban Az uj C++ I/O fuggvenyek deklaraciojat az iostream.h include le-ban talalhatjuk Az

uj I/O konyvtar hasznalata el}onyoket nyujt az stdio.h-hoz kepest Ezek egyike, hogy a fuggvenyek szintaxisa sokkal egyszer}ubb, elegansabb, olvashatobb. Egy masik tenyez}o, hogy a C++ folyamkezel}o mechanizmusa a leggyak-
2.12 C++ I/O KONYVTARAK 123 rabban el}ofordulo esetekben hatekonyabb es rugalmasabb, mint a hagyomanyos C folyamkezeles. A formatumozott kimenet el}oalltasa az operator-overloadingnak koszonhet}oen peldaul sokszor egyszer}ubb, mint a printf-fel Ugyanazon operator hasznalhato mind el}oredenialt, mind pedig a felhasznalo altal denialt adattpusok kiiratasara. A C++-ban negyel}ore denialt folyam jelleg}u objektum van. Ezek a kovetkez}ok:
cin a szabvanyos bemenet, amely  altalaban a billenty}uzet. A hagyomanyos C-beli stdin-nek felel meg
cout a szabvanyos kimenet, amely  altalaban a keperny}o. A hagyomanyos C-beli stdout-nak felel meg.
cerr a szabvanyos hibakimenet, amely  altalaban a keperny}o. A

hagyomanyos C-beli stderr-nek felel meg
clog a cerr teljesen buerelt valtozata, nincs megfelel} oje a C-ben. Ezek a folyamok tetsz}oleges eszkozre vagy le-ba atiranythatok, mg C-ben csak az stdin es az stdout iranythato at. Az iostream konyvtar elemei hierarchikusan epulnek egymasra A konyvtar elemei az alap-primitvt}ol a legspecializaltabb elemig a kovetkez}ok:
streambuf a memoriabuereket es az azokat kezel} o eljarasokat tartalmazza,
ios a folyamok allapotvaltozoit es a hib akat kezeli,
istream egy streambuf-b ol szarmazo formatumozott es kotetlen formatumu karakterfolyam konverziojat vegzi,
ostream egy streambuf-ba k uldend}o formatumozott vagy kotetlen formatumu karakterfolyam konverziojat vegzi,
iostream istream-et es ostream-et kombin alja annak erdekeben, hogy ketiranyu folyamokat lehessen kezelni,
istream withassign a cin folyam sz amara denial konstruktorokat es ertekado operatorokat,


ostream withassign a cout, cerr es a clog folyamok sz amara denial konstruktorokat es ertekado operatorokat. Az istream osztaly az overloading segtsegevel egy uj jelentest ad a >> operator szamara a standard elemi tpusok esetere. Ha az x valtozo tpusa standard elemi tpus, akkor a cin>>x kifejezes mellekhatasakent az x tpusanak (char, int, long, float, double) megfelel} o konverzios input rutin az x valtozonak megfelel}o memoriacmre teszi a standard bemenetr}ol erkez}o adatot. A kifejezes ertekekent cin-t kapjuk vissza. Az el}obbiekhez hasonlo modon, az ostream osztalyban talalhato a << operator uj ertelmezese. A cout<<x utastas hatasara az x valtozo tpusanak megfelel}o output rutin a szabvanyos kimeneti allomanyra kuldi az x ertekenek megfelel}o karaktersorozatot es visszaadja cout-ot. (Itt x tpusa szinten valamelyik standard elemi tpus lehet) 124
C++-BAN 2. FEJEZET PROGRAMOZAS

A << es >> operator-fuggvenyek a megfelel}o folyam osztalyara vonatkozo referencia tpusu visszateresi erteket adnak, gy tobb ilyen operator lancba f}uzhet}o: int i = 0, x = 243 double d = 0 cout << "The value of x is " << x << cin >> i >> d // Egy int-et, utana SPACE-t, // majd egy double-t var. A. Fuggelek Include le-ok
es fuggv
enyek A.1 Fontosabb konyvtari fuggvenyek El}oszor az IBM-PC, illetve BORLAND C++ specikus fuggvenyeket ismertetjuk, majd az ANSI C, illetve UNIX kompatibilis, illetve az MS-Windows alatt is hasznalhato fontosabb fuggvenyeket es makrokat tekintjuk at. A.11 Fuggvenyek szoveges uzemmodban clreol conio.h Torli az osszes karaktert a sor vegeig a keperny}o ablakban, anelkul, hogy a kurzort elmozgatna. #include <conio.h> void clreol(void) Megjegyz
es: Torles utan a sor a kurzor helyet}ol az aktualis keperny}o ablak szeleig hatterszn}u

lesz. clrscr conio.h Torli a keperny}o ablakot. #include <conio.h> void clrscr(void) Megjegyz
es: Ha a hatter nem volt fekete, akkor a torles utan a hatter felveszi az el}oz}oekben denialt hatter sznet. A kurzor athelyez}odik a keperny}o bal fels}o sarkaba (1,1). delline conio.h 125 A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 126 Torli a kurzort tartalmazo sort. #include <conio.h> void delline(void) Megjegyz
es: A delline torli a kurzort tartalmazo sort es az alatta lev}o sorok egy sorral feljebb lepnek a keperny}on. A delline az aktualis keperny}o ablakon belul is m}ukodik. gettext conio.h Szoveget masol a keperny}or}ol memoriateruletre. #include <conio.h> int gettext(int left, int int right, int void *destin) top, bottom, Param
eterek: left, top right,bottom destin a teglalap bal fels}o sarka a teglalap jobb also sarka memoria teruletre mutato pointer Megjegyz
es: A gettext a teglalap alaku keperny}o

tartalmat masolja a megadott memoriateruletre. Minden koordinatat abszolut koordinataertekkel kell megadni. Minden pozcionak 2 byte felel meg A h sor es v oszlop tarolasara bytes = (hsor)(woszlop)2 drab byte szukseges. Sikeres vegrehajtas eseten a visszateresi ertek 1, kulonben 0. gettextinfo conio.h A text uzemmodrol nyujt informaciot. #include <conio.h> void gettextinfo(struct text info *r) Param
eter: Az *r struktura { ez adja meg a text video informaciokat. Megjegyz
es: A text info struktura a conio.h-ban van denialva: struct text info { unsigned char winleft unsigned char wintop unsigned char winright unsigned char winbottom unsigned char attribute unsigned char normattr unsigned char currmode /*az ablak bal koordinataja / /*az ablak felso koordinataja/ /*az ablak jobb koordinataja / /*az ablak also koordinataja / /*szoveg attributum */ /*normal attributum */ /*BW40, BW80, C40 vagy C80 */
FUGGVE
NYEK A.1 FONTOSABB

KONYVTARI unsigned unsigned unsigned unsigned char char char char screenheight screenwidth curx cury 127 /*also - felso koordinata */ /*bal - jobb koordinata */ /*aktualis ablak x koordinata/ /*aktualis ablak y koordinata/ } gotoxy conio.h Pozcionalja a kurzort. #include <conio.h> void gotoxy(int x, int y) Param
eterek: x, y { a kurzor uj pozcioja. Megjegyz
es: Az aktv ablak adott pozciojaba mozgatja a kurzort, az x- edik oszlopba es az y-adik sorba. Az ablak bal fels}o sarokpontja (1,1) E rvenytelen koordinatak eseten a gotoxy hvas nem kerul vegrehajtasra. Peldaul a kurzort a 10. oszlopba es a 20 sorba pozcionalja a gotoxy(10,20) fuggvenyhvas highvideo conio.h Intenzv karakterszn kivalasztasat vegzi. #include <conio.h> void highvideo(void) Megjegyz
es: A highvideo a nagy intenzitast az aktualisan kivalasztott hatterszn legmagasabb helyiertek}u bitjenek bealltasaval valostja meg. insline conio.h

Beszur egy ures sort a kurzor pozcional. #include <conio.h> void insline(void) Megjegyz
es: A sorbeszuras kovetkezteben az utolso sor kilep a keperny}ob}ol. lowvideo conio.h Normal karakterszn kivalasztasat vegzi. #include <conio.h> void lowvideo(void) Megjegyz
es: A lowvideo torli az aktualisan kivalasztott hatterszn legmagasabb helyiertek}u bitjet, amely a magasabb intenzitast jelolte. movetext Szoveget masol at egyik teglalapbol a masikba. conio.h A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 128 #include <conio.h> int movetext(int left, int top, int right, int bottom, int destleft, int desttop) Param
eterek: left, top right,bottom destleft,desttop a forras teglalap bal fels}o sarka jobb also sarka a celterulet bal fels}o sarka Megjegyz
es: Az egyik teglalapbol a masik teglalapba masolja a keperny}o tartalmat. Peldaul legyen az egyik teglalap bal fels}o sarkanak koordinataja (5,15), a jobb

also sarkanak koordinataja (20,25), masoljuk at egy uj teruletre, melynek a bal fels}o koordinatai (30,5)! Ezt a movetext(5,15,20,25,30,5) fuggvenyhvassal tehetjuk meg. normvideo conio.h Normal intenzitasu karakterszn kivalasztasat vegzi. #include <conio.h> void normvideo(void) Megjegyz
es: Visszatolti azt a szoveg attributumot, amelyet az indtasnal hasznalt a program. puttext conio.h Memoriabol keperny}ore masol. #include <conio.h> int puttext(int left, int top, int right, int bottom, void *source) Param
eterek: left, top right,bottom source a teglalap bal fels}o sarka a teglalap jobb also sarka memoria teruletre mutato pointer Megjegyz
es: Az osszes koordinatat abszolut koordinataval kell megadni, es nem az ablakhoz kepest relatvval. Ha sikeres volt a m}uvelet, akkor pozitv a viszszateresi ertek, kulonben 0 setcursortype Kurzor vezerlese. #include <conio.h> void far setcursortype(int cur t)

conio.h
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 129 Param
eter: cur t a kurzortpus kivalasztasa Megjegyz
es: Alabbi kurzortpusok leteznek: Kurzortpus Leras NOCURSOR kikapcsolja a kurzort SOLIDCURSOR tomor, teglalap alaku kurzor NORMALCURSOR norm al (alahuzas) tpusu kurzor Csak BORLAND C++-ban letezik. textattr conio.h Bealltja az el}oter es az ras sznet. #include <conio.h> void textattr(int newattr) Megjegyz
es: Egyetlen hvassal be lehet alltani a hatter es az ras sznet. A 8 bites newattr parameter a kovetkez}o: 7 B 6 b ffff bbb B 5 b 4 b 3 f 2 f 1 f 0 f 4 bit a ras szne (0-15) 3 bit a hatter szne (0-7) villodzo allapot ag-je textbackground conio.h Kivalasztja a hatter sznet. | #include <conio.h> void textbackground(int newcolor) Param
eter: newcolor { a hatter szne Megjegyz
es: A newcolor megadhato (0-7) szamertekkel vagy szimbolikus konstanssal. A newcolor erteke az

alabbi lehet: szimbolikus ertek konstans BLACK 0 BLUE 1 GREEN 2 CYAN 3 RED 4 MAGENTA 5 BROWN 6 LIGHTGRAY 7 szn fekete kek zold turkiz piros lila barna vilagosszurke A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 130 textcolor conio.h Kivalasztja a karakter sznet. #include <conio.h> void textcolor(int newcolor) Param
eter: newcolor { a karakter szne (0-15) Megjegyz
es: A sznkonstansok megnevezeset lasd a setallpalette fuggveny ismertetesenel. A szoveget lehet villogtatni a BLINK szimbolikus konstans segtsegevel P
elda: Sargan villogjon a kek hatteren a Hello szoveg: textattr(YELLOW+(BLUE<<4)+BLINK) cputs("Hello") textmode conio.h A szoveges (text) uzemmodot valasztja ki. #include <conio.h> void textmode(int newmode) Param
eter: newmode { a text uzemmod tpusa Megjegyz
es: A lehetseges text uzemmodok azonostoi a kovetkez}ok: szimbolikus ertek konstans LASTMODE -1 BW40 0 C40 1 BW80 2 C80 3 MONO

7 leras el}oz}o text mod fekete/feher, 40 oszlop sznes, 40 oszlop fekete/feher, 80 oszlop sznes, 80 oszlop egyszn}u, 80 oszlop wherex conio.h A kurzor x koordinataertekevel ter vissza, amely az aktualis ablakhoz kepest relatv tavolsagot jelent. #include <conio.h> int wherex(void) Megjegyz
es: Visszateresi ertek 1-80 kozotti egesz szam. wherey conio.h
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 131 A kurzor y koordinataertekevel ter vissza, amely az aktualis ablakhoz kepest relatv tavolsagot jelent. #include <conio.h> int wherey(void) Megjegyz
es: Visszateresi ertek 1-t}ol 25, 43 vagy 50 kozotti egesz szam. window conio.h Szoveg-ablakot denial a keperny}on. #include <conio.h> void window(int left, int top, int right, int bottom) Param
eterek: left, top right, bottom az ablak bal fels}o sarka az ablak jobb also sarka Megjegyz
es: A szoveg-ablak minimalis merete 1 oszlop es 1 sor. Alapertelmezes

szerint a szoveg-ablak a teljes keperny}o a kovetkez}o koordinatakkal: 80 oszlopos modban 1,1,80,25! mg 40 oszlopos modban: 1,1,40,25. A.12 Hangeektusok letrehozasa sound dos.h Megszolaltatja a bels}o hangszorot az adott frekvencian. #include <dos.h> void sound(unsigned frequency) Param
eter: frequency { a hang frekvenciaja Hz-ben Megjegyz
es: A hangszoro addig szol, amg a nosound fuggveny nem kerul hvasra. delay dos.h Felfuggeszti a program vegrehajtasat egy adott id}otartamra. #include <dos.h> void delay(unsigned msec) Param
eter: msec { a kesleltetes ideje ms] egysegben nosound Kikapcsolja a bels}o hangszorot. #include <dos.h> void nosound(void) dos.h A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 132 P
elda: A kovetkez}o program 440 Hz-es hangot (normal zenei A) ad 500 ms-ig. #include <dos.h> main() { sound(440) delay(500) nosound() } A.13 Fuggvenyek gra kus uzemmodban arc graphics.h x,y

kozeppontu korvet rajzol kezd}o es vegszog kozott. #include <graphics.h> void far arc(int x, int y, int stangle, int endangle, int radius) Param
eterek: x, y stangle endangle radius a korv kozeppontja a kezd}oszog (fokban) a vegszog (fokban) a sugar Megjegyz
es: Ha a kezd}oszognek 0 es a vegszognek 360 fokot adunk, akkor az eljaras teljes kort rajzol. A szogeket az oramutato jarasaval ellentetes iranyban kell megadni, 0 fok 3 oranak, 90 fok 12 oranak felel meg. bar graphics.h Teglalapot rajzol es befesti az aktualis sznnel es mintaval. #include <graphics.h> void far bar(int left, int top, int right, int bottom) Param
eterek: left, top right, bottom a teglalap bal fels}o sarka a teglalap jobb also sarka Megjegyz
es: A setcolor, setfillstyle es a setlinestyle fuggvenyek altal korabban bealltott sznnel es mintaval rajzolja, illetve tolti ki a teglalapot. bar3d graphics.h Teglatestet rajzol es befesti az

aktualis sznnel es mintaval. #include <graphics.h> void far bar3d(int left, int top, int right, int bottom, int depth, int topflag)
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 133 Param
eterek: left, top right, bottom depth topflag a teglalap bal fels}o sarka a teglalap jobb also sarka a teglatest melysege ha nem nulla, a teglatest teteje zart, nulla eseten a teglatest tetejere ujabb teglatest illeszthet}o. Megjegyz
es: A korabban denialt sznnel es mintaval rajzol es fest teglatestet. circle graphics.h x,y kozeppontu kort rajzol. #include <graphics.h> void far circle(int x, int y, int radius) Param
eterek: x, y radius a kor kozeppontjanak koordinatai a kor sugara Megjegyz
es: A kor rajzolasa az aktualis sznnel tortenik. A linestyle parameter nem hatasos az v, kor, ellipszis es ellipszis v rajzolasanal, csak a thickness parameter hasznalhato. cleardevice graphics.h Torli a grakus keperny}ot. #include

<graphics.h> void far cleardevice(void) Megjegyz
es: Torli a keperny}ot besznezve a hattersznnel es a kurzort a (0,0) pozcioba mozgatja. clearviewport graphics.h Torli az aktualis grakus ablakot. #include <graphics.h> void far clearviewport(void) Megjegyz
es: Torli a aktualis grakus ablakot es a kurzort a keperny}o ablak (0,0) pozciojaba mozgatja. closegraph Lezarja a grakus uzemmodot. #include <graphics.h> void far closegraph(void) graphics.h A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 134 Megjegyz
es: A closegraph a grakus uzemmod inicializalasa el}otti keperny}o uzemmodot alltja vissza. detectgraph graphics.h Ellen}orzi a hardvert es meghatarozza, hogy milyen grakus meghajtot es modot lehet hasznalni. #include <graphics.h> void far detectgraph(int far *graphdriver, int far *graphmode) Megjegyz
es: Megvizsgalja a grakus kartyat es kivalasztja azt az uzemmodot, amelyik a legjobb

felbontast nyujtja. Ha az adott hardverkonguracioban a graka hasznalata nem lehetseges, ezt a *graphdriver parameter, illetve a grahpresult f uggveny -2-es visszateresi erteke jelzi. A lehetseges grakus uzemmod kontsansok az alabbiak: konstansok numerikus ertek DETECT 0 CGA 1 MCGA 2 EGA 3 EGA64 4 EGAMONO 5 IBM8514 6 HERCMONO 7 ATT400 8 VGA 9 PC3270 10 A DETECT ertek hatasara a grakus rendszer erzekeli a grakus kartya tpusat. Minden mas ertek eseten az adott grakus kartya legjobb felbontasu uzemmodja kerul kivalasztasra. drawpoly graphics.h A megadott vonaltpussal es sznnel pontsorozatot egyenessel kot ossze. #include <graphics.h> void far drawpoly(int numpoints, int far *polypoints) Param
eterek: a koordinatak szama mutat az x,y pontparokat tartalmazo tombre Megjegyz
es: Egy n pontbol allo zart poligon eseten n + 1 koordinatapart kell megadni, ahol az n +1-edik koordinataparnak meg kell egyeznie a 0-adikkal.

Ha hiba tortenik a poligon rajzolasa alatt a graphresult -6 ertekkel ter vissza. numpoints polypoints
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI ellipse 135 graphics.h x,y kozeppontu ellipszis vet rajzol kezd}o es vegszog kozott. #include <graphics.h> void far ellipse(int x, int y, int stangle, int endangle, int xradius, int yradius) Param
eterek: x,y stangle endangle xradius yradius kozeppont kezd}o koordinatai kezdeti szog vegszog vizszintes tengely fugg}oleges tengely Megjegyz
es: A szogek az oramutato jarasaval ellentetes iranyuak. A 0 fok 3 oranak, a 90 fok 12 oranak felel meg. Ha 0 kezd}o- es 360 fok vegszoget adunk, teljes ellipszist kapunk. fillellipse graphics.h Rajzol es befest egy ellipszist. #include <graphics.h> void far fillellipse(int x, int y, int xradius, int yradius) Param
eterek: x, y xradius yradius az ellipszis kozeppontja a vizszintes tengely a fugg}oleges tengely Megjegyz
es: Rajzol egy x, y

kozeppontu, xradius vizszintes es yradius fugg}oleges tengely}u ellipszist es befesti az aktualis sznnel es mintaval. fillpoly graphics.h Rajzol es befest egy poligont. #include <graphics.h> void far fillpoly(int numpoints, int far *polypoints) Param
eterek: a poligon pontparainak szama mutat az x,y pontparokat tartalmazo tombre Megjegyz
es: Aktualis sznnel es vonaltpussal megrajzolja a poligon korvonalat es befesti az aktualis mintaval es sznnel. numpoints polypoints A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 136 floodfill graphics.h Aktualis mintaval befesti az adott szn}u vonallal zart teruletet. #include <graphics.h> var far floodfill(int x, int y, int border) Param
eterek: x, y border a zart terulet egy bels}o pontjanak koordinatai szn getarccoords graphics.h Megadja az utoljara rajzolt v kezd}o- es vegkoordinatainak erteket. #include <graphics.h> void far getarccoords(struct arccoordstype

far *arccoords) Megjegyz
es: Visszater az arccoordtype struktura tpusu *arccoords valtozoban elhelyezett ertekekkel, ahol struct arccoordstype { int x, y int xstart, ystart, xend, yend } Itt x, y xstart, ystart xend, yend a kozeppont koordinatai az v kezd}opontjanak koordinatai az v vegpontjanak koordinatai Ezeknek az adatoknak az ismereteben lehet peldaul egy ellipszis v vegpontjabol egy vonalat rajzolni. getaspectratio graphics.h Visszaadja az aktualis grakus mod vizszintes/fugg}oleges keparanyat. #include <graphics.h> void far getaspectratio(int far *xasp, int far *yasp) Param
eterek: *xasp, yasp: keparany osszetev}ok (faktorok) Megjegyz
es: Az y aranyfaktor (*yasp) minden grakus kartya eseten 10000hez van normalva, kiveve a VGA-t. Az *xasp (x aranyfaktor) kisebb, mint az *yasp, mivel egy k eppont (pixel) magassaga es szelessege nem egyforma. VGA eseten negyzet alaku egy pixel, emiatt *xasp egyenl}o yasp-vel.


FUGGVE
NYEK A.1 FONTOSABB KONYVTARI getbkcolor 137 graphics.h A hatter aktualis sznet adja vissza. #include <graphics.h> int far getbkcolor(void) Megjegyz
es: Visszateresi erteke a hatterszn, amely 0 - 15-ig valtozhat, ez fugg a grakus kartyatol es az aktualis grakus modtol. getcolor graphics.h A rajzolo sznt adja vissza. #include <graphics.h> int far getcolor(void) Megjegyz
es: Az utolso sikeres setcolor hvas sznenek erteket adja vissza. A rajzolas szne 0-15-ig valtozhat, ez fugg a grakus kartyatol es az aktualis grakus modtol. getdefaultpalette graphics.h A paletta (sznskala) ertekeit adja vissza. #include <graphics.h> struct palettetype *far getdefaultpalette(void) Megjegyz
es: A palettetype tpusu strukturara mutato pointert kapunk viszsza. A pointer altal megcmzett strukturaban kapjuk meg az initgraph-ban denialt sznskala ertekeket. getdrivername graphics.h Visszater egy

sztringre mutato pointerrel, melyben a grakus kartya nevet adja vissza. #include <graphics.h> char *far getdrivername(void) Megjegyz
es: Az initgraph aktivalasa utan az aktv grakus kartya nevevel ter vissza. getfillpattern graphics.h A felhasznalo altal el}oz}oleg denialt alakzat kitolt}o minta azonosto kodjat viszsza. #inlcude <graphics.h> void far getfillpattern(char far *pattern) 138 A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK Param
eter: pattern { egy pointer, amely egy 8 byte-os szekvenciara mutat. Megjegyz
es: A setfillpattern altal denialt mintat a getfillpattern betolti egy 8 byte-os teruletre, amit a pattern cmez meg. getfillsettings graphics.h Informaciot ad az aktualis fest}omintarol es sznr}ol. #include <graphics.h> void far getfillsettings(struct fillsettingstype far *fillinfo) Megjegyz
es: A getfillsettings betolti a fillsettingstype strukturara mutato pointert a fillinfo pointer valtozoba,

amely informaciot ad az aktalis kitolt}o mintarol es sznr}ol. A struktura a graphicsh le-ban az alabbi: struct fillsettingstype { int pattern /* az aktualis minta / int color /* az aktualis szin / } Nev (konstans) EMPTY FILL SOLID FILL LINE FILL LTSLASH FILL SLASH FILL BKSLASH FILL LTBSKLASH FILL HATCH FILL XHATCH FILL INTERLEAVE FILL WIDE DOT FILL CLOSE DOT FILL USER FILL Kitolt}o mintak E rtek 0 1 2 3 4 5 6 7 8 9 10 11 12 Leras hattersznnel fest egyenletes, gyenge tonus vzszintes vonalas minta jobbra d}olt vonalas minta jobbra d}olt vastag vonalas minta balra d}olt vastag vonalas minta balra d}olt vonalas minta kockas minta d}olt kockas minta s}ur}un pontozott minta ritkan pontozott kozepesen pontozott felhasznalo altal denialt getgraphmode graphics.h Az aktualis grakus uzemmodot adja meg. #include <graphics.h> int far getgraphmode(void) Megjegyz
es: A getgraphmode megadja az initgraph vagy setgraphmode altal bealltott grakus

uzemmodot. Ennek erteke 0-5 kozott valtozhat, ez fugg az aktualis grakus kartyatol.
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI getimage 139 graphics.h A megadott kepmez}ot elmenti egy buerba. #include <graphics.h> void far getimage(int left, int top, int right, int bottom, void far *bitmap) Param
eterek: left, top right, bottom *bitmap a tartomany bal fels}o sarka a tartomany jobb also sarka a buerre mutato pointer Megjegyz
es: A getimage a kepmez}o megadott teruletet elmenti a bitmap pointer altal mutatott memoria teruletre.A memoria teruletnek az els}o ket adata a tartomany szelesseget es magassagat tartalmazza, ezutan kovetkeznek a kepmez}o adatai. getlinesettings graphics.h A vonal tpusat, mintajat es vastagsagat adja vissza. #include <graphics.h> void far getlinesettings(struct linesettingstype far *lineinfo) Megjegyz
es: A getlinesettings betolti a linesettinsgtype struktura pointeret a lineinfo pointer

valtozoba, amely a vonal tulajdonsagait szolgaltatja: struct linesettingstype { int linestyle unsigned upattern int thickness } A vonal tpusa: Konstans SOLID LINE DOTTED LINE CENTER LINE DASHED LINE USERBIT LINE E rtek 0 1 2 3 4 Leras normal vonal pont vonal kozep vonal szaggatott vonal felhasznalo altal denialt vonal A vonal vastagsaga Konstans NORM WIDTH THICK WIDTH E rtek Leras 1 normal vonal (1 pixel szeles) 3 vastag vonal (3 pixel szeles) A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 140 getmaxcolor graphics.h Megadja a maximalisan hasznalhato sznek szamat. #include <graphics.h> int far getmaxcolor(void) Megjegyz
es: Peldaul 256K-s EGA kartya eseten a visszateresi ertek 15, mert a setcolor maxim alisan 0 { 15 ervenyes sznt tud kivalasztani. A CGA nom graka es a Hercules egyszn}u graka eseten a visszateresi ertek 1, mert ebben az esetben a szn 0 es 1 lehet. getmaxmode graphics.h A legmagasabb

grakus uzemmod-szamot adja meg. #include <graphics.h> int far getmaxmode(void) Megjegyz
es: A legkisebb ertek 0. getmaxx graphics.h A maximalisan hasznalhato x koordinata erteket adja meg. #include <graphics.h> int far getmaxx(void) Megjegyz
es: Peldaul a CGA kartya 320  200 felbontasu grakus uzemmodja eseten a getmaxx 319 ertekkel ter vissza. getmaxy graphics.h A maximalisan hasznalhato y koordinata erteket adja meg. #include <graphics.h> int far getmaxy(void) Megjegyz
es: Peldaul a CGA kartya 320  200 felbontasu grakus uzemmodja eseten a getmaxy 199 ertekkel ter vissza. getmodename graphics.h A grakus eszkoz meghajto nevere mutato pointerrel ter vissza. #include <graphics.h> char *far getmodename(int mode number) Param
eter: mode number grakus mod szama
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI getmoderange 141 graphics.h Megadja a grakus meghajto uzemmodjainak tartomanyat. #include

<graphics.h> void far getmoderange(int graphdriver, int far *lomode, int far *himode) Param
eterek: grakus meghajto az uzemmod tartomany also es fels}o hatarara mutato pointerek Megjegyz
es: *lomode tartalmazza a grakus mod also, himode pedig a fels}o hatarat. E rvenytelen grakus meghajto megadasa eseten mindket visszateresi ertek -1 lesz. graphdriver lmode, hmode getpalette graphics.h Informaciot ad a palettarol. #include <graphics.h> void far getpalette(struct palettetype far *palette) Megjegyz
es: A getpalette feltolti a palettetype tpusu palette strukturat az aktualisan hasznalt paletta jellemz}oivel. A palettetype a graphicsh-ban van deni alva #define MAXCOLORS 15 struct palettetype { unsigned char size signed char colors"MAXCOLORS+1] } A size a sznkeszletben hasznalhato sznek szama, melyet az aktualis grakus mod hataroz meg. getpalettesize graphics.h A szntabla (paletta) meretet adja meg. #include

<graphics.h> int far getpalettesize(void) Megjegyz
es: A visszateresi ertek megadja az aktualis grakus modban hasznalhato sznek szamat. Peldaul sznes uzemmodban hasznalt EGA kartya eseten ez az ertek 16 lesz. getpixel graphics.h 142 A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK Az (x,y) koordinataju keppont sznerteket adja vissza. #include <graphics.h> unsigned far getpixel(int x, int y) Param
eterek: x, y a keppont koordinatai gettextsettings graphics.h Informaciot ad a bealltott raskepr}ol. #include <graphics.h> void far gettextsettings(struct textsettingstype far *texttypeinfo) Megjegyz
es: A gettextsettings betolti a textsettingstype struktura cmet atexttypeinfo pointer valtozoba. Ez a struktura tajekoztatast ad a hasznalt karakterkeszlet tpusarol, iranyarol, mereter}ol es bealltasi helyzeter}ol. struct textsettingstype { int font /* karakterkeszlet tipusa int direction /* irany

int charsize /* meret int horiz /* vizszintes helyzet int vert /* fuggoleges helyzet } getviewsettings */ */ */ */ */ graphics.h Az aktualis ablak (viewport) adatait adja meg. #include <graphics.h> void far getviewsettings(struct viewporttype far *viewport) Megjegyz
es: A getviewsettings kitolti a viewport pointer altal mutatott viewporttype strukt urat. struct viewporttype { int left,top,right,bottom int clip } A (left, top) es (right, bottom) koordinatapontok az aktv ablak meretet szolgaltatjak, melyek abszolut keperny}o koordinatakban ertend}ok. A clip mez}o erteke hatarozza meg az ablakban megjelen}o rajz vagasat Ha clip erteke poztv, akkor van vagas, ebben az esetben a rajzoknak csak az ablakba es}o resze lathato, nulla eseten nincs vagas.
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI getx 143 graphics.h Az aktualis grakus kurzor x koordinatajat adja meg. #include <graphics.h> int far getx(void) Megjegyz
es: A megadott x

koordinata relatv ertek az ablakhoz kepest, ami azt jelenti, hogy ha a keperny}on egy ablakot jeloltunk ki, akkor az ahhoz viszonytott koordinatakat kapjuk vissza. gety graphics.h Az aktualis grakus kurzor y koordinatajat adja meg. #include <graphics.h> int far gety(void) Megjegyz
es: A megadott y koordinata relatv ertek az ablakhoz kepest. graphdefaults graphics.h Alapallapotba alltja vissza a grakus uzemmodot. #include <graphics.h> void far graphdefaults(void) Megjegyz
es: Az alapallapot bealltas a kovetkez}o: - az ablak a teljes keperny}ot jelenti, - a kurzort a (0,0) pozcioba helyezi, - bealltja a paletta sznet, a hattersznt es a rajzsznt a default-ra, valamint a fest}o tpusra, mintara es a szoveginformaciora. grapherrormsg graphics.h Visszater a hibauzenetet tartalmazo sztringre mutato pointerrel. #include <graphics.h> char *far grapherrormsg(int errorcode) Megjegyzes: A hibakodot a

graphresult fuggveny szolgaltatja. graphfreemem A grakus memoria felszabadtasa. #include <graphics.h> void far graphfreemem(void far *ptr, unsigned size) graphics.h A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 144 Param
eterek: a grakus memoria teruletre mutato pointer a felszabadtando memoria merete Megjegyz
es: A grakus konyvtar hvja a graphfreemem fuggvenyt, hogy felszabadtsa graphgetmem altal korabban lefoglalt memoriat. Magunk is vezerelhetjuk a grakus konyvtar memoria kezeleset egyszer}uen, ha denialjuk a graphfreemem f uggveny sajat verziojat. Ennek a rutinnak az alapertelmezes szerinti verzioja csak a free fuggvenyt hvja. Csak BORLAND C++-ban letezik *ptr size graphgetmem graphics.h A grakus memoria lefoglalasa. #include <graphics.h> void far *far graphgetmem(unsigned size) Param
eter: size a felszabadtando memoria merete Megjegyz
es: A grakus konyvtar (nem a felhasznaloi program)

hvja a graphfugggvenyt, hogy memoriateruletet foglaljon le bels}o buerek, grakus meghajtok es karakterkeszletek szamara. Magunk is vezerelhetjuk a grakus konyvtar memoria kezeleset egyszer}uen, ha denialjuk a graphgetmem fuggveny sajat verziojat. Ennek a rutinnak az alapertelmezes szerinti verzioja csak a malloc fuggvenyt hvja. Csak BORLAND C++-ban letezik getmem graphresult graphics.h Az utoljara vegrehajtott grakus m}uvelet hibakodjat adja meg. #include <graphics.h> int far graphresult(void) imagesize graphics.h Adott teglalap alaku tartomany meretet adja meg byte-okban. #include <graphics.) unsigned far imagesize(int left, int top, int right, int bottom) Param
eterek: left, top right, bottom a teglalap bal fels}o sarka a teglalap jobb also sarka Megjegyz
es: Ha nagyobb memoria szukseges a tarolasra, mint 64 Kbyte, akkor az imagesize fuggveny -1 ertekkel ter vissza.
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI

initgraph 145 graphics.h Inicializalja a grakus rendszert. #include <graphics.h> void far initgraph(int far *graphdriver, int far *graphmode, char far *pathtodriver) Param
eterek: a grakus kartya tpusa grakus mod az aktualis .bgi le-t tartalmazo hozzaferesi ut (path) Megjegyz
es: A graphdriver parameternel a DETECT ertek megadasa eseten a grakus kartya tpusa es a grakus mod automatikusan kerul kivalasztasra. Ha az aktualis .bgi le az aktv DOS konyvtarban van, akkor a pathtodriver parameter erteke "" (ures sztring) lehet. graphdriver graphmode pathtodiver installuserdriver graphics.h A felhasznalo altal rt BGI meghajto installalasa a grakus rendszerbe. #include <graphics.h> int far installuserdriver(char far *name, int huge (*detect)(void)) Param
eterek: az uj meghajto (.bgi) le neve pointer egy szabadon valasztott fuggvenyre, amely automatikusan erzekeli az uj meghajtot. name detect

installuserfont graphics.h Betolt egy uj karakterkeszletet, amely nincs beeptve a .BGI rendszerbe #include <graphics.h> int far installuser(char far *name) Param
eter: name az utvonal neve, ahol az uj karakterkeszlet van. Megjegyz
es: Egyszerre csak 20 karakter installalhato. Hibajelzest kapunk, ha a bels}o tabla tele van, ilnyenkor a fuggveny a grError (-11) ertekkel ter vissza. line Egy egyenest rajzol ket adott pont kozott. graphics.h A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 146 #include <graphics.h> void far line(int x1, int y1, int x2, int y2) Param
eterek: x1, y1 x2, y2 kezd}o koordinata veg koordinata Megjegyz
es: A ket koordinatapont kozott adott sznnel, vonaltpussal es vonalvastagsaggal egy egyenest rajzol. linerel graphics.h Egyenes szakaszt rajzol az aktualis plot-pozciotol relatv koordinatakkal megadott pontig. #include <graphics.h> void far linerel(int dx, int dy) Param
eterek: tavolsag

x iranyban tavolsag y iranyban Megjegyz
es: Az egyenest a korabban denialt sznnel, vonaltpussal es vonalvastagsaggal rajzolja meg. dx dy lineto graphics.h Egyenest rajzol az aktualis plot-pozciotol az abszolut koordinatakkal adott pontig. #include <graphics.h> void far lineto(int x, int y) Param
eterek: x, y az egyenes vegpontja Megjegyz
es: Az egyenest a korabban denialt sznnel, vonaltpussal es vonalvastagsaggal rajzolja meg. moverel graphics.h Az aktualis plot-pozciot athelyezi a relatv koordinatakkal adott helyre. #include <graphics.h> void far moverel(int dx, int dy) Param
eterek: dx dy tavolsag x iranyban tavolsag y iranyban
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI moveto 147 graphics.h A plot-pozciot az abszolut koordinatakkal adott pontba helyezi at. #include <graphics.h> void far moveto(int x, int y) Param
eterek: x, y az uj plot-pozcio abszolut koordinatai outtext graphics.h Az

aktualis plot-pozciotol kezdve szoveget r ki. #include <graphics.h> void far outtext(char far *textstring) Param
eter: textstring a kirando szovegre mutao pointer Megjegyz
es: A szoveget a korabban bealltott bet}utpussal, meretben, valamint a kijelolt iranyban (vzszintes, fugg}oleges) rja ki a plot-pozciotol kezdve. outtextxy graphics.h Szoveget r ki a megadott (x,y) ponttol kezdve. #include <graphics.h> void far outtextxy(int x, int y, char far *textstring) Param
eterek: x, y textstring az adott pont a kiirando szoveg Megjegyz
es: A korabban bealltott bet}utpussal, meretben, valamint a kijelolt iranyban (vzszintes, fugg}oleges) szoveget r ki az adott (x, y) ponttol kezdve. pieslice graphics.h Egy korcikket rajzol es befest. #include <graphics.h> void far pieslice(int x, int y, int stangle, int endangle, int radius) Param
eterek: A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 148 x, y stangle

endangle radius kozeppont koordinatai kezdeti szog vegszog sugar Megjegyz
es: Befest egy (x, y) kozeppontu, radius sugaru, stangle kezd}oszog}u es endangle vegszog}u korcikket a korabban denialt sznnel es mintaval. A kezd}o- es vegszoget az oramutato jarasaval ellentestes iranyban kell megadni, ahol a 0 fok 3 oranal van, a 90 fok pedig 12 oranal van. putimage graphics.h Korabban tarolt kepmez}o rahelyezese a keperny}ore. #include <graphics.h> void far putimage(int left, int top, void far *bitmap, int op) Param
eterek: left, top a keperny}on a teglalap alaku tartomany bal fels}o sarokpontja bitmap pointer, amely a kepmez}ot tartalmazo teruletre mutat op binaris m}uvelet a kihelyezend}o tartomany pontjai es a keperny}o pontjai kozott Megjegyz
es: A tarolt kepmez}o es a keperny}o keppontjai kozott az alabbi binaris m}uveletek denialhatok: azonosto ertek COPY PUT 0 XOR PUT 1 OR PUT 2 AND PUT 3 NOT PUT 4

leras ramasolja kizaro vagy kapcsolat vagy kapcsolat es kapcsolat a kepmez}o inverzet masolja putpixel graphics.h Egy keppontot rajzol az (x,y) pontban. #include <graphics.h> void far putpixel(int x, int y, int color) Param
eterek: a pont koordinatai a pont szine Megjegyz
es: Az (x, y) pontban a keppontot az adott sznnel rajzolja. x, y color rectangle graphics.h
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 149 Teglalapot rajzol. #include <graphics.h> void far rectangle(int left, int top, int right, int bottom) Param
eterek: left, top right, bottom a teglalap bal fels}o sarka a teglalap jobb also sarka Megjegyz
es: A teglalapot az aktualis sznnel es vonaltpussal rajzolja. restorecrtmode graphics.h Visszaalltja azt a keperny}o uzemmodot, amelyik az initgraph aktivalasa el}ott volt ervenyben. #include <graphics.h> void far restorecrtmode(void) Megjegyz
es: A restorecrtmode visszaalltja az eredeti video modot, amelyet

az initgraph erzekelt. A setgraphmode fuggveny visszakapcsolja a grakus uzemmodot A textmode fuggvenyt csak akkor hasznalhatjuk, ha szoveges uzemmodban van a keperny}o es kulonboz}o text modokat akarunk valtani. sector graphics.h Egy ellipszis vet rajzol es befest. #include <graphics.h> void far sector(int x, int y, int stangle, int endangle, int xradius, int yradius) Param
eterek: x, y stangle endangle xradius yradius kozeppont koordinatai kezd}oszog vegszog vizszintes tengely fugg}oleges tengely setactivepage U j lapot nyit meg a grakus output szamara. #include <graphics> void far setactivepage(int page) graphics.h A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 150 Param
eter lap szama page Megjegyz
es: Tobb lap hasznalatat csak az EGA (256K), a VGA es a Hercules grakus kartya teszi lehet}ove. A setvisualpage fuggveny hvasaval valtogathatjuk a lathato lapokat, ez segtseget nyujt az animacio

szamara setallpalette graphics.h Valtoztatja a paletta szneit. #include <graphics.h> void far setallpalette(struct palettetype far *palette) Param
eter: palette egy palettetype tpusu strukturara mutato pointer. Megjegyz
es: EGA/VGA paletta szneket lehet valtoztatni a fuggvennyel. A palettetype struktura a kovetkez}o: setallpalette #define MAXCOLOR 15 struct palettetype { unsigned char size signed char colors"MAXCOLORS+1] } Lehetseges szinek: nev CGA BLACK BLUE GREEN CYAN RED MAGENTA BROWN LIGHTGRAY DARKGRAY LIGHTBLUE LIGHTGREEN LIGHTCYAN LIGHTRED LIGHTMAGENTA YELLOW WHITE EGA/VGA szn nev szn 0 EGA BLACK 0 1 EGA BLUE 1 2 EGA GREEN 2 3 EGA CYAN 3 4 EGA RED 4 5 5 EGA MAGENTA 6 EGA LIGHTGRAY 7 7 EGA BROWN 20 8 EGA DARKGRAY 56 9 EGA LIGHTBLUE 57 10 EGA LIGHTGREEN 58 11 EGA LIGHTCYAN 59 12 EGA LIGHTRED 60 13 EGA LIGHTMAGENTA 61 14 EGA YELLOW 62 15 EGA WHITE 63
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 151 A tombben a szn helyen -1 van,

ott a paletta szne nem valtozik. setaspectratio graphics.h Valtoztatja a gyelembe veend}o vizszintes/fugg}oleges keparanyt. | #include <graphics.h> void far setaspectratio(int xasp, int yasp) Param
eterek: xasp, yasp aranytenyez}ok Megjegyz
es: Ha a beeptett keparannyal egy kor torzult, akkor a hibat szoftver uton kikuszobolhetjuk, ha az aranyokat valtoztatjuk. setbkcolor graphics.lib Bealltja a hatter sznet. #include <graphics.h> void far setbkcolor(int color) Param
eter: egy szn a palettabol, amely lehet egy szam (0{15), vagy a szn szimbolikus neve color Megjegyz
es: A color parameterrel az alabbi modon allthatjuk be kekre a hatter szinet setbkcolor(BLUE) A hatter sznkent az alabbiakat hasznalhatjuk: Szam Nev 0 BLACK 1 BLUE 2 GREEN 3 CYAN 4 RED 5 MAGENTA 6 BROWN 7 LIGHTGRAY setcolor Bealltja a rajzolas sznet. | Szam Nev 8 DARKGRAY 9 LIGHTBLUE 10 LIGHTGREEN 11 LIGHTCYAN 12 LIGHTRED 13

LIGHTMAGENTA 14 YELLOW 15 WHITE graphics.lib A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 152 #include <graphics.h> void far setcolor(int color) Param
eter color egy szn a palettabol Megjegyz
es: A color parameter erteke 0-tol getmaxcolor altal visszaadott ertekeig valtozhat, amely a rajzolas sznet alltja be. EGA eseten 0-tol 15-ig valtozhat. A rajzolas sznei CGA eseten PaPixel szn-erteke mod letta 1 2 3 0 CGA LIGHTGREEN CGA LIGHTRED CGA YELLOW CGAC0 1 CGA LIGHTCYAN CGA LIGHTMAGENTA CGA WHITE CGAC1 2 CGA GREEN CGA RED CGA BROWN CGAC2 3 CGA CYAN CGA MAGENTA CGA LIGHTGRAY CGAC3 A CGA grakus kartya eseten egyszerre csak negy sznt hasznalhatunk, amelyb}ol egy a hatterszn. A 4 grakus modbol azt a modot valasszuk ki, amelynek a rajzolasi sznertekeit akarjuk felhasznalni. Termeszetesen a modokat valtogathatjuk Peldaul CGAC0 modban a paletta 4 sznt tartalmaz Ezek: a hatterszn, halvany zold, halvany piros es

sarga. Ebben a modban a setcolor(CGA YELLOW) hv as sargat valasztja ki rajzolasi sznnek. setfillpattern graphics.h Bitkepet denial a USER FILL fest}ominta szamara (lasd setfillstyle) #include <graphics.h> void far setfillpattern(char far *upattern, int color) Param
eterek: pointer egy 8 byte hosszu memoria teruletre, ez tartalmazza a mintat szn, upattern color setfillstyle graphics.h Bealltja a fest}omintat es a sznt. #include <graphics.h> void far setfillstyle(int pattern, int color) Param
eterek:
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI minta szn Megjegyz
es: A mintavalasztekot lasd a tesenel. 153 pattern color getfillsettings fuggveny ismerte- setgraphbufsize graphics.h Valtoztatja a bels}o grakus buer meretet. #include <graphics.h> unsigned far setgraphbufsize(unsigned bufsize) Param
eter: a buer merete bufsize Megjegyz
es: A beeptett buer merete 4096 byte. Ha kisebb is eleg, akkor memoria

teruletet lehet megtakartani. Ha a buer kevesnek bizonyul, -7 hibajelzest kapunk A beeptett buer merete egy 650 torespontu poligon befestesehez elegend}o Ha ennel tobb torespontu poligont akarunk befesteni, akkor meg kell novelni a buer meretet, hogy elkeruljuk a buer tulcsordulasat. setgraphmode graphics.h Bealltja a grakus modot es torli a keperny}ot. #include <graphics.h> void far setgraphmode(int mode) Param
eter: mode a beeptett grakus kartya ervenyes modja setlinestyle graphics.h Bealltja a vonal tpusat es vastagsagat. #include <graphics.h> void far setlinestyle(int linestyle, unsigned upattern, int thickness) Param
eterek: linestyle upattern thickness Megjegyz
es: A nialva: vonaltpus vonaltpus minta vonalvastagsag linesettingstype struktura a graphics.h le-ban van de- A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 154 struct linesettingstype { int linestyle unsigned upattern int

thickness } A linestyle parameter erteke az alabbi lehet: nev ertek leras 0 teljes vonal 1 pontozott vonal 2 kozepvonal 3 szaggatott vonal 4 bitmintaval megadott A thickness parameter az alabbi lehet: SOLID LINE DOTTED LINE CENTER LINE DASHED LINE USERBIT LINE nev NORM WIDTH THICK WIDTH ertek leras 1 normal vastagsagu (1 pixel szeles) 3 vastag vonal (3 pixel szeles) setpalette graphics.h Egy paletta sznt valtoztat. #include <graphics.h> void far setpalette(int colornum, int color) Param
eterek: szn sorszama a tablazatban szn Megjegyz
es: Ha a colornum erteke 0 es a color erteke GREEN, akkor az els}o elem zold lesz. A beeptett sznkonstansok sorszamat lasd a setallpalette fuggveny lerasanal. colornum color settextjustify graphics.h Szoveg helyzetenek bealltasa az outtext es az outtextxy eljarasok szamara. #include <graphics.h> void far settextjustify(int horiz, int vert) Param
eterek: vzszintes

bealltas fugg}oleges bealltas Megjegyz
es: A horiz es a vert parameterek az alabbi ertekeket vehetik fel: horiz vert
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI nev LEFT TEXT CENTER TEXT RIGHT TEXT BOTTOM TEXT TOP TEXT ertek 0 1 2 0 2 155 leras parameter balra horiz kozepre horiz, vert jobbra horiz aljara vert tetjere vert settextstyle graphics.h Bealltja az aktualis karakterkeszlet tpusat es meretet. #include <graphics.h> void far settextstyle(int font, int direction, int charsize) Param
eterek: a karaktereszlet neve az ras iranya karakterek merete Megjegyz
es: A font parameter az alabbi ertekeket veheti fel nev ertek leras DEFAULT FONT 0 8  8 pixeles karakterek TRIPLEX FONT 1 3 vonalas karakterek SMALL FONT 2 kismeret}u karakterek 3 talp nelkuli karakterek SANS SERIF FONT GOETHIC FONT 4 gotikus karakterek A direction parameter az alabbi ertekeket veheti fel: font direction charsize nev ertek leras 0

balrol jobbra 1 alulrol felfele A charsize parameter lehetseges ertekei: HORIZ DIR VERT DIR 1 2 . 10 0 8  8 bitminaju lesz a karakter 16  16 bitminaju lesz a karakter maximum vagy a beeptett 4 -es faktor, vagy a felhasznalo altal denialt meret}u setusercharsize graphics.h A karakter szelessegenek es magassaganak valtoztatasa. #include <graphics.h> void far setusercharsize(int multx, int divx, int multy, int divy) A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 156 Param
eterek: multx, divx multy, divy multx / divx multy / divy szorzodik a beeptett szelesseggel szorzodik a beeptett magassaggal setviewport graphics.h Ablakot jelol ki a grakus keperny}on. #include <graphics.h> void far setviewport(int left, int top, int right, int bottom, int clip) Param
eterek: left, top right, bottom clip az ablak bal fels}o sarka az ablak jobb also sarka pozitv eseten a kivagast bekapcsolja, nulla eseten kikapcsolja

Megjegyz
es: A tovabbiakban minden koordinatapont az adott ablakhoz lesz viszonytva. A clip parameter hatarozza meg, hogy az ablakbol kinyulo vonalak latszanak-e setvisualpage graphics.h Lathatova teszi az adott grakus ablakot. #include <graphics.h> void far setvisualpage(int page) Param
eter: page a lap szama Megjegyz
es: Tobb lap hasznalata csak EGA (256K), VGA es Hercules grakus kartya eseten lehetseges. setwritemode graphics.h Bealltja az rasmodot a vonalrajzolas szamara. #include <graphics.h> void far setwritemode(int mode) Param
eter: mode ketfajta lehet, az alabbi konstansok kozul valaszthatunk: Szimbolum ertek leras COPY PUT 0 masolas XOR PUT 1 kizaro vagy
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 157 Megjegyz
es: A COPY PUT a MOV assembler utastast hasznalja fel, a vonal felulrja a keperny}ot. Az XOR PUT az XOR utastast hajtja vegre a vonal pontjai es a keperny}o pontjai kozott. Ket

egymasutan kovetkez}o XOR utastas a vonalat letorli es a keperny}on az eredeti kep marad meg. textheight graphics.h Visszater a szoveg keppontokban mert magassagaval. #include <graphics.h> int far textheight(char far *textstring) Param
eter: textstring szovegre mutato pointer textwidth graphics.h Visszater a szoveg keppontokban mert szelessegevel. #include <graphics.h> int far textwidth(char far *textstring) Param
eter: textstring szovegre mutato pointer A.14 A ltalanos konyvtari fuggvenyek A kovetkez}okben a BORLAND C++ legfontosabb, altalanos celu konyvtari fuggvenyeit ismertetjuk. Mindegyik fuggveny eseteben utalunk a portabilitasi lehet}osegekre (ANSI C, es/vagy UNIX kompatibilitas! DOS vagy BORLAND C++ specikus! csak C++-ban hozzaferhet}o, stb), illetve az MS-Windows alkalmazoi programokban valo felhasznalasi lehet}osegre. abort stdlib.h, processh Abnormalisan terminal az egy fuggvenyt. void

abort(void) Megjegyz
es: Az Abnormal program termination szoveget rja ki a standard hiba-periferian (stderr) es aktivalja 3-as koddal az exit fuggvenyt. Visszat
er
esi
ert
ek: 3-as koddal ter vissza a hvo programba vagy a DOS-ba. Portabilit
as: ANSI C es UNIX kompatibilis. acos math.h, stdlibh, complexh A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 158 Arkusz koszinus erteket szamol. Val
os verzi
o: < > #include math.h double acos(double x) Komplex verzi
o: < > #include complex.h double acos(complex x) Megjegyz
es: A double argumentumnak -1 es 1 kozott kell lenni. Hibas argumentum eseten 0-val ter vissza, bealltja az errno erteket az EDOM Domain error hibajelzesre. A komplex inverz koszinusz alakja: p arccos(z ) = ;i  log(z + i  1 ; z 2 ) A fuggveny komplex verzioja csak C++-ban hasznalhato. Visszat
er
esi
ert
ek: 0  kozotti ertekkel ter vissza. Portabilit
as: Az acos valos valtozata ANSI C es UNIX

kompatibilis. A fuggveny komplex valtozata BORLAND C++ specikus asctime time.h A datumot es az id}ot ASCII karakterlancca konvertalja. #include <time.h> char *asctime(const struct tm tblock) Megjegyz
es: 26 karakteres sztringkent adja vissza a *tblock strukturaban tarolt datumot es id}ot (a 26-dik karakter az EOS): Sun Aug 16 02:05:45 1989nnn0 Visszat
er
esi
ert
ek: A karakterlancra mutato pointer. A sztringet a kovetkez}o asctime() vagy ctime() hvas felulrja Portabilit
as: ANSI C es UNIX kompatibilis. asin math.h, complexh Arkusz szinuszt szamol. Val
os verzi
o: < > #include math.h double asin(double x) Komplex verzi
o: < > #include complex.h double asin(complex x) Megjegyz
es: A double argumentumnak -1 es 1 kozott kell lenni.Hibas argumentum eseten 0-val ter vissza es bealltja errno erteket az EDOM Domain error hibajelzesre. A komplex inverz szinus alakja: p arcsin(z ) = ;i  log(i  z + 1 ; z 2)

Visszat
er
esi
ert
ek: ;
2
2 kozotti ertekkel ter vissza. Portabilit
as: A fuggveny valos valtozata ANSI C es UNIX kompatibilis. A fuggveny komplex verzioja csak BORLAND C++-ban hasznalhato.
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 159 assert assert.h Teszteli a feltetelt es szukseg eseten abortal. #include <assert.h> #include <stdio.h> void assert(int condition) Megjegyz
es: Ha a condition hamis (0), akkor az assert a kovetkez}o uzenetet rja ki a stderr folyamba (a terminalra): Assertion failed: condition, le forr% asfile, line sor sz% ama  es az abort hvasa reven terminalja a programot. Ha az assert.h include le beeptese el}ott denialjuk az NDEBUG szimbolumot tetsz}oleges ertekkel, akkor az assert makro hatastalan lesz. Portabilit
as: ANSI C es UNIX kompatibilis. atan math.h, complexh Arkusz tangest szamt. Val
os verzi
o: < > #include math.h double atan(double x) Komplex verzi
o: < > #include

complex.h double atan(complex x) A komplex inverz tangens alakja: Visszat
er
esi
ert
ek: + i  z) arctan(z ) = ;0:5  i  log( 11 ; iz ;
2
2 kozotti ertekkel ter vissza. Portabilit
as: A fuggveny valos valtozata ANSI C es UNIX kompatilis. A komplex verzioja csak BORLAND C++-ban hasznalhato atan2 math.h y=x arkusz tangenset szamtja. #include <math.h> double atan2(double y, double x) Visszat
er
esi
ert
ek: ;
2
2 kozotti ertekkel ter vissza. Portabilit
as: ANSI C es UNIX kompatibilis. atof math.h, stdlibh Sztringet konvertal lebeg}opontos szamma. #include <math.h> double atof(const char *s) A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 160 Visszat
er
esi
ert
ek: Az input sztringnek megfelel}o lebeg}opontos ertek. Ha a konvertalas sikertelen, a visszateresi ertek 0 Portabilit
as: ANSI C es UNIX kompatibilis. atoi stdlib.h Sztringet konvertal rovid egesz szamma. int atoi(const char *s) Visszat
er
esi


ert
ek: Az input sztringnek megfelel}o egesz ertek. Ha a konvertalas sikertelen, a visszateresi ertek 0. Portabilit
as: ANSI C es UNIX kompatibilis. atol stdlib.h Sztringet konvertal hosszu egesz szamma. #include <stdlib.h> long atol(const char *s) Visszat
er
esi
ert
ek: Az input sztring konvertalt erteke. Ha a konvertalas sikertelen, a visszateresi ertek 0L Portabilit
as: ANSI C es UNIX kompatibilis. bcd bcd.h Szamot konvertal binarisan kodolt decimalisba (BCD). #include <bcd.h> bcd bcd(int x) bcd bcd(double x) bcd bcd(double x, int decimals) Megjegyz
es: Az osszes aritmetikai m}uvelet m}ukodik BCD szamokkal. A BCD szamok 17 jegyre pontosak, abszolut tartomanyuk 10;125 es 10125 kozott van. A decimals argumentum opcion alis, amellyel megadhato, hogy mennyi decimalis jegy legyen a tizedes pont utan. Portabilit
as: BORLAND C++ specikus. bdos dos.h A DOS rendszer kozvetlen hvasat vegzi. int bdos(int dosfun, unsigned

dosdx, unsigned dosal)
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 161 Megjegyz
es: dosfun az MS-DOS Programmers Reference Manual-ban denialt funkciokod dosdx DX regiszter bemen} o erteke dosal AL regiszter bemen} o erteke Visszat
er
esi
ert
ek: A DOS hvas altal visszaadott AX regiszterertek. Portabilit
as: DOS specikus. bsearch stdlib.h Binaris kereses egy rendezett tombben. #include <stdlib.h> void *bsearch(const void key, const void base, size t nelem, size t width, int(*fcomp)(const void , const void )) Megjegyz
es: A size t tpus el}ojelnelkuli egeszkent van denialva. Az adott tomb kezd}ocme a keresend}o ertekre mutato pointer a tomb elemeinek szama a tombelemek merete sizeof egysegben pointer az osszehasonlto fuggvenyre Az osszehasonlto fuggvenyt a bsearch ket pointerrel hvja meg, amelyek a kulcsra, illetve egy bizonyos elemre mutatnak. A fuggvenynek a kovetkez}o ertekeket kell szolgaltatnia: base key nelem width

fcomp < 0, ha az els}o pointer mutatta argumentum kisebb a masodiknal ha a ket elem megegyezik > ha az els}o pointer mutatta argumentum nagyobb a masodiknal Visszat
er
esi
ert
ek: A megtalalt tablabeli elem cme, illetve NULL, ha nem talalt. == 0, 0, Portabilit
as: ANSI C es UNIX kompatibilis. cabs math.h Komplex szam abszolut erteke. #include <math.h> double cabs(struct complex z) Megjegyz
es: A struktura az alabbi: struct complex { double x, y } A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 162 az x a valos, az y a kepzetes resz. Visszat
er
esi
ert
ek: A z komplex szam abszolut erteke vagy HUGE VAL tulcsordulas eseten. Portabilit
as: UNIX kompatibilis. calloc stdlib.h, alloch Memoriateruletet foglal le (allokal). #include <stdlib.h> void *calloc(size t nitems, size t size) Megjegyz
es: A calloc lefoglal egy nitems  size meret}u memoriateruletet es kinullazza. Visszat
er
esi
ert
ek: A lefoglalt blokkra mutato

pointer. Ha a lefoglalando meretre nincs hely, vagy nitems vagy size 0, akkor NULL-t ad vissza Portabilit
as: ANSI C es UNIX kompatibilis. chdir dir.h Aktualis katalogus (directory) valtasa. int chdir(const char *path) Megjegyz
es: Lemezegyseg is specikalhato a path argumentumban, peldaul chdir("a:\borlandc") Visszat
er
esi
ert
ek: Sikeres vegrehajtas eseten a visszateresi ertek 0, kulonben -1 es az errno a kovetkez}o hibajelzesre lesz bealltva: ENOENT a path (utvonal) vagy a le nev nem letezik. Portabilit
as: UNIX kompatibilis. clock time.h Processzor id}o lekerdezese. #include <time.h> clock t clock(void) Megjegyz
es: A clock segtsegevel ket esemeny kozotti id}ointervallum meghatarozhato. Ha az erteket masodpercben kvanjuk megkapni, a visszaadott erteket el kell osztani a CLK TCK szimbolummal. Visszat
er
esi
ert
ek: A program indulasa ota eltelt processzor id}o bels}o egysegben. Portabilit
as: ANSI C

kompatibilis.
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 163 close io.h Lezar egy le-t. int close(int handle) Megjegyz
es: A handle le-leroval azonostott le-t zarja le. Visszat
er
esi
ert
ek: Hiba eseten az errno valtozot bealltja a EBADF ertekre (rossz le azonosto szam). Portabilit
as: UNIX kompatibilis. complex complex.h Komplex szamot hoz letre. #include <complex.h> complex complex(double real, double imag) Megjegyz
es: A megadott valos es kepzetes reszb}ol komplex szamot hoz letre. Ha a kepzetes resz 0, akkor az imag megadasa elhagyhato. A C++-ban a complex oszt aly szamara a complex fuggveny a konstruktor. A C++ hasznalata szukseges a komplex aritmetikahoz Ha nem hasznaljuk a C++-t, akkor csak a struct complex es a cabs hasznalhato, mindkett}o a math.h-ban van deklaralva. Acomplexh lehet}ove teszi a +, -, *, /, +=, -=, =, /=, ==, != operatorok hasznalatat. Szabadon keverhet}ok a komplex m}uveletekben az egesz, a

duplapontossagu es mas numerikus tpusok. Ugyanugy hasznalhato a << es >> az inputra es outputra, mint mas tpusoknal. Visszat
er
esi
ert
ek: A komplex szam az adott valos es kepzetes reszeivel. Portabilit
as: csak C++-ban hasznalhato. conj complex.h A komplex szam konjugaltjat kepezi. #include <complex.h> complex conj(complex z) Megjegyz
es: A conj(z) azonos a complex(real(z),-imag(z)) hvasaval. Visszat
er
esi
ert
ek: A komplex szam konjugaltja. Portabilit
as: Csak C++-ban hasznalhato. cos Koszinusz erteket szamol. math.h, complexh A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 164 Val
os verzi
o: < > #include math.h double cos(double x) Komplex verzi
o: < > #include complex.h double cos(complex x) Megjegyz
es: A komplex koszinusz denicioja: cos(z ) = exp(i  z ) +2exp(;i  z ) Megjegyz
es: A fuggveny komplex verzioja csak C++-ban hasznalhato. Visszat
er
esi
ert
ek: A radianban megadott

szog koszinusza. Portabilit
as: A fuggveny valos verzioja ANSI C es UNIX kompatibilis. Komplex verzioja csak C++-ban hasznalhato. cosh math.h, complexh Koszinusz hiberbolikusz erteket szamol. Val
os verzi
o: Komplex verzi
o: < > #include math.h double cosh(double x) < > #include complex.h double cosh(complex x) Megjegyz
es: cosh szamtasa cosh(x) = exp(x) +2exp(;x) A komplex cosh szamtasa cosh(z ) = exp(z ) +2exp(;z ) Visszat
er
esi
ert
ek: Az argumentum koszinus hiperbolikusza. Portabilit
as: A fuggveny valos verzioja ANSI C es UNIX kompatibilis. A komplex verzio csak C++-ban hasznalhato creat io.h U j le-t hoz letre, vagy felulr egy letez}o le-t. #include <sysstat.h> int creat(const char *path, int amode) Megjegyz
es: Letrehozza vagy felulrja a path-ban megadott nev}u le-t amode hozzaferesi moddal. amode v altozo erteke hozzaferesi mod S IWRITE csak rasra (DOS alatt olvasast is enged) S IREAD

csak olvasasra S IREAD j S IWRITE rasra es olvasasra
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 165 Visszat
er
esi
ert
ek: A le-lero, vagy hiba eseten -1. Portabilit
as: UNIX kompatibilis. ctime time.h A datumot es az id}ot ASCII karakterlancca konvertalja. #include <time.h> char *ctime(const time t time) Megjegyz
es: *time egy megelez}o time() hvassal allthato be. A datumot es az id}ot az alabbi formaju, ujsor es EOS karakterrel lezart 26 karakteres sztringben szolgaltatja: Sun Aug 16 02:05:45 1989nnn0 Visszat
er
esi
ert
ek: A karakterlancra mutato pointer. A sztringet a kovetkez}o asctime(), vagy ctime() hvas felulrja Portabilit
as: ANSI C es UNIX kompatibilis. ecvt stdlib.h Lebeg}opontos szamot sztringbe konvertal. char *ecvt(double value, int ndig, int *dec, int *sign) Megjegyz
es: A value erteket konvertalja ndig szamjegyet tartalmazo sztringge, *dec-be a tizedespont pozciojat teszi a rutin (maga a tizedespont

nem szerepel a sztringben), *sign-ba pedig nem 0 kerul, ha az ertek negatv. Visszat
er
esi
ert
ek: A sztringre mutato pointer, ami egy statikus buerben van. ecvt k ovetkez}o hvasa felul fogja rni az uj ertekkel. Portabilit
as: UNIX kompatibilis. eof io.h File-veg ellen}orzese. int eof(int handle) Visszat
er
esi
ert
ek: Ha az aktualis pozcio a le-veg, az eof visszateresi erteke 1, kulonben 0. Portabilit
as: DOS specikus. A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 166 exec. process.h Programokat tolt be es futtat. Megjegyz
es: Az exec fuggvenycsalad egyes tagjai megegyeznek a spawn. csalad megfelel}o tagjaival, ha az ott megadott mode  erteke P OVERLAY. Ezert az exec csaladban nincs mode parameter, egyebekben a parameterezes ugyanaz. Portabilit
as: A BORLAND C++ implementacio DOS specikus, de a UNIX alatt hasonlo fuggvenycsalad letezik. exit process.h, stdlibh Terminalja a programot es visszaadja a vezerlest a

DOS-nak vagy a hvo programnak. void exit(int status) Megjegyz
es: A terminalas el}ott az osszes le-t lezarja. Nem ter vissza A status a visszaadott st atuszkod, hasznalhato szimbolumok: normal program terminalas terminalas hibaval. Portabilit
as: ANSI C es UNIX kompatibilis. EXIT SUCCESS EXIT FAILURE exit process.h, stdlibh Terminalja a programot. void exit(int status) Megjegyz
es: Terminalja a vegrehajtast a le-ok lezarasa nelkul. Portabilit
as: UNIX kompatibilis. exp math.h, complexh ex erteket szamol. Val
os verzi
o: < > #include math.h double exp(double x) Komplex verzi
o: < > #include complex.h complex exp(complex.h) Megjegyz
es: A komplex exponencialis fuggveny exp(x + i  y) = exp(x)  (cos(y) + i  sin(y)) Visszat
er
esi
ert
ek: ex. Portabilit
as: A valos valtozat ANSI C es UNIX kompatibilis, a komplex valtozat csak C++-ban hozzaferhet}o.
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI farcalloc 167 alloc.h

Memoriat foglal le az alapszegmensen kvul. void far *farcalloc(unsigned long nunits, unsigned long unitsz) Megjegyz
es: Ugyanaz a funkcioja, mint a calloc-nak, de small es medium modellb}ol is lehet}ove teszi az osszes rendelkezesre allo RAM lefoglalasat, valamint segtsegevel 64 Kbyte-nal nagyobb tombok szamara is foglalhatunk le memoriat. A tiny kivetelevel minden modellb}ol hvhato. Visszat
er
esi
ert
ek: Egy far pointer, mely az ujonnan lefoglalt blokkra mutat, illetve NULL, ha nincs eleg memoria. Portabilit
as: DOS specikus. farmalloc alloc.h Memoriat foglal le az alapszegmensen kvul. void far *farmalloc(unsigned long nbytes) Megjegyz
es: Lasd malloc-ot es farcalloc-ot. Visszat
er
esi
ert
ek: Egy far pointer, mely az ujonnan lefoglalt blokkra mutat, illetve NULL, ha nincs eleg memoria. Portabilit
as: DOS specikus. farfree alloc.h Felszabadt egy memoriablokkot. void farfree(void far *block) Megjegyz
es: block egy megel}oz}o

farmalloc(), farcalloc() illetve farrealloc() hv asbol szarmazhat. Portabilit
as: DOS specikus. farrealloc alloc.h Modostja egy lefoglalt memoriaterulet meretet. void far *farrealloc(void far oldblock, unsigned long nbytes) Megjegyz
es: nagysagura modostja az oldblock mutatta, megel}oz}o stb. hvasbol szarmazo allokalt blokkot Tartalmat uj teruletre masolja, ha a keres teljestese az eredeti helyen nem lehetseges. farmalloc() nbytes A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 168 Visszat
er
esi
ert
ek: Az ujra allokalt blokk cme, amely lehet, hogy elter oldblock-t ol. Ha a kert meretnoveles nem teljesthet}o, NULL ertekkel ter vissza Portabilit
as: DOS specikus. fclose stdio.h File-t zar le. #include <stdio.h> int fclose(FILE *stream) Megjegyz
es: A stream le-mutatoval azonostott le-t zarja le. Visszat
er
esi
ert
ek: A visszateresi ertek sikeres lezaras eseten 0, kulonben hiba eseten EOF.

Portabilit
as: ANSI C es UNIX kompatibilis. fcvt stdlib.h Lebeg}opontos szamot sztringge alakt. #include <stdlib.h> char *fcvt(double value, int ndig, int *dec, int *sign) Megjegyz
es: A value erteket konvertalja ndig decimalis szamjegyet tartalmazo sztringge, *dec-be a tizedespont pozciojat teszi a rutin (maga a tizedespont nem szerepel a sztringben), *sign-ba pedig nem 0 kerul, ha az ertek negatv. Visszat
er
esi
ert
ek: A sztringre mutato pointer, ami egy statikus buerben van. fcvt k ovetkez}o hvasa felul fogja rni az uj ertekkel. Portabilit
as: ANSI C es UNIX kompatibilis. feof stdio.h File-veg pozcio detektalasa. #include <stdio.h> int eof(FILE *stream) Visszat
er
esi
ert
ek: A visszateresi ertek nem 0, ha a stream le-mutatoval azonostott le aktualis pozcioja a le-veg. Portabilit
as: ANSI C es UNIX kompatibilis. ferror stdio.h
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 169 A tviteli hiba lekerdezese.

#include <stdio.h> int ferror(FILE *stream) Megjegyz
es: A getc stb. rutinok mind le vege eseten, mind adatatviteli hiba eseten EOF ertekkel ternek vissza. A ferror es a feof hasznalhato annak eldontesere, hogy melyik eset allt el}o Visszat
er
esi
ert
ek: A visszateresi ertek nem 0, ha a stream le-mutatoval azonostott le rasa vagy olvasasa kozben adatatviteli hiba volt. Portabilit
as: ANSI C es UNIX kompatibilis. fgets stdio.h Egy sor beolvasasa adott le-bol. #include <stdio.h> char *fgets(char s, int n, FILE stream) Megjegyz
es: Az stream altal azonostott le-bol maximum n ; 1 karaktert az s sztringbe olvas, de le all az olvasas az els}o beolvasott ujsor karakter utan. A sztring vegere kiteszi az EOS karaktert. Visszat
er
esi
ert
ek: Sikeres olvasas eseten az s sztringre mutato pointer, hiba eseten NULL. Portabilit
as: ANSI C es UNIX kompatibilis. fopen stdio.h Megnyit vagy letrehoz egy le-t folyam jelleg}u

kezelesre. #include <stdio.h> FILE *fopen(const char filename, const char mode) Megjegyz
es: Megnyitja vagy letrehozza a filename nev}u le-t a mode ertekenek megfelel}oen. A nev tartalmazhat meghajto (drive) es utvonal (path) megadast is, de ne felejtsuk el a n karaktereket megkett}ozni. Amode sztring ertekei az alabbiak lehetnek: r letez}o le megnyitasa csak olvasasra w uj le letrehozasa (vagy letez}o felulrasa) es megnyitasa csak rasra a letez}o le megnyitasa hozzaf}uzesre (append), vagy uj le letrehozasa csak rasra, ha nem letezik. r+ l etez}o le megnyitasa olvasasra es rasra w+ u j le letrehozasa (vagy letez}o felulrasa) es megnyitasa olvasasra es rasra a+ megnyit as olvasasra es hozzaf}uzesre. Ha a le nem letezik, el}oszor letrehozza. A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 170 Azoknal a kezelesi modoknal, ahol ras es olvasas egyarant lehetseges, atviteli irany valtas

eseten meg kell hvni az fseek, vagy rewind fuggvenyeket a bels}o puerek urtese celjabol. A mode sztring minden fent megadott ertekehez hozzatoldhatjuk a t vagy b karaktert annak jelzesere, hogy szoveges (text) vagy binaris modban kvanjuk a le-t kezelni. Ha nem adjuk meg egyiket sem, akkor a le az fmode nev}u globalis valtozo altal tarolt mod szerint lesz megnyitva. Az fmode-nak  ertekul az fcntl.h include le-ban denialt O TEXT vagy O BINARY szimbolumot adhatjuk. Visszat
er
esi
ert
ek: Sikeres megnyitas eseten a le-mutato, hiba eseten aNULL pointer. Portabilit
as: ANSI C es UNIX kompatibilis. fprintf stdio.h Formazott kivitel le-ba. #include <stdio.h> int fprintf(FILE *stream, const char format, .) Megjegyz
es: M}ukodese megegyezik a printf rutineval, de megadhato a kimeneti folyam a stream le-mutatoval. Tovabbi reszleteket a printf fuggvenycsalad ismertetesenel, a 1.102-es szakaszban talalhatunk Visszat
er
esi


ert
ek: A kirt byte-ok szama, vagy hiba eseten EOF. Portabilit
as: ANSI C es UNIX kompatibilis. fputs stdio.h File-ba kir egy karakterlancot. #include <stdio.h> int fputs(const char *s, FILE stream) Megjegyz
es: Kirja az s sztringet a stream-mel azonostott le-ba. A zaro EOS nem kerul kivitelre. Visszat
er
esi
ert
ek: Sikeres vegrehajtas eseten az utolso kirt karakterrel ter viszsza, egyebkent a visszateresi ertek EOF. Portabilit
as: ANSI C es UNIX kompatibilis. fread stdio.h File-bol tombot olvas. #include <stdio.h> size t fread(void *ptr, size t size, size t n, FILE *stream)
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 171 Megjegyz
es: A stream-mel azonostott le-bol beolvas n darab size meret}u adatot a ptr altal mutatott tombbe. Visszat
er
esi
ert
ek: A beolvasott adatok (nem a byte-ok) szama. Hiba, vagy le-veg eseten n-nel kevesebbet ad vissza. Portabilit
as: ANSI C es UNIX kompatibilis. free stdlib.h, alloch

Felszabadtja az allokalt memoriablokkot. void free(void *block) Megjegyz
es: Felszabadt egy lefoglalt memoriablokkot. A block egy megel}oz}o calloc(), malloc() vagy a realloc() hv as reven kapott mutato. Portabilit
as: ANSI C es UNIX kompatibilis. fscanf stdio.h File-bol olvas formatum szerint #include <stdio.h> int fscanf(FILE *stream, const char format, .) Megjegyz
es: M}ukodese megegyezik a scanf rutineval, de megadhato a bemeneti folyam a stream le-mutatoval. Visszat
er
esi
ert
ek: A sikeresen beolvasott mez}ok szama. File-veg eseten EOF-ot ad. Portabilit
as: ANSI C es UNIX kompatibilis. fseek stdio.h File aktualis pozciojanak bealltasa #include <stdio.h> int fseek(FILE *stream, long offset, int origin) Megjegyz
es: Bealltja a stream altal azonostott le-ban az aktualis le-pozciot az origin-hez kepest offset byte-ra. Az origin az alabbi ertekeket veheti fel: szimbolum szamertek offset szamtasa SEEK SET 0

a le elejet}ol SEEK CUR 1 az aktualis le pozciotol 2 a le veget}ol SEEK END Visszat
er
esi
ert
ek: Sikeres vegrehajtas eseten 0, kulonben nem 0. Portabilit
as: ANSI C es UNIX kompatibilis. A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 172 ftell stdio.h Az aktualis le-pozciot szolgaltatja. #include <stdio.h> long int ftell(FILE *stream) Megjegyz
es: A le-pozcio a le elejet}ol byte-okban kifejezett tavolsag,0L-rol indul. Visszat
er
esi
ert
ek: Az aktualis le-pozcio erteke sikeres vegrehajtas eseten, egyebkent -1L. Portabilit
as: ANSI C es UNIX kompatibilis. fwrite stdio.h File-ba tombot r. #include <stdio.h> size t fwrite(const void *ptr, size t size, size t n, FILE *stream) Megjegyz
es: A stream-mel azonostott le-ba kir n darab size meret}u adatot a ptr mutatta tombb}ol. Visszat
er
esi
ert
ek: A kirt adatok (nem a byte-ok) szama. Hiba eseten n-nel kevesebbet ad vissza. Portabilit
as: ANSI C es UNIX

kompatibilis. gcvt stdlib.h Lebeg}opontos szam ASCII karakterlancca konvertalasa. #include <dos.h> char *gcvt(double value, int ndec, char buf) Megjegyz
es: value erteket konvertalja ndec ertekes szamjegyre xpontos alakban (FORTRAN F forma), ha lehet, egyebkent lebeg}opontos alakban (FORTRAN E forma). Az eredmeny a buf mutatta puerbe kerul, EOS karakterrel lezarva. Visszat
er
esi
ert
ek: buf. Portabilit
as: ANSI C es UNIX kompatibilis. getc Egy karaktert olvas a le-bol. stdio.h
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 173 #include <stdio.h> int getc(FILE *stream) Megjegyz
es: Beolvassa a le kovetkez}o karakteret, es egesz szamma konvertalja el}ojelkiterjesztes nelkul. getc makrokent lett megvalostva Visszat
er
esi
ert
ek: A beolvasott karakter, le-veg vagy hiba eseten EOF. Portabilit
as: ANSI C es UNIX kompatibilis. getch conio.h Karakter olvas a klaviaturarol, keperny}ore ras (echo) nelkul. int getch(void)

Megjegyz
es: A getch a stdin folyamot (standard input) hasznalja. Visszat
er
esi
ert
ek: a beolvasott karakter. Portabilit
asi opci
ok: DOS specikus, WINDOWS-ban nem hasznalhato. getchar stdio.h Karaktert olvas a standard inputrol. #include <stdio.h> int getchar(void) Megjegyz
es: Megegyezik a getc(stdin) hvassal. Visszat
er
esi
ert
ek: a beolvasott karakter. Portabilit
as: ANSI C es UNIX kompatibilis. WINDOWS-ban nem hasznalhato getche conio.h Karaktert olvas a klaviaturarol es visszarja a keperny}ore. int getche(void) Visszat
er
esi
ert
ek: a beolvasott karakter. Portabilit
as: ANSI C es UNIX kompatibilis. WINDOWS-ban nem hasznalhato gets stdio.h Beolvas egy sort a standard inputrol. char *gets(char s) A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 174 Megjegyz
es: A beolvasott sort az s sztring valtozoba helyezi, az ujsor karaktert EOS karakterrel helyettestve. Visszat% er% esi % ert% ek: Sikeres olvasas eseten s, le-veg vagy

hiba eseten NULL. Portabilit
as: ANSI C es UNIX kompatibilis. WINDOWS-ban nem hasznalhato gmtime time.h A time t tpusban megadott datumot es id}ot strukturaba bontja. #include <time.h> struct tm *gmtime(const time t time) Megjegyz
es: time feltolteset a time hvasaval vegezhetjuk. A tm struktura dencioja a time.h include le-ban talalhato Visszat
er
esi
ert
ek: A strukturara mutato pointer. A kovetkez}o gmtime() hvas felulrja az uj ertekkel Portabilit
as: DOS specikus. int86 dos.h A ltalanos 8086 programozott megszaktas (software interrupt) #include <dos.h> int int86(int intno, union REGS *inregs, union REGS *outregs) Megjegyz
es: Az int86 az intno argumentumban specikalt 8086 szoftver interruptot hajtja vegre. Miel}ott vegrehajtana a szoftver interruptot, atmasolja a regiszterek erteket az inregs parameterb}ol a regiszterekbe. Az interrupt vegrehajtasa utan az int86 atmasolja a regiszterek tartalmat az

outregs-be A carry ag statuszat a x.cflag tartalmazza Visszat
er
esi
ert
ek: A visszaadott AX regiszterertek. Portabilit
as: A 8086 processzor csaladra specikus. int86x dos.h A ltalanos 8086 programozott megszaktas (software interrupt) #include <dos.h> int int86x(int intno, union REGS *inregs, union REGS *outregs, struct SREGS *segregs)
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 175 Megjegyz
es: Az intno argumentumban specikalt 8086 szoftware interruptot hvja meg. inregs es outregs a be-, illetve kimen}o regiszterkeszlet mutatoi (lehetnek azonosak), segregs a szegmens regiszterkeszlet mutatoja. A fenti struktura dencioja a dos.h fejlecle-ban talalhato Visszat
er
esi
ert
ek: A visszaadott AX regiszterertek. Portabilit
as: 8086 processzor csaladra specikus. isalnum ctype.h Karakter osztalyozo makro. #include <ctype.h> int isalnum(int c) Visszat
er
esi
ert
ek: nem nulla, ha a c bet}u (A-Z, a-z) vagy szamjegy (0-9). Portabilit
as:

UNIX specikus. isalpha ctype.h Karakter osztalyozo makro. #include <ctype.h> int isalpha(int c) Visszat
er
esi
ert
ek: nem nulla, ha a c bet}u (A-Z vagy a-z). Portabilit
as: ANSI C es UNIX kompatibilis. isascii ctype.h Karakter osztalyozo. #include <ctype> int isascii(int c) Visszat
er
esi
ert
ek: nem nulla, ha a 0x7F). c also byte-janak erteke 0{127 (0x00 Portabilit
as: UNIX kompatibilis. iscntrl Karakter osztalyozo makro. X #include <ctype.h> int iscntr(int c) Visszat
er
esi
ert
ek: nem nulla, ha a c erteke a DEL karakter, vagy vezerl}okarakter (0x7F, vagy 0x00 - 0x1F). Portabilit
as: ANSI C es UNIX kompatibilis. ctype.h - A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 176 isdigit ctype.h Karakter osztalyozo makro. #include <ctype.h> int isdigit(int c) Visszat
er
esi
ert
ek: nem nulla, ha a c erteke szamjegy: (0 { 9). Portabilit
as: ANSI C es UNIX kompatibilis. islower ctype.h Karakter osztalyozo makro.

#include <ctype.h> int islower(int c) Visszat
er
esi
ert
ek: nem nulla, ha a c kisbet}u (a { z)! Portabilit
as: ANSI C es UNIX kompatibilis. isprint ctype.h Karakter osztalyozo makro. #include <ctype.h> int isprint(int c) Visszat
er
esi
ert
ek: nem nulla, ha a c nyomtathato karakter (0x20 - 0x7E). Portabilit
as: ANSI C es UNIX kompatibilis. isspace ctype.h Karakter osztalyozo makro. #include <ctype.h> int isspace(int c) Visszat
er
esi
ert
ek: nem nulla, ha a c white space karakter, azaz bet}ukoz (space), tabulator, kocsivissza (carrige return), ujsor, vizszintes vagy fugg}oleges tabulator, vagy lapdobas karakter (0x09 - 0x0D). Portabilit
as: ANSI C es UNIX kompatibilis. isupper Karakter oszalyozo makro. #include <ctype.h> int isupper(int c) ctype.h
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 177 Visszat
er
esi
ert
ek: nem nulla, ha a c nagybet}u (A { Z). Portabilit
as: ANSI C es UNIX kompatibilis. isxdigit ctype.h Karakter

osztalyozo makro. #include <ctype.h> int isxdigit(int c) Visszat
er
esi
ert
ek: nem nulla, ha a c hexadecimalis szamjegy ( 0 { 9, A { F, a { f). Portabilit
as: ANSI C es UNIX kompatibilis. itoa stdlib.h Egesz szamot sztringge konvertal. char *itoa(int value, char sztring, int radix) Megjegyz
es: A value erteket EOS karakterrel lezart sztringge konvertalja a sztring mutatta t ombbe. A radix a konvertalas alapszamat hatarozza meg (2-36). Ha a value negatv, es radix 10, akkor el}ojelesen konvertal, egyebkent el}ojeltelenul. Visszat
er
esi
ert
ek: a sztring-re mutato pointer. Portabilit
as: DOS specikus. kbhit conio.h Megvizsgalja, hogy varakozik-e karakter a billenty}u-puerben. int kbhit(void) Visszat
er
esi
ert
ek: Nem nulla, ha van beolvashato karakter. Portabilit
asi opci
ok: DOS specikus, WINDOWS-ban nem hasznalhato. keep dos.h Terminalja a processzt, de rezidensen a tarban hagyja. void keep(unsigned char status, unsigned size)

Megjegyz
es: status statuszkoddal ter vissza a DOS-hoz, es a program size paragrafus hosszu reszet (size*16 byte) rezidensen a tarban hagyja. Visszat
er
esi
ert
ek: Nem ter vissza. Portabilit
asi opci
ok: DOS specikus, WINDOWS-ban nem hasznalhato. A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 178 lfind stdlib.h Linearis keresest hajt vegre. #include <stdlib.h> void *lfind(const void key, const void base, size t *num, size t width, int (*fcmp)(const void , const void )) Megjegyz
es: A *key erteke szerint linearis kereses tortenik a base tombben a felhasznalo altal denialt fcmp osszehasonlto rutin felhasznalasaval (lasdd bsearch). A t omb *num elemb}ol all, width az elemek sizeof merete. Visszat
er
esi
ert
ek: Az els}o egyez}o tombelem cme, NULL, ha nincs ilyen. Portabilit
as: DOS specikus. log math.h, complexh Termeszetes alapu logaritmust szamol. Val
os verzi
o: Komplex verzi
o: < > #include math.h double

log(double x) < > #include complex.h double log(complex x) Visszat
er
esi
ert
ek: ln(x), hibas argumentum eseten EDOM bajelzest ad. (Domain error) hi- Portabilit
as: A fuggveny valos valtozata ANSI C es UNIX kompatibilis, komplex verzioja csak C++-ban hasznalhato. log10 math.h, complexh Tizes alapu logaritmust szamol. Val
os verzi
o: < > #include math.h double log10(double x) Komplex verzi
o: < > #include complex.h double log10(complex x) Visszat
er
esi
ert
ek: lg(x), hibas argumentum eseten EDOM bajelzest ad. (Domain error) hi- Portabilit
as: A fuggveny valos valtozata ANSI C es UNIX kompatibilis, komplex valtozata csak C++-ban hasznalhato. lsearch stdlib.h Linearis keresest hajt vegre. #include <stdlib.h> void *lsearch(const void key, const void base, size t *num, size t width, int (*fcmp)(const void , const void ))
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 179 Megjegyz
es: A *key erteke szerint linearis

kereses tortenik a base tombben a felhasznalo altal denialt fcmp osszehasonlto rutin felhasznalasaval (lasd bsearch). A t omb *num elemb}ol all, width az elemek sizeof merete. Ha a keresett elemet nem talalja, akkor a tomb vegehez hozzailleszti (append). Visszat% er% esi % ert% ek: dostja. Ha uj elemet illesztett a tombbe, *num erteket mo- Portabilit
as: UNIX kompatibilis. lseek io.h File-pozciot allt be alacsony szint}u I/O m}uvelethez. #include <io.h> long lseek(int handle, long offset, int origin) Megjegyz
es: Bealltja a handle le-lero altal azonostott le-ban az aktualis le-pozciot az origin-hez kepest offset byte-ra. Az origin az alabbi ertekeket veheti fel: szimbolum szamertek offset szamtasa SEEK SET 0 a le elejet}ol SEEK CUR 1 az aktualis le pozciotol SEEK END 2 a le veget}ol Visszat
er
esi
ert
ek: Sikeres vegrehajtas eseten a bealltott le-pozcio a le elejet}ol szamtva,

egyebkent -1L. Portabilit
as: UNIX kompatibilis. ltoa stdlib.h Hosszu egesz szamot sztringge konvertal. #include <stdlib.h> char *ltoa(long value, char sztring, int radix) Megjegyz
es: A value erteket EOS karakterrel lezart sztringge konvertalja a sztring mutatta t ombbe. A radix a konvertalas alapszamat hatarozza meg (2-36). Ha a value negatv, es radix 10, akkor el}ojelesen konvertal, egyebkent el}ojeltelenul. Visszat
er
esi
ert
ek: a sztring-re mutato pointer. Portabilit
as: DOS specikus. malloc stdlib.h, alloch Dinamikus memoriafoglalas. #include <alloc.h> void *malloc(size t size) A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 180 Megjegyz
es: size byte-nyi memoriat igenyel futas kozben. Visszat
er
esi
ert
ek: az ujonnan lefoglalt memoriablokkra mutato pointer, ha a keres teljesthet}o, egyebkent NULL. Portabilit
as: ANSI C es UNIX kompatibilis. matherr math.h A felhasznalo altal modosthato matematikai

hibakezel}o rendszer. #include <math.h> int matherr(struct exception *e) Megjegyz
es: A matherr fuggveny matemetikai jelleg}u hibak felleptekor (peldaul 0-val osztas, lebeg}opontos tul-, illetve alulcsordulas stb.) kerul meghvasra Ha a felhasznalo nem denialja a fenti fuggvenyt, akkor az alapertelmezes szerinti hibakezel}o lep m}ukodesbe. Portabilit
as: ANSI C es UNIX kompatibilis. memchr string.h, memh Megkeresi egy adott byte els}o el}ofordulasi helyet. #include <mem.h> void *memchr(const void s, int c, size t n) Megjegyz
es: Az s tombben keresi a c karakter els}o el}ofordulasat. merete byte-ban. Visszat
er
esi
ert
ek: A megtalalt byte-ra mutato pointer, illetve talal. n NULL, a tomb ha nem Portabilit
as: ANSI C es UNIX kompatibilis. memcmp string.h, memh Ket adott meret}u blokkot hasonlt ossze. #include <mem.h> int memcmp(const void *s1, const void s2, size t n) Megjegyz
es: Az s1 es s2 tomb els}o n byte-jat

hasonltja ossze lexikograkusan. Visszat
er
esi
ert
ek: negatv, ha > s2. s1 < s2, nulla, ha s1 = s2 es pozitv, ha s1 Portabilit
as: ANSI C es UNIX kompatibilis.
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI memcpy 181 string.h, memh Adott meret}u memoriablokkot masol. #include <mem.h> void *memcpy(void dest, const void src, size t n) Megjegyz
es: n byte-nyi blokkot masol az src teruletr}ol a dest teruletre. A tfed}o teruletek eseten nem alkalmazhato Visszat
er
esi
ert
ek: dest. Portabilit
as: ANSI C es UNIX kompatibilis. memset string.h, memh Adott hosszusagu memoriaterulet feltoltese. #include <mem.h> void *memset(void s, int c, size t n) Megjegyz
es: Az s tomb els}o n byte-jaba berja a c karaktert. Visszat
er
esi
ert
ek: s. Portabilit
as: ANSI C es UNIX kompatibilis. open io.h File-nyitas alacsony szint}u rasra/olvasasra. #include <fcntl.h> #include <sysstat.h> int open(const char *name, int mode,

unsigned attrib) Megjegyz
es: Megnyitja a name nev}u le-t, es el}okeszti rasra es/vagy olvasasra a mode parameter szerint. A mode az alabbi szimbolumok binaris OR kapcsolataval (j) kepezhet}o Ebb}ol a csoportbol pontosan egy szimbolum szerepelhet: O RDONLY nyitas csak olvasasra O WRONLY nyitas csak rasra O RDWR nyitas olvasasra es rasra A tovabbi felhasznalhato szimbolumok: O APPEND Megadasa eseten minden rasi m}uveletet megel}oz}oen a le-pozcio a le vegere lesz alltva. O CREAT Ha a le nem letezik, akkor letre kell hozni. O EXCL Ha a le letezik es O CREAT kerelem volt, hibaval ter vissza. O TRUNC Ha a le letezik, akkor levagja 0 hosszusagura. O BINARY A le-t binaris kezelesi modban nyitja meg. O TEXT A le-t szoveges kezelesi modban nyitja meg. A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 182 Ha a mode argumentum tartalmazza O CREAT-ot, akkor az attrib ertekei: S IWRITE S IREAD S IREADjS IWRITE Visszat%

er% esi % ert% ek: engedelyezes rasra engedelyezes olvasasra engedelyezes rasra es olvasasra A le-lero sikeres vegrehajtas eseten, egyebkent -1. Portabilit
as: UNIX kompatibilis. perror stdio.h Rendszer hibauzenetet ad. void perror(const char *s) Megjegyz
es: Az stderr periferiara (altalaban a keperny}o) kirja az s sztringet, egy kett}ospontot es az errno tartalmanak megfelel}oen a legutoljara bekovetkezett rendszerhiba megnevezeset. Portabilit
as: ANSI C es UNIX kompatibilis. printf stdio.h Formattalt kimenet az stdout-ra. int printf(const char *format, .) Megjegyz
es: A format formatumsztringnek megfelel}oen konvertalja az argumentumait, es az gy nyert karaktereket az stdout periferiara kuldi. A formatumsztring ketfele informacioelemb}ol epul fel: egyszer}u karakterekb}ol (ezek valtoztatas nelkul kerulnek at a kimenetre), illetve konverzio-specikaciokbol (ezek a soronkovetkez}o argumentum megfelel}o

feldolgozasat es kiratasat rjak el}o). Reszletes ismertet}ot talalhatunk a printf fuggvenyr}ol a 1102-es szakaszban Visszat
er
esi
ert
ek: A kirt byte-ok szama, hiba eseten EOF. Portabilit
as: ANSI C es UNIX kompatibilis. WINDOWS-ban nem hasznalhato putc stdio.h Karaktert r ki egy folyam-jelleg}u le-ba. #include <stdio.h> int putc(int c, FILE *stream)
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI Megjegyz
es: Makro, amely kirja a manyba. c karaktert a 183 stream le-mutatoju allo- Visszat
er
esi
ert
ek: A kirt karakter, hiba eseten EOF. Portabilit
as: ANSI C es UNIX kompatibilis. putchar stdio.h Karaktert r az stdout peirferiara. #include <stdio.h> int putchar(int c) Megjegyz
es: Makro, amely megfelel a putc(c, stdout) hvasnak. Visszat
er
esi
ert
ek: A kirt karakter, hiba eseten EOF. Portabilit
as: ANSI C es UNIX kompatibilis. puts stdio.h Karakterlancot r ki az stdout periferiara. #include <stdio.h>

int puts(const char *s) Megjegyz
es: Az s karakterlancot rja ki az stdout folyamba, es automatikusan kiegeszti egy ujsor karakterrel (n n). Visszat
er
esi
ert
ek: Sikeres kiras eseten pozitv ertek, egyebkent EOF. Portabilit
as: ANSI C es UNIX kompatibilis. qsort stdlib.h Tomb rendezese gyorsrendez}o (quicksort) algoritmussal. #include <stdlib.h> void qsort(void *base, size t nelem, size t width, int (*fcmp)(const void , const void )) Megjegyz
es: Tetsz}oleges elemekb}ol allo tomb rendezeset vegzi a felhasznalo altal biztostott osszehasonlto fuggveny segtsegevel. Az egyes parameterek: base nelem width fcmp Az adott tomb kezd}ocme a tomb elemeinek szama a tombelemek merete sizeof egysegben pointer az osszehasonlto fuggvenyre A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 184 Az osszehasonlto fuggvenyt a qsort ket pointerrel hvja meg, amelyek egyegy elemre mutatnak. A fuggvenynek a kovetkez}o

ertekeket kell szolgaltatnia: < 0, ha az els}o pointer mutatta argumentum kisebb a masodiknal ha a ket elem megegyezik > ha az els}o pointer mutatta argumentum nagyobb a masodiknal. Portabilit
asi: ANSI C es UNIX kompatibilis. == 0, 0, rand stdlib.h Veletlenszam-generator. #include <stdlib.h> int rand(void) Visszat
er
esi
ert
ek: Az alveletlen szam 0 es RAND MAX kozott. Portabilit
as: ANSI C es UNIX kompatibilis. random stdlib.h Veletlenszam-generator. #include <stdlib.h> int random(int num) Visszat
er
esi
ert
ek: 0 es (num-1) kozotti veletlenszam. Portabilit
as: BORLAND C++ specikus, ez a fuggveny megtalalhato a Turbo Pascal-ban is. read io.h Alacsony szint}u le-olvasas. #include <io.h> int read(int handle, void *buf, unsigned len) Megjegyz
es: len byte-ot olvas a handle-vel azonostott le-bol buf-ba. Visszat
er
esi
ert
ek: A sikeresen beolvasott byte-ok szama. File-veg eseten 0, hiba eseten -1.

Portabilit
as: UNIX kompatibilis. realloc stdlib.h, alloch Modostja a malloc, illetve a calloc altal lefoglalt memoriablokkot.
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 185 #include <stdlib.h> void *realloc(void block, size t size) Megjegyz
es: A block argumentum mutat az el}oz}oleg lefoglalt memoriateruletre, amelyet size meret}ure kell modostani. Ha a blokkot novelni kell, akkor szukseg eseten a regi blokk tartalmat atmasolja az uj helyre. Visszat
er
esi
ert
ek: A memoriaterulet cme, amely kulonbozhet block-tol. Ha a kert noveles nem teljesthet}o, NULL ertekkel ter vissza. Portabilit
as: ANSI C es UNIX kompatibilis. scanf stdio.h Olvassa es formazza az stdin bemenetet. #include <stdio.h> int scanf(const char *format, .) Megjegyz
es: Karaktereket olvas a szabvanyos bemenetr}ol es azokat a format formatumsztring szerint megprobalja ertelmezni es konvertalas utan tarolni. Reszletesebb lerast talalhatunk a scanf

fuggvenycsaladrol a 1.102-es reszben Visszat
er
esi
ert
ek: A sikeresen beolvasott es eltarolt tetelek szama. File-veg olvasasa eseten EOF-ot ad vissza. Portabilit
as: ANSI C es UNIX kompatibilis. setbuf stdio.h Egy folyamhoz rendelt buer meretet alltja be. #include <stdio.h> void setbuf(FILE *stream, char buf) Megjegyz
es: Kozvetlenul a stream megnyitasa utan hvhato meg. Az adatok buerelesere a buf memoriaterulet hasznalatat rja el}o, az automatikusan lefoglalt buer helyett. Portabilit
as: ANSI C es UNIX kompatibilis. setmode A le kezelesi modjat alltja at. #include <fcntl.h> int setmode(int handle, int mode) Megjegyz
es: a mode erteke az alabbi lehet: io.h A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 186 binaris text (szoveg) tpusu. Visszat
er
esi
ert
ek: nulla, ha sikeres a vegrehajtas. O BINARY O TEXT Portabilit
as: UNIX kompatibilis. setvbuf stdio.h A folyam buereleset rja el}o. #include

<stdio.h> int setvbuf(FILE *stream, char *buf, int type, size t size) Megjegyz
es: size meret}u buert r el}o a stream folyam szamara, type bufferelesi eljaras mellett. Ha buf == NULL, akkor automatikusan foglal buert, egyebkent a megadott buert hasznalja. A type erteke parameter az alabbi lehet: IOFBF teljesen puerelt folyam IOLBF sorpuerelt folyam IONBF nem puerelt folyam Visszat
er
esi
ert
ek: nulla, ha sikeres. Portabilit
as: ANSI C es UNIX kompatibilis. sin math.h, complexh Szinusz erteket szamol. Real verzi
o: < > #include math.h double sin(double x) Komplex verzi
o: < > #include complex.h double sin(complex x) Visszat
er
esi
ert
ek: x szinusza. Portabilit
as: A fuggveny valos valtozata ANSI C es UNIX kompatibilis, a komplex valtozata csak C++-ban hasznalhato. sinh math.h, complexh Szinusz hiperbolikusz erteket szamol. Real verzi
o: Komplex verzi
o: < > #include math.h double sinh(double x) < >

#include complex.h double sinh(complex x) Visszat
er
esi
ert
ek: sinh(x). Portabilit
as: A fuggveny valos valtozata ANSI C es UNIX kompatibilis, komplex valtozata csak C++-ban hasznalhato.
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI spawn. 187 process.h Ez egy fuggvenycsalad. Az itt szerepl}o fuggvenyek arra szolgalnak, hogy egy adott program kezdemenyezhesse egy masik program (subprocess, child process) operatv tarba valo behvasat es futtatasat. #include <process.h> #include <stdio.h> int spawnl(int mode, char *path, char *arg0, char *arg1, ., char *argn, NULL) int spawnle(int mode, char *path, char *arg0, char *arg1, ., char *argn, NULL, char *envp"]) int spawnlp(int mode, char *path, char *arg0, char *arg1, ., char *argn, NULL) int spawnlpe(int mode, char *path, char *arg0, char *arg1, ., char *argn, NULL, char *envp"]) int spawnv(int mode, char *path, char argv"]) int spawnve(int mode, char *path, char argv"], char

*envp"]) int spawnvp(int mode, char *path, char argv"]) int spawnvpe(int mode, char *path, char argv"], char *envp"]) Megjegyz
es: A spawn. csalad gyerekfolyamatkent (child process) betolt es futtat egy adott programot. A spawn fuggveny nevehez adott karakterek jelentese: p a le-t az aktualis DOS konyvtaron kvul a PATH kornyezeti valtozoban megadott konyvtarakban is keresi, l arg0, arg1, . reket, argn felsorolasaval adjuk at a gyereknek a paramete- A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 188 az argumentumokra mutato pointerek az argv" ] tombben kerulnek atadasra, NULL-pointerrel lezarva (akkor celszer}u, ha az argumentumok szama futas kozben d}ol el), e a k ornyezeti valtozokat tartalmazo pointertomb is atadasra kerul. A tomb utolso eleme kotelez}oen NULL. Param
eterek: v a m}ukodesi modot hatarozza meg a betoltend}o gyerekprogramot tartalmazo le neve A mode parameter erteke az alabbi

lehet: mode path a szul}ofolyamat felfuggesztve, mg a gyerek fut, a szul}o es a gyerek parhuzamosan futnak (nem alkalmazhato DOS alatt) P OVERLAY a gyerekfolyamat felulrja a szul}o altal elfoglalt memoria-teruletet. Visszat
er
esi
ert
ek: hiba eseten -1, egyebkent a gyerekfolyamat altal visszaadott statuszkod. Sikeres P OVERLAY eseten nem ter vissza P WAIT P NOWAIT Portabilit
as: A spawn fuggvenyek DOS specikusak. Az exec fuggvenycsalad nev-kiterjesztese es parameterezese olyan, mint a spawn fuggvenycsalad tagjaie, hvasuk szintaktikailag UNIX kompatibilis, vegrehajtasi modjuk DOS specikus. sprintf stdio.h Formatalt kimenetet r egy sztringbe. int sprintf(char *buffer, const char format, .) Megjegyz
es: Megegyezik a print fuggvennyel, de a kimenetet a buffer memoriateruleten helyezi el. Visszat
er
esi
ert
ek: a kirt byte-ok szama a lezaro EOS karakter nelkul. Portabilit
as: ANSI C es UNIX kompatibilis. sqrt math.h,

complexh Negyzetgyokot szamol. Real verzi
o: < > #include math.h double sqrt(double x) Komplex verzi
o: < > #include complex.h double sqrt(complex x) Visszat
er
esi
ert
ek: az x negyzetgyoke. Portabilit
as: A fuggveny valos valtozata ANSI C es UNIX kompatibilis, a komplex valtozata csak C++-ban hasznalhato.
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI srand 189 stdlib.h Inicializalja a veletlenszam generatort. #include <stdlib.h> void srand(unsigned seed) Megjegyz
es: a seed ertekevel a veletlenszam generatornak uj kezd}oerteket adhatunk. Portabilit
as: ANSI C es UNIX kompatibilis. sscanf stdio.h Sztringb}ol formattalt adatot olvas. #include <stdio.h> int sscanf(const char *buffer, const char *format, .) Megjegyz
es: Megegyezik az scanf fuggvennyel, de a bemenetet a buffer altal megadott memoriateruletr}ol veszi. Visszat
er
esi
ert
ek: a sikeresen beolvasott es tarolt mez}ok szama. Portabilit
as: ANSI C es

UNIX kompatibilis. strcat string.h Sztringhez egy masik karakterlancot f}uz. #include <string.h} char *strcat(char dest, const char src) Megjegyz
es: Az src sztringet hozzamasolja a dest vegehez. Visszat
er
esi
ert
ek: Az osszef}uzott sztringre mutato pointer. Portabilit
as: ANSI C es UNIX kompatibilis. strchr string.h Egy sztringben adott karakter els}o el}ofordulasat keresi. #include <string.h> char *strchr(const char s, int c) A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 190 Visszat
er
esi
ert
ek: a c karakter s-beli els}o el}ofordulasi helyere mutato pointer. Ha c nem talalhato s-ben, NULL ertekkel ter vissza. Portabilit
as: ANSI C es UNIX kompatibilis. strcmp string.h Ket sztringet hasonlt ossze. #include <string.h> int strcmp(const char *s1, const char s2) Visszat
er
esi
ert
ek: negatv, ha s1 < s2, nulla, ha s1 s2. == s2 es pozitv, ha s1 > Portabilit
as: ANSI C es UNIX kompatibilis. strcpy string.h Egy

sztringet masikba masol. #include <string.h> char *strcpy(char dest, const char src) Megjegyz
es: Az src sztringet masolja a dest sztringbe a lezaro EOS karakterrel bezarolag. Visszat
er
esi
ert
ek: dest. Portabilit
as: ANSI C es UNIX kompatibilis. strdup string.h Sztringet masol egy dinamikusan foglalt tarteruletre. #include <string.h> char *strdup(const char s) Visszat
er
esi
ert
ek: A masolatra mutato pointer, ill. teruletfoglalas. NULL, ha nem sikerult a Portabilit
as: UNIX kompatibilis. stricmp Ket sztringet hasonlt ossze, kis- es nagybet}uket azonosnak veve. #include <string.h> int stricmp(const char *s1, const char s2) string.h
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI Visszat
er
esi
ert
ek: negatv, ha s1 < s2, nulla, ha s1 s2. 191 == s2 es pozitv, ha s1 > Portabilit
as: DOS specikus. strlen string.h A sztring hosszat adja meg. #include <string.h> size t strln(const char *s) Visszat
er
esi
ert
ek:

az s sztring hossza a lezaro EOS karakter nelkul. Portabilit
as: ANSI C es UNIX kompatibilis. strlwr string.h Egy sztring nagybet}uit kisbet}ukre csereli le. #include <string.h> char *strlwr(char s) Visszat
er
esi
ert
ek: s. Portabilit
as: DOS specikus. strncat string.h Maximalt hosszusagu karakterlancot f}uz egy sztringhez. #include <string.h> char *strncat(char dest, const char src, size t maxlen) Megjegyz
es: A src karakterlancbol maximum sztring vegehez. Visszat
er
esi
ert
ek: maxlen karaktert f}uz a dest dest. Portabilit
as: ANSI C es UNIX kompatibilis. strncmp  Osszehasonl t ket maximalt hosszusagu karakterlancot. #include <string.h> int strncmp(const char *s1, const char *s2, size t maxlen) string.h A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 192 Megjegyz
es: Megegyezik strcmp-rel, de mindket sztringb}ol maximum maxlen karaktert vesz gyelembe. Visszat
er
esi
ert
ek: negatv, ha s1 < s2, nulla, ha s1 s2.

== s2 es pozitv, ha s1 > Portabilit
as: ANSI C es UNIX kompatibilis. strncpy string.h Maximalt hosszu sztring masolasa. #include <stdio.h> char *strncpy(char dest, const char *src, size t maxlen) Megjegyz
es: A src sztringb}ol maximum maxlen karaktert masol at dest-be. Visszat
er
esi
ert
ek: dest. Portabilit
as: ANSI C es UNIX kompatibilis. strnset string.h Egy sztring els}o n karakteret feltolti adott c ertekkel. #include <string.h> char *strnset(char s, int c, size t n) Visszat
er
esi
ert
ek: s. Portabilit
as: DOS specikus. strrchr string.h Egy sztringben adott karakter utolso el}ofordulasat keresi. #include <string.h> char *strrchr(const char s, int c) Visszat
er
esi
ert
ek: a c karakter s-beli utolso el}ofordulasi helyere mutato pointer. Ha c nem talalhato s-ben, NULL ertekkel ter vissza Portabilit
as: ANSI C es UNIX kompatibilis. strrev string.h Helyben megfordt egy sztringet, az EOS karaktert helyen hagyva.


FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 193 #include <string.h> char *strrev(char s) Visszat
er
esi
ert
ek: Pointer a megfordtott sztringre. Portabilit
as: DOS specikus. strset string.h Egy adott karakterrel feltolt egy sztringet. #include <string.h> char *strset(char s, int c) Visszat
er
esi
ert
ek: s. Portabilit
as: DOS specikus. strstr string.h Egy sztringben adott reszlanc els}o el}ofordulasat keresi. #include <string.h> char *strstr(const char s1, const char s2) Visszat
er
esi
ert
ek: az s2 reszlanc s1-beli els}o el}ofordulasi helyere mutato pointer. Ha s1 nem talalhato s2-ben, NULL ertekkel ter vissza Portabilit
as: ANSI C es UNIX kompatibilis. strupr string.h Egy sztring kisbet}uit nagybet}ukre csereli le. char *strupr(char s) Visszat
er
esi
ert
ek: s. Portabilit
as: DOS specikus. system stdlib.h, processh Az operacios rendszer egy parancsat hajtja vegre. int system(const char *command) A. FUGGELE
K INCLUDE

FILE-OK E
S FUGGVE
NYEK 194 Megjegyz
es: Behvja DOS COMMAND.COM le-t, hogy vegrehajtsa a sztringben megadott DOS parancsot. command Visszat
er
esi
ert
ek: nulla, ha sikeres a vegrehajtas, kulonben -1. Portabilit
as: ANSI C es UNIX kompatibilis. A WINDOWS-ban nem hasznalhato tan math.h, complexh Tangens erteket szamol. Real verzi
o: < > #include math.h double tanh(double x) Komplex verzi
o: < > #include complex.h double tanh(complex x) Visszat
er
esi
ert
ek: tan(x) Portabilit
as: A fuggveny valos valtozata ANSI C es UNIX kompatibilis, a komplex valtozata csak C++-ban hasznalhato. tanh math.h, complexh Tangens hiperbolikusz erteket szamol. Real verzi
o: Komplex verzi
o: < > #include math.h double tanh(double x) < > #include complex.h double tanh(complex x) Visszat
er
esi
ert
ek: tanh(x) Portabilit
as: A fuggveny valos valtozata ANSI C es UNIX kompatibilis, a komplex valtozata csak C++-ban hasznalhato.

tell io.h Lekerdezi az aktualis le-pozciot. #include <io.h> long tell(int handle) Visszat
er
esi
ert
ek: az aktualis le-pozcio, hiba eseten -1. Portabilit
as: UNIX kompatibilis. time time.h Az aktualis id}ot kerdezi le. #include <time.h> time t time(time t *timer)
FUGGVE
NYEK A.1 FONTOSABB KONYVTARI 195 Megjegyz
es: az 1970. januar elseje ota eltelt id}ot adja meg masodpercben *timer-ben. Visszat
er
esi
ert
ek: az id}o masodpercekben. Portabilit
as: ANSI C es UNIX kompatibilis. toascii ctype.h ASCII karakterre alakt. #include <ctype.h> int toascii(int c) Megjegyz
es: Az also 7 bit kivetelevel torli c osszes bitjet. Visszat
er
esi
ert
ek: a c konvertalt erteke. Portabilit
as: UNIX kompatibilis. tolower ctype.h Kisbet}ure alakt. #include <ctype.h> int tolower(int c) Megjegyz
es: Olyan makrokent van megvalostva, amely az argumentumat ketszer ertekeli ki. Visszat
er
esi
ert
ek: c konvertalt erteke.

Portabilit
as: ANSI C es UNIX kompatibilis. toupper ctype.h Nagybet}ure alakt. #include <ctype.h> int toupper(int c) Megjegyz
es: Olyan makrokent van megvalostva, amely az argumentumat ketszer ertekeli ki. Visszat
er
esi
ert
ek: c konvertalt erteke. Portabilit
as: ANSI C es UNIX kompatibilis. A. FUGGELE
K INCLUDE FILE-OK E
S FUGGVE
NYEK 196 ungetc stdio.h Egy karaktert r vissza az input folyamba. #include <stdio.h> int ungetc(int c, FILE *stream) Visszat
er
esi
ert
ek: A c karakter, hiba eseten EOF. Portabilit
as: ANSI C es UNIX kompatibilis. write io.h Alacsony szint}u le-ras. #include <io.h> int write(int handle, void *buf, unsigned len) Megjegyz
es: len byte-ot r a handle-vel azonostott le-ba buf-bol. Visszat
er
esi
ert
ek: A sikeresen kirt byte-ok szama, hiba eseten -1. Portabilit
as: ANSI C es UNIX kompatibilis. Irodalomjegyz
ek 1] B. W Kernighan D M Ritchie A C programozasi nyelv M}uszaki

Konyvkiado., 1985 Forditotta Dr Siegler Andras 2] BORLAND C++. Programmers Guide Borland International, Inc, 1991 Version 2.0 3] BORLAND C++. Library Reference Borland International, Inc, 1991 Version 2.0 4] B. Stroutstrup The C++ programming language Addison-Wesley, 1986 5] M. A Ellis B Stroutstrup The Annotated C++ Reference Manual AddisonWesley, 1990 197