„Programozás C nyelven” változatai közötti eltérés
Tartalom törölve Tartalom hozzáadva
a Bot: removing existed iw links in Wikidata |
Nincs szerkesztési összefoglaló |
||
21. sor:
6. A parancsokat a ; zárja le.
1., 2. feladat
'''
2.2 Megjegyzések'''
A megjegyzéseket a programszöveg magyarázatainak beírására szoktuk használni. Hibakereséskor is jó hasznát vehetjük azonban, ha a program egy részének végrehajtását szeretnénk kihagyni, akkor azt megjegyzés blokkba zárhatjuk.
/* ez most egy egysoros megjegyzés */
27 ⟶ 28 sor:
több soros
megjegyzés */
'''2.3 A változókról'''
A C típusos programnyelv. Ez azt jelenti, hogy mielőtt egy változót használni szeretnénk deklarálnunk kell azt. Figyeljünk arra, hogy a a fordítóprogram a változó nevekben is különbséget tesz a kis és a nagy betűk között.
A névre a következő megkötések érvényesek:
102 ⟶ 104 sor:
hex = 0X2AB4;
Minden változó esetén figyeljünk a kezdőérték megadására. Ha ezt nem tesszük meg, a változónak akkor is lesz kezdőértéke, de biztosan nem olyan, amit mi szerettünk volna adni.
'''
2.3.1 Felhasználói típus'''
Ha egy típus neve túl hosszú és gyakran használnunk kell a program során, akkor érdemes egy szinonímával hivatkozni rá: Ennek a módja:
\n új sor
118 ⟶ 121 sor:
3.,4.,5.,6. feladat
'''
2.4 Konstansok'''
A konstansok megadásának két módját ismertetjük az alábbiakban.
''
2.4.1 A const kulcsszó hazsnálatával''
const int a=30;
Ebben az esetben vigyázni kell arra, hogy a konstanst inicializáljuk is. Hiba jelzést ad a következő deklaráció:
129 ⟶ 133 sor:
a=30;
Az így létrehozott konstansok értéke közvetlenül nem változtatható meg. A konstansok, azonban a memórában tárolódnak, így értékük közvetetten mutatók használatával módosítható
''2.4.2 Az előfordítónak szóló helyettesítéssel''
Az előfordítónak különböző definíciókat, leírásokat adhatunk, erről a későbbikeben még részletesen lesz szó. Most egyetlen példát nézzünk a konstansok megadására
#define ADO_KULCS 0.25
Az így megadott konstansok a program listájának elején szerepelnek a #include beillesztések után. Szintaktikailag a # a sor első karaktere kell hogy legyen, az ilyen sorokat nem zárhatjuk pontosvesszővel, és minden sorban csak egy #define állhat. Mivel ezek a leírások az előfordítónak szólnak, ezért minden olyan helyen, ahol a programlistában az ADO_KULCS azonosító szerepel, az előfordító 0.25 értéket fog beírni. Ezért az így létrehozott konstansok értéke még indirekt módon sem változtatható.
'''2.5 Operátorok'''
A programok írása során gyakran van szükségünk kifejezések felépítésére, váltózónak történő értékadásra, számolási műveletekre, függvényhívásokra. A C nyelvben ezek a kifejezések oparandusok, függvényhívások és operátorok kombinációjából épülnek fel.
Az operátorokat többféle szempont szerint lehet csoportosítani.
141 ⟶ 147 sor:
• Az operátor helye szerint (prefix, postfix)
Itt az operátorokat a típusuk szerint tárgyaljuk, de említést teszünk a másik két szempontról is.
''
2.5.1 Aritmetikai operátorok''
A négy alapművelet, a szokásos szimbólumokkal, valamint a maradékos osztás % jellel. A művelet az osztás maradékát adja vissza, természetesen csak egész típusú változók használata esetén alkalmazható. A másik négy művelet mind egész, mind valós operandusok esetén is működik. Vigyázzunk a következőhöz hasonló esetekben.
int a=12,b=5;
148 ⟶ 155 sor:
A programrészlet után az f értéke a 2.000000 valós érték lesz. Tehát az eredmény típusát az operandusok típusa döntötte el.
A műveletek precedenciája a matematikában megszokott.
''
2.5.2 Összehasonlító és logikai operátorok''
Feltételekben és ciklusokban gyakran kell összehasonlítani különböző értékeket, ennek elvégzésére a hasonlító operátorokat használjuk. Ezek a következők: <,>,<=,>=,==,!=. Ha ezekkel két változót vagy kifejezést hasonlítunk össze, akkor az eredmény int típusú lesz, és értéke 1, ha a reláció igaz, illetve 0, ha hamis.
A logikai kfejezésekben gyakran összetett feltételeket is meg kell fogalmazni, erre szolgálnak a logikai operátorok. Ezek a következők: ! a tagadás művelete, egyoperandusú. && logikai és, || logikai vagy műveletek. A műveletek precedenciája a táblázatban.
''
2.5.3 Léptető operátorok''
A változó értékének eggyel való növelésére, vagy csökkentésére szolgálnak. Egyoperandusú műveletek. Postfix és prefix alakban is írhatók. ++ eggyel növeli, -- eggyel csökkenti a változó értékét. Ha egy kifejezésben csak egy változó szerepel, akkor mindegy, hogy postfixes, vagy prefixes alakját használjuk az operátoroknak. (a++ egyenértékű a ++a-val) Ha azonban egy kifejezés kiértékelésében használjuk, akkor már óvatosabban kell bánni a két alakkal.
int a=4,x,y;
158 ⟶ 167 sor:
A programrészletben az első értékadás előtt az a értéke 1-gyel nő 5 lesz, ezt kapja az x változó, tehát annak értéke is 5 lesz, a második értékadásban az y megkapja a pillanatnyi értékét az ötöt, majd az a értéke 1-gyel nő, azaz 6 lesz. Az operátorok mind egész, mind valós operátorokkal működnek.
C-ben nem szokás az a=a+1 értékadás, helyette minden esetben a léptetést használjuk.
''2.5.4 Bitműveletek''
A műveletek operandusai csak char, short, int és long típusú előjel nélküli egészek lehetnek.
A műveletek első csoportja két operandusú. ~ 1-es komplemens, & bitenkénti és, | bitenkénti vagy, ^ bitenkénti kizáró VAGY. Ezeket a műveleteket leggyakrabban maszkolásra, vagy bitek törlésére szoktuk használni. A kizáró VAGY érdekes tulajdonsága, hogy ha ugyanazt a maszkot kétszer alkalmazzuk egy értékre, akkor visszakapjuk az eredeti értéket.
A műveletek másik csoportjába a biteltoló műveletek tartoznak. << eltolás balra, >> eltolás jobbra. A felszabaduló pozíciókba 0 kerül, a kilépő bitek elvesznek. A műveletek két operandusúak. a<<2 az a változó bitjeit 2-vel tolja balra. Nyilvánvalóan az n bittel való balra tolás 2n-nel való szorzást, míg az n bittel való jobbra tolás 2n-nel való egészosztást eredményez.
''
2.5.5 Értékadó operátorok''
Az értékadás történhet a más nyelvekben megszokottak szerint.
a=érték, vagy a=kifejezés formában
184 ⟶ 195 sor:
Ez a forma általában gyorsabb kódot és áttekinthetőbb listát eredményez. A C programokban természetesen mindkettő forma használható, de igyekezzünk a másodikat előnyben részesíteni. A mellékelt táblázatban összefoglaljuk ezeket a rövidített értékadásokat.
''2.5.6 Feltételes operátor''
A C-ben ez az egyetlen operátor, melynek három operandusa van. Általános alakja a következő:
kifejezés1 ? kifejezés2 : kifejezés3
190 ⟶ 201 sor:
A következő példában c értéke a és b közül a kisebbel lesz egyenlő.
c = a < b ? a : b
''2.5.7 Pointer operátorok''
A mutatókról az eddigiek során még nem volt szó, de a teljesség kedvéért megemlítünk két egyoperandusú műveletet, mely a mutatókhoz (pointerek) kötődik. & a címe operátor.
int a , *ptr;
196 ⟶ 208 sor:
Ebben a példában a ptr egy egész típusú változóra mutat, értékadásnál pedig az a változó memóriabeli címét kapja meg. Ha erre a címre új értéket akarunk írni, akkor a * (indirekt hivatkozás) operátort kell használnunk.
*ptr = 5 egyenértékű az a=5 értékadással.
''2.5.8 Típuskonverziók''
A C-ben kétfajta típuskonverzió létezik, az implicit (automatikus) és az explicit. Az első a C nyelvbe rögzített szabályok szerint történik a programozó beavatkozása nélkül, a második pedig a típuskonverziós operátor segítségével. Ennek általános alakja:
(típusnév) kifejezés
230 ⟶ 243 sor:
7.,8.,9. feladat
'''2.6 Adatok beolvasása a billentyűzetről'''
A formázott adatbeolvasást a scanf függvény segítségével tehetjük meg. A függvény általános formája a következő:
scanf(formátum, argumentumlista)
254 ⟶ 268 sor:
10. feladat
'''2.7 Iterációk'''
Mint minden magas szintű programozási nyelvben a C-ben is vannak olyan utasítások, melyek egy feltételtől függően többször is végrhajtják ugyanazt az utasítást, vagy utasítás blokkot. A következőkben ahol utasítást írunk helyettesíthető utasításblokkal is. Utasításblokk:
{
262 ⟶ 277 sor:
utasításn;
}
'''2.7.1 while ciklus'''
A while ciklus általános alakja:
while (kifejezés)
288 ⟶ 304 sor:
while((ch=getch()) !=27);
Az ESC billentyű leütésére vár
''2.7.2 for ciklus''
A for ciklust a leggyakrabban akkor használjuk, ha előre tudjuk, hogy egy utasítást hányszor akarunk végrehajtani. Az utasítás általános alakja egyszerű formában a következő lehet:
for ( kifejezés1;kifejezés2;kifejezés3)
308 ⟶ 325 sor:
for (i=1,osszeg=0;i<=n;osszeg+=i++);
Itt feltétlenül kell egy ; az utasítás végére, ezzel jelezzük, hogy a for ciklus csak egy üres utasítást tartalmaz. Vigyázzunk azonban, ha egy egyéb uatsításokat tartalmazó for ciklusban erre a helyre ;-t teszünk meglepődve tapasztalhatjuk, hogy a ciklusmag többi utasítása nem fog végrehajtódni.
''2.7.3 do-while ciklus''
Ezt a ciklust igen ritkán használjuk. Minden programozási feladat megoldható az előző két ciklus alkalmazásával, van azonban néhány olyan feladat, mely rövidebb kódot eredményez, ha a do-while ciklust használjuk. (Pl. a bináris keresés) A ciklus általános alakja:
do
335 ⟶ 353 sor:
11., 12., 13. feladat
'''
2.8 Szelekciók'''
A C nyelvben három elágazás típust használhatunk. Az egyágú (if szerkezet), a kétágú (if-else szerkezet) és a többágú (switch szerkezet)
''2.8.1 if utasítás''
Az utasítás általános alakja:
if (kifejezés)
356 ⟶ 376 sor:
}
''2.8.2 if-else szerkezet''
Az utasítás általános alakja:
if (kifejezés)
368 ⟶ 388 sor:
Ezt a két sort az előző programban az üres sor helyére kell beszúrni. Vigyázzunk azonban, ebben az esetben a Jó érték sorának végén nem állhat ; ugyanis ekkor egy else kulcsszóval találkozna a fordító, amivel viszont nem kezdődhet parancs.
''2.8.3 switch utasítás''
Az utasítás több irányú elágazást tesz lehetővé, de csak abban az esetben, ha egy egész kifejezés értékét több konstanssal kell összehasonlítani. Általános alakja:
switch (kifejezés)
407 ⟶ 427 sor:
14., 15., 16., 17., 18., 20. feladat
'''2.9 Tömbök'''
Az eddigiek során olyan változókat használtunk csak, melyek egy érték tárolására voltak alakalmasak. Gyakran van azonban szükségünk arra, hogy ugyanazzal a változónévvel több értékre is tudjunk hivatkozni. Ebben az esetben haszáljuk a tömböket. (Egy osztály minden tanulójához hozzárendeljük a magasságát, ilyenkor nyilván érdemes változónévként az osztály azonosítóját használni, a tanulókra pedig a napló sorszámával)
2.9.1 Egydimenziós tömbök
441 ⟶ 462 sor:
printf(”\n Az összeg: %d”,s);
}
''2.9.2 Sztringek''
A C-ben nincs külön sztring típus, ezért az egy dimenziós tömböket gyakran használjuk sztringek definiálására. Tulajdonképpen a sztring egy egydimenziós karaktertömb lesz. A sztring végét egy \0 karakter fogja jelezni, ezért ha egy 10 hosszúságú sztringet szeretnénk kezelni, akkor azt feltétlenül 11 hosszúságúra kell létrehoznunk.
char sztring[11];
510 ⟶ 532 sor:
21., 22., 23., 24., 25., 26. feladat
''2.9.3 Kettő és több dimenziós tömbök''
A C nyelvben is lehetőségünk van kettő vagy több dimenziós tömbök használatára. Deklarálni a következőképpen kell:
típus név [méret1] [méret2] …;
547 ⟶ 569 sor:
27. feladat
'''2.10 Felhasználó által definiált típusok'''
Az előző részben említett összetett adattípust tömböknek neveztük, a tömbök minden eleme azonos típusú kell hogy legyen. Gyakran szükségünk van azonban olyan egymással összetartozó elemek tárolására is, melyek nem azonos típusúak, mégis egy egyedre jellemzők. Ezket leggyakrabban adatbázisokban találjuk meg. Gondoljunk itt egy személy kereszt és vezetéknevére, születési idejére, alapfizetésére. Ezek különböző típusú adatok mégis ugyanarra a személyre vonatkoznak.
''2.10.1 Struktúrák''
Egy ilyen adattípust valósítanak meg a struktúrák. Ennek deklarációja általános formában:
struct név {
576 ⟶ 599 sor:
Ebben az estben természetesen a változó típusának megadásakor is hiányzik a struct.
szemely sz;
''2.10.2 Struktúrát tartalmazó tömbök''
Ha egy struktúra típusú változót létrehoztunk, akkor annak segítségével csak egyetlen egyed jellemzőit tudjuk tárolni. Mit tehetünk, ha több egyedről is ugyanazokat a jellemzőket szeretnénk raktározni? Kézenfekvő megoldás olyan tömbök alkalmazása, melynek minden egyes eleme az adott struktúra típusú.
Az előző példánál maradva egy vállalatnak maximálisan 20 dolgozójáról a fenti adatokat szeretnénk tárolni, akkor a
584 ⟶ 609 sor:
28. feladat
'''2.11 Függvények'''
Függvényeket a következő esetekben szokás írni:
• Ha ugyanazt a tevékenységsorozatot többször is el kell végeznünk ugyanolyan típusú, de más-más értéket fölvevő változókkal.
627 ⟶ 652 sor:
Vegyük észre azt is, hogy a függvénynek nincs visszatérési értéke, annak ellenére, hogy az átadott változók értéke megváltozott.
29., 30., 31. feladat
''2.11.2 Lokális és globális változók''
A lokális változókat csak azok a blokkok látják, ahol deklarálva lettek, ez alól a main sem kivétel. Ezek a változók a veremben tárolódnak, tehát minden függvényhíváskor törlődik az értékük.
A globális változókat minden függvény látja, értéküket módosíthatja. Ezeket a változókat minden függvény törzsén kívül kell deklarálni, célszerű rögtön a #define után megtenni ezt. Ajánlott a globális változókat egy tömbben deklarálni, lehetőség van ugyan arra, hogy két függvény között is deklaráljunk változót, ebben az esetben viszont az előbb lévő függvény nem látja az alatta lévő változót, annak ellenére sem, hogy az függvényeken kívül lett létrehozva.
''2.11.3 Automatikus és statikus változók''
Bevezetésként tanulmányozzuk a következő programot:
#include <stdio.h>
666 ⟶ 693 sor:
A statikus változókat csak egyszer hozza létre a fordító és értéket is csak egyszer kapnak, a legelső függvényhíváskor. Statikus változót lokálisan és globálisan is létrehozhatunk, értékét a program futása során végig megtartja, a különbség a kettő között csak a láthatóságban van. A lokálisan létrehozott statikus változó csak a blokkján belül látható. A fenti program egy lokális satikus változót mutatott be.
Az automatikus változók minden függvényhíváskor újra deklarálódnak, és mindig fölveszik a megadott kezdőértéket. Ha nem írjuk ki ezeket a módosító jelzőket, akkor a változó autmatikus lesz. Az automatikus változók dinamikusan tárolódnak a veremben.
''2.11.4 Register módosító jelző''
A register kulcsszó azt jelenti a fordító számára, hogy az adott változóhoz gyorsan szeretnénk hozzáférni. Arra utasítjuk tehát, hogyha módjában áll, akkor ne a memóriában, hanem regiszterekben tárolja. Nyilván akkor folyamodunk ilyen technikához, ha úgy gondoljuk,hogy az adott változót gyakran módosítjuk. Regiszterbe char, int és pointer típust tehetünk az esetek többségében.
Arra semmi garancia nincs, hogy a fordító tudja teljesíteni kérésünket, de ha tudja, akkor az eredmény gyorsabb futás lesz.
676 ⟶ 704 sor:
*b=s;
}
''2.11.5 Vektor átadása függvénynek''
A következő példa bemutatja, hogy egy vektort hogyan adhatunk át paraméterként egy függvénynek. A függvény az átadott vektor legnagyobb elemével tér vissza.
#include <stdio.h>
734 ⟶ 763 sor:
A mutatóknak nem ez a bűvészkedés adja a jelentőségét. Segítségükkel dinamikusan kezelhetjük a memóriát, mindig csak annyit használva, amennyire az adatoknak éppen szüksége van.
32. feladat
''2.12.1 Vektorok és mutatók''
A C programozási nyelvben igen szoros kapcsolat van a a vektorok és az egyszeres indirektségű mutatók között. Ez a vektorok tárolási módjából ered. A vektorok a memóriában sorfolytonosan helyezkednek el. Ha egy pointert a vektor első elemére irányítunk, akkor a pointer aritmetika szabályai szerint ehhez 1-et hozzáadva a vektor második elemét fogjuk megkapni.
int *p,a[10];
790 ⟶ 820 sor:
Figyeljük meg a p-nek történő értékadást! A calloc függvény visszatérési értéke egy típus nélküli mutató, ezt egy típuskonverzióval át kellet alakítani a p típusának megfelelő alakra. Minden esetben meg kell vizsglni, hogy sikeres volt-e a helyfoglalás. Ha nincs elég memória, akkor a calloc függvény NULL (nulla) értékkel tér vissza, ebben az esetben a return –1 hatására a program kilép a main() függvényből és befejezi futását.
A programban a pointeres és tömbös hivatkozás vegyesen lett használva, mutatva ezzel a kettő teljes egyenértékűségét.
''
2.12.2 Kétdimenziós tömbök és pointerek''
Természetesen két dimenziós tömböket is lehet dinamikusan kezelni. Erre három különböző módszert mutatunk be. Mindhárom program csupán annyit csinál, hogy egy mátrixot feltölt véletlen számokkal, majd táblázatos formában megjeleníti. A programok után rövid magyarázatok is lesznek.
''2.12.2.1 Dinamikus tömb egy vektorban''
#include <stdio.h>
#include <conio.h>
835 ⟶ 867 sor:
hely=aktuális_sor*oszlopszám+aktuális_oszlop
formulával határoztuk meg. Figyeljünk föl itt is a két fajta hivatkozásra!
''2.12.2.2 Konstansban megadott tömbméret, dinamikus helyfoglalással''
#include <stdio.h>
#include <conio.h>
875 ⟶ 908 sor:
}
Ebben az esetben futási időben nincs már lehetőségünk a tömb méreteinek változtatására, de ahelyfoglaás itt is csak futási időben történik meg. A hivatkozás majdnem teljesen olyan, mint a mátrixok esetében szokásos. Itt a calloc függvényben érdekes módon csak 1 elem számára kell helyet foglalni, ami viszont akkora, mint a tljes mátrix.
''2.12.2.3 Mutatótömb''
#include <stdio.h>
#include <conio.h>
925 ⟶ 959 sor:
Itt a mátrixot egy mutatótömbbel valósítottuk meg. A különlegesség az, hogy a sorok eltérő hosszúságúak is lehetnek. A mutatóknak egyesével adtunk értéket, azaz a helyfoglalás soronként történt. A felszabadítást szintén ciklus segítségével kell végezni.
33., 34. feladat
''2.12.3 Struktúrák és mutatók''
A korábbiakban már volt szó a strutúrákról. Pointerekkel hivatkozhatunk a struktúrk egyes elemeire is, mint azt a következő példában láthatjuk.
struct datum
935 ⟶ 970 sor:
map->ev=2001;map->ho=2;map->14;
A két hivatkozás egymással teljesen egyenértékű, de a C programokban és a szakirodalomban a második lényegesen elterjedtebb.
''2.12.4 Dinamikus lista''
A lista olyan adtaszerkezet, melynek minden egyes eleme két jól elkülöníthető részből áll, az adatrészből és egy mutatóból, mely a lista következő elemére mutat. A lista első elemére a listafejjel hivatkozhatunk. A lista utolsó elemének mutató mezője pedig NULL értékű.
1 051 ⟶ 1 087 sor:
A főprogramban lévő while ciklussal pozitív számokat olvasunk be, és ezeket fűzzük föl egy dinamikus listába. Látszik, hogy a listában mindig csak a következő elem számára foglalunk helyet a malloc függvénnyel. A lista feltöltése után meghívott list() függvény a fölvett elemeket listázza ki.
35. feladat
'''
2.13 File kezelés'''
A C nyelvben aza datállományokat tartalmuk alapján két csoportra oszthatjuk, szöveges és bináris állományokra. A szöveges állományok olvasható információt tartalmaznak. Sorokból épülnek fel, minden sor végét a CR/LF karakterpár zárja.A bináris állományok byte-okból felépülő adtahalmazt jelentenek. A szöveges állomány minden esetben földolgozható, mint bináris állomány, de ez fordítva már nem igaz.
Szöveges állományokban is lehet számokat tárolni. Ebben az esetben a számok, mint karakterek fogan tárolódni. Ha például egy négy jegyű számot szöveges állományban tárolunk, akkor négy byte-nyi helyet foglal el, ha azonban egy bináris állományba tesszük le, akkor csak 2 byte kell. (Természetesen csak akkor, ha int típusú volt)
''2.13.1 File előkészítése, lezárása''
A file kezeléshez tartozó függvények az stdio.h deklarációs állományban vannak leírva. Minden file-hoz hozzá kell rendelni egy FILE típusú muatatót, mely a memóriában a file jellemzőire mutat . Ennek formája:
FILE *fp;
1 084 ⟶ 1 122 sor:
}
Ha a file-on elvégeztük a megfelelő műveleteket akkor le kell zárni. Ezt az fclose(fp) függvényhívás valósítja meg. Amennyiben egy filban írási műveletekt is végeztünk lezárás előtt célszerű az fflush(fp) függvényhívás, ez az átmeneti pufferek tartalmát kiírja az állományba, ha még nem történt volna meg.
''
2.13.2 Szöveges állományok''
Szöveges állományokkal kapcsolatban leggyakrabban alkalmazott függvényeket az alábbi táblázatban foglajuk össze. Minden esetben a
FILE *fp;
1 164 ⟶ 1 203 sor:
}
}
''2.13.3 Bináris állományok''
A bináris állományokat byte-onként vagy blokkonként kezelhetjük. A byte-onkénti kezeléshez jól használható az előző részben leírt fgetc és fputc függvénypáros. A blokkonkénti kezelést pedig az fread és az fwrite függvényekkel végezhetjük el.
Használatukat a következő példában figyelhetjük meg.
1 208 ⟶ 1 248 sor:
A progarmban van még egy újdonság, az állományban való pozícionálás. Erre az fseek függvényt használjuk. Paraméterezése: első paraméter a file mutató, második a blokkméret és egy egész szám szorzata (ennyiedik elemre fogunk állni), harmadik pedig azt mutatja meg, hogy mihez viszonytjuk a pozícionálást. SEEK_CUR esetén a pillanatnyi pozícióhoz, SEEK_SET esetén pedig a file elejéhez. Vigyázzunk azonban ennek az alakalmazásával, a sorszámozás most is a nulladik elemtől kezdődik, ennek a SEEK_SET esetén lehet jelentősége. A pillanatnyi pozícióval pedig az a helyzet, hogy amikor egy adat beolvasása megtörtént, akkor a file mutató rögtön eggyel tovább lép, tehát, ha a szomszédos elemre akarunk lépni, akkor természetesen a fseek-ben 0-t kell adnunk a második paraméter helyén .
36., 37., 38. feladat
'''
2.14 A szöveges képernyő kezelése'''
A Turbo C a képernyőt grafikus és szöveges üzemmódban működtethető. Mindkét üzemmódban nagyon sok függvényt segít változatosabbá tenni a képernyőt ebben a fejezetben a szöveges üzemmód függvényeiről lesz szó.
Ha ezeket a függvényeket ahsználni szeretnénk, akkor a program elején a következő header file-okra lesz szükségünk:
1 215 ⟶ 1 256 sor:
#include <ctype.h>
Valójábana képernyőt kezelő függvények az elsőben vannak deklarálva, de képernyőn sztringekkel és karakterekkel dolgozunk, ezért szinte mindig szükségünk van a másik ekttőre is. A sztring kezelő függvényekről korábban már volt szó ezt még ebben a fejezetben kiegészítjük néhány konverziós függvénnyel és a gyakrabban hasznát karakter kezelő függvényeket is fölsoroljuk.
''2.14.1 Szöveges üzemmódban gyakran használt függvények:''
Név Leírás Név Leírás
cprintf() Formázott kivitel, hasonló a printf-hez clreol() sor törlése az aktuális kurzor pozíciótól
1 303 ⟶ 1 345 sor:
}
Tanulmányozzuk át figyelmesen a programot! Vegyük észre, hogy szöveg kiírására a cputs gyanolyan alkalmas, minta cprintf! A valasz beolvasásakor találunk egy olyan függvényt, mely az eddigiekben még nem szerepelt, isdgit(valasz), visszatérési értéke nem nulla, ha a valasz értéke számjegy.
''2.14.2 Képernyő mentése és vissztöltése''
Egy jól használható lehetősége a szöveges képernyőkezelő függvényeknek az ablak teljes egészének, vagy egy részletének elmentése, majd visszatöltése a memóriába. A következő program erre muata egy példát:
#include <conio.h>
1 336 ⟶ 1 379 sor:
''2.14.3 Néhány karaktert tesztelő makró''
Minden makró argumentumában char típusú változó szerepel és mindegyik visszatérési értéke int.
Makró Leírás Makró Leírás
1 353 ⟶ 1 396 sor:
tolower Az angol nagybetűket kis betűkké alakítja
''
2.14.5 Néhány konverziós függvény''
Függvény példával Leírás
1 382 ⟶ 1 426 sor:
39., 40. feladat
'''2.15 A grafika programozása'''
A grafikus függvénycsomagban jól használható függvénxek csoportja áll rendelkezésünkre ahhoz, hogy egyszerűbb pixel grafikus ábrákat készítsünk. Valójában minden alakzat, amit a képernyőn megjelenítünk a putpixel függvényre támaszkodik, de a rajzolás megkönnyítése érdekében sok grafikus primitív áll rendelkezésünkre. (egyenes, kör téglalap, ellipszis, ív stb rajzolása) Ha a grafikus függvényeket használni akarjuk, akkor be kell emelni graphics.h header file-t. Grafika programozásánál gyakran használjuk a matematikai függvényeket is, ezért általában az elején hozzátesszük a programhoz a math.h állományt is.
''2.15.1 Koordináta-rendszer''
Mielőtt hozzáfognánk a grafika programozásához meg kell ismernünk a rendszer által alkalmazott grafikus koordináta-rendszert.
1 406 ⟶ 1 452 sor:
trafoxy(&x,&y);
Ha egy grafikus függvény szögekkel dolgozik, akkor azt fokokban kell megadni, a matematikában megszokott körüljárás szerint.
''2.15.2 Grafika indítása''
Mielött garfikai függvényeket használnánk elő kell készítenünk a képernyőt. Ennek módját mutatjuk meg az alábbiakban.
#include <conio.h>
1 431 ⟶ 1 478 sor:
}
DETECT segítségével földerítjük az aktuális monitor jellemzőit, majd inicializáljuk a grafikát, az idézőjelek között a BGI file-ok helyét kell megadnunk a programnak, ezen állományok segítik a képernyő grafikus üzemmódban való kezelését. A graphresult() függvény jelzi, ha valami miatt nem sikerült az áttérés grafikus módra. Ha minden rendben volt következhetnek a grafikai függvényhívások, (itt ezt a rectangle() függvény jelzi), ha végeztünk, akkor pedig a closegraph(); függvénnyel lezárjuk a grafikát.
''2.15.3 Gyakran használt függvények''
Az alábbiakban egy táblázatban soroljuk föl a leggyakrabban használt grafikus függvényeket, a teljesség igénye nélkül. (A rendszerben közel 80 grafikus függvény van)
Függvény Leírás
1 466 ⟶ 1 514 sor:
41., 42., 43., 44., 45., 46. feladat
'''2.16 Makrók'''
A makrók a függvény kódjába beépített szövegeket jelentenek a C nyelv esetében. Makrók segítségével egyszerű, gyakran alkalmazott műveleteket oldhatunk meg függvények megírása nélkül. C nyelvi makrókat a #define direktíva után adhatunk meg. Ezt a direktívát használtuk már korábban kostansok létrehozására.
Az így létrehozott konstansok futásidőben már nem változtahatók . A fordítónak az az első dolga, hogy a forrásnyelvi állományt átadja az előfeldolgozónak. Az előfeldolgozó feladata, hogy a #define után talált szövegeket behelyettesítse a forrásprogram azon részébe, ahol hivatkozás történt rájuk. Az előfeldolgozónak lehet, hogy többszö is végig kell menni a listán, mivel a makrók minden további nélkül egymásba ágyazhatók
''
2.16.1 Függvényszerű makrók''
A definíció általános alakja:
#define azonosító(paraméterek) helyettesítő szöveg
| |||