„Programozás C nyelven” változatai közötti eltérés
Tartalom törölve Tartalom hozzáadva
Nincs szerkesztési összefoglaló |
rendes szakaszok, egyéb formai javítások az →Iterációk: előttig |
||
1. sor:
== Az első C program ==
Tekintsük a következő egyszerű C nyelven írt programot:
<source lang="c">
#include <stdio.h>
main()
<
A program kimenete az idézőjelek között szereplő felirat, a kurzor pedig a következő soron áll.
Nézzünk néhány megjegyzést a fenti programmal kapcsolatban:<br />
# A C program belépési pontját a <source lang="c" inline="1">main()</source> függvényhívás azonosítja. Egyelőre a függvényt argumentumok nélkül hívtuk meg, a későbbiekben ennek részletezésére még kitérünk.
# A <code>{</code> és <code>}</code> a kezdő és a végpontját jelölik a végrehajtási résznek.
# <source lang="c" inline="1">#include <stdio.h></source> nélkül nem működne a printf() függvény.
# A printf()-ben a kiírandó szöveget dupla idézőjelek közé kell tennünk. Vegyük észre azt is, hogy a \n karakter nem került kiírásra. Tehát a printf() külön tartalmazza a kiírandó szöveget és a kiírást befolyásoló változókat. Ami a dupla idézőjelek között megjelenik változtatás nélkül kiírásra kerül, kivétel ez alól a \ és % karaktereket követő jel, vagy a jelsorozat. A \n változó a fordító számára azt jelenti, hogy a következő karakter kiírása előtt új sort kell kezdenie.
# A parancsokat a ; zárja le.
== 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.
<source lang="c">
/* ez most egy egysoros megjegyzés */
/* ez most
több soros
megjegyzés */
</source>
== 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:
* csak betűket, számjegyeket és aláhúzás karaktert tartalmazhat
* betűvel kell kezdődnie
* hossza legfeljebb 32 karakter (implementációfüggő)
A változódeklaráció szabálya C-ben a következő:
<pre>Típus nev1,nev2,…;</pre>
Például:
<source lang="c">
int s;
float f,k;
</source>
Egy változót kezdőértékkel is elláthatunk.
<source lang="c">
int s=10;
<
Nézzük a következő C programot:
<source lang="c">
#include <stdio.h>
main()
{
int sum;
sum = 500 + 15;
printf("500 és 15 összege %d\n", sum);
}
</source>
A programban létrehoztunk egy egész típusú változót, majd egy összeget rendeltünk hozzá. Figyeljük meg a változó kiíratását! Az idézőjelek között most találkozunk először a % jellel. Mögötte kell megadnunk, hogy erre a helyre milyen típusú változó kerül kiírásra. A d betű az egész típusra utal. Az idézőjel után következik a változó neve. Ennek értéke kerül majd beírásra a szövegbe.
Az adatoknak a C-ben négy alaptípusa van: egész (int), karakter (char), valós (float, double).
Az alaptípusokat elláthatjuk módosító jelzőkkel is, ekkor az értékkészlet módosul.
Pl.
<source lang="c">
int a;
unsigned int b;
</source>
Az első esetben az a értéke –32768 és 32767 között lehet, míg a második esetben a b értéke 0 és 65535 közötti szám lehet. A signed módosító jelző is használható, de alapértelmezés szerint minden egész változó ilyen lesz.
A következő táblázatban felsoroltunk néhány típust, értékkészletükkel együtt.
{| class="wikitable"
! Adattípus !! Értékkészlet !! Méret (byte) !! Pontosság (tizedesjegy)
|-
| char || -128..127 || 1 || rowspan="6" | (egész)
|-
| unsigned char || 0..255 || 1
|-
| int || -32768..32767 || 2
|-
| unsigned int || 0..65535 || 2
|-
| long int || -2147483648..2147483647 || 4
|-
| unsigned long int || 0..4294967295 || 4
|-
| float || 3.4e-38..3.8e+38 || 4 || 6
|-
| double || 1.7e-308..1.7e+308 || 8 || 15
|-
| long double || 3.4e-4932..3.4e+4932 || 10 || 19
|}
A printf() függvényben a változókat csak úgy tudjuk kiíratni, hogy az idézőjelek között % jel után megadjuk a változó típusát, a kiírás formátumát majd az idézőjelek után vesszőkkel elválasztva fölsoroljuk a változók neveit. A gyakrabban használt karaktereket a következő táblázatban soroltuk föl:
{| class="wikitable"
| %d || decimális egész
|-
| %u || előjel nélküli decimális egész
|-
| %f || lebegőpontos
|-
| %c || karakter
|-
| %s || sztirng vagy karaktertömb
|-
| %e || dupla valós
|}
Lehetőség van arra is, hogy meghatározzuk a változó értéke által elfoglalt mező szélességét. Nézzük a következő példákat:
<source lang="c">
int v1;
printf("…%5d", v1);
</source>
A v1 egész változó 5 karakter helyen jelenik meg.
<source lang="c">
float f1;
printf("…%5.2f", f1);
</source>
Az f valós változót 5 mezőre írja ki 2 tizedes pontossággal.
<source lang="c">
int v1, w = 10;
printf("…%*d", w, v1);
</source>
A * jelentése eben az esetben az, hogy a mezőszélességet az idézőjel utáni első változó határozza meg. Tehát a fenti példában a v1 egész változó 10 szélességű mezőre kerül kiírásra.
Ha egy változó karakter típusú, akkor értékét egyszeres idézőjelek között kell megadnunk.
<source lang="c">
char betu;
betu='A';
</source>
Egész típusú változónak adhatunk 16-os vagy 8-as számrendszerbeli értéket is.
<source lang="c">
int okt, hex;
okt = 0567;
hex = 0x2ab4;
hex = 0X2AB4;
</source>
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.
=== 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 szinonimával hivatkozni rá: Ennek a módja:<br />
\n új sor<br />
\t tabulátor<br />
123 ⟶ 159 sor:
<br />
<br />
3.,4.,5.,6. feladat
== Konstansok ==
A konstansok megadásának két módját ismertetjük az alábbiakban.
=== A const kulcsszó használatával ===
<syntaxhighlight lang="c">
const int a = 30;
</syntaxhighlight>
Ebben az esetben vigyázni kell arra, hogy a konstanst inicializáljuk is. Hibajelzést ad a következő deklaráció:
<syntaxhighlight lang="c">
a = 30;
</syntaxhighlight>
Az így létrehozott konstansok értéke közvetlenül nem változtatható meg. A konstanso, azonban a memóriában tárolódnak, így értékük közvetetten mutatók használatával módosítható.
=== 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őbbiekben még részletesen lesz szó. Most egyetlen példát nézzünk a konstansok megadására.
<syntaxhighlight lang="c">
#define ADO_KULCS 0.25
</syntaxhighlight>
Az így megadott konstansok a program listájának elején szerepelnek az #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ó.
== 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.
* Az operandusok száma szerint (egy, kettő, három operandus)
* Az operátor típusa szerint (aritmetikai, logikai, léptető, bitművelet, értékadó, feltételes)
* 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.
=== 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.
<syntaxhighlight lang="c">
int a=12, b=5;
float f;
f = a/b;
</syntaxhighlight>
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 sorrendje a matematikában megszokott.
=== Ö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: <code><, >, <=, >=, ==, !=</code>. 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 kifejezésekben gyakran összetett feltételeket is meg kell fogalmazni, erre szolgálnak a logikai operátorok. Ezek a következők: <code>!</code> a tagadás művelete, egyoperandusú. <code>&&</code> logikai és, <code>||</code> logikai vagy műveletek. A műveletek precedenciája a táblázatban.
=== 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. <code>++</code> eggyel növeli, <code>--</code> 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. (<code>a++</code> egyenértékű a <code>++a</code>-val) Ha azonban egy kifejezés kiértékelésében használjuk, akkor már óvatosabban kell bánni a két alakkal.
<syntaxhighlight lang="c">
int a=4, x, y;
x=++a;
y=a++;
</syntaxhighlight>
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 <code>a=a+1</code> értékadás, helyette minden esetben a léptetést használjuk.
=== 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ú. <code>~</code> 1-es komplemens, <code>&</code> bitenkénti és, <code>|</code> bitenkénti vagy, <code>^</code> 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. <code><<</code> eltolás balra, <code>>></code> eltolás jobbra. A felszabaduló pozíciókba 0 kerül, a kilépő bitek elvesznek. A műveletek két operandusúak. <code>a<<2</code> 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.
=== Értékadó operátorok ===
Az értékadás történhet a más nyelvekben megszokottak szerint.
<code>a=érték</code> vagy <code>a=kifejezés</code> formában
Van azonban olyan forma is, mely a hagyományos nyelvektől teljesen idegen.
<syntaxhighlight lang="c">
b=2*(a=4)+5;
</syntaxhighlight>
Ebben az esetben az a és a b változó is kap értéket. Az értékadás operátor mindig jobbról balra értékelődik ki, tehát a kiértékelés után a fenti kifejezésben a értéke 4, b értéke pedig 13 lesz. A kiértékelés ilyen sorrendje miatt van az, hogy a C-ben az összetett értékadás is működik.
<code>a=b=c=0</code> értékadás után mindhárom változó értéke 0 lesz.
Van az értékadásnak C-ben egy tömörebb formája is. Általános alakban a következőképpen írható le:
változó=változó op kifejezés helyett a változó op=kifejezés
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.
{| class="wikitable"
!Hagyományos forma
!Tömör forma
|-
| <pre>a = a + b</pre>
| <
|-
| <pre>a = a - b</pre>
| <pre>a -= b</pre>
|-
| <pre>a = a * b</pre>
| <pre>a *= b</pre>
|-
| <pre>a /= b</pre>
|-
| <pre>a = a % b</pre>
| <pre>a %= b</pre>
|-
a=a<
a=a>>b
</pre>
| <pre>a >>= b</pre>
|-
| <pre>a = a & b</pre>
| <pre>a &= b</pre>
|-
| <pre>a = a | b</pre>
| <pre>a |= b</pre>
|-
| <pre>a = a ^ b</pre>
| <
|}
=== Feltételes operátor ===
A C-ben ez az egyetlen operátor, melynek három operandusa van. Általános alakja a következő:
<pre>kifejezés1 ? kifejezés2 : kifejezés3</pre>
Itt először a kifejezés1 értékelődik ki, ha ennek értéke nem 0, azaz IGAZ, akkor a kifejezés2 adja a feltételes kifejezés értékét, különben pedig a kifejezés3. A feltételes kifejezés típusa mindig a kifejezés2 és kifejezés3 típus közül a nagyobb pontosságú típusával egyezik meg.
A következő példában c értéke a és b közül a kisebbel lesz egyenlő.
<syntaxhighlight lang="c">
c = a < b ? a : b;
</syntaxhighlight>
=== 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. <code>&</code> a címe operátor.
<syntaxhighlight lang="c">
int a, *ptr;
ptr = &a;
</syntaxhighlight>
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.
<code>*ptr = 5</code> egyenértékű az <code>a=5</code> értékadással.
=== 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:
<pre>(típusnév) kifejezés</pre>
Az implicit konverzióval kapcsolatban elmondhatjuk, hogy általában a szűkebb operandus információveszteség nélkül konvertálódik a szélesebb operandus típusára.
<syntaxhighlight lang="c">
int i, j;
float f, m;
m = i + f;
</syntaxhighlight>
Ebben az esetben az i float-ra konvertálódik.
<syntaxhighlight lang="c">
j = i + f;
</syntaxhighlight>
Itt viszont vigyáznunk kell, mert adatvesztés lép fel, az összeg törtrésze elveszik.
Explicit konverziót kell végrehajtanunk a következő példában, ha f-be nem csak az egész osztás hányadosát szeretnénk betenni.
<syntaxhighlight lang="c">
int a = 12, b = 5;
float f;
f = (float) a / (float) b;
</syntaxhighlight>
A következő táblázatban összefoglaltuk az említett műveleteket precedenciájuk szerint rendezve. Valamint a kiértékelés sorrendjét is megadtuk. A kiértékelés sorrendje akkor kerül előtérbe, ha egy kifejezésben egyenlő precedenciájú operátorok szerepelnek zárójelezés nélkül.
{| class="wikitable"
!Operátor
!Kiértékelés sorrendje
|-
|! ~ - ++ -- & * (típus)
|Jobbról balra
|-
|/ &
|Balról jobbra
|-
| + -
|Balról jobbra
|-
|<< >>
|Balról jobbra
|-
|< <= > >=
|Balról jobbra
|-
|== !=
|Balról jobbra
|-
|&
|Balról jobbra
|-
|^
|Balról jobbra
|-
|<nowiki>|</nowiki>
|Balról jobbra
|-
|&&
|Balról jobbra
|-
|<nowiki>||</nowiki>
|Balról jobbra
|-
|?:
|Balról jobbra
|-
|= += -= *= /= %=
<<= >>= &= |= ^=
|Jobbról balra
|}
== 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ő:
<pre>scanf(formátum, argumentumlista)</pre>
A scanf karaktereket olvas a billentyűzetről, majd a formátum alapján értelmezi azokat, ha a beolvasott karakterek megfelelők, akkor konvertálja őket. Ha az input valamilyen ok miatt nem felel meg a formátum előírásainak, akkor a scanf befejezi az olvasást, még akkor is, ha az argumentumlista szerint további karaktereket is be kellene olvasnia. A scanf függvénynek visszatérési értéke is van. A sikeresen beolvasott adatok számát adja vissza. Nézzünk néhány példát a scanf használatára.
<syntaxhighlight lang="c">
int a;
char c;
printf("Kérek egy egész számot és egy betűt");
scanf("%d%c", &a, &b);
</syntaxhighlight>
A példából látszik, hogy az egyszerű adatokat cím szerint kell beolvasni. Az argumentumlistában az &a és az &c a változók memóriabeli címére utal. A formátumban ugyanazokat a karaktereket használhatjuk, mint a printf esetében korábban tettük. Ez a sor egy számot és egy karaktert olvas be egymás után, nem tesz közéjük semmilyen elválasztó jelet. Nyilván, ha egy scanf-fel több értéket is akarunk beolvasni, akkor valamilyen határolóra szükség van.
<syntaxhighlight lang="c">
int a;
char c;
printf("Kérek egy egész számot és egy betűt vesszővel elválasztva");
scanf("%d,%c", &a, &b);
</syntaxhighlight>
Figyeljük meg a változtatást. A formátumban egy vesszőt tettünk a második % jel elé. Ilyenkor a scanf beolvassa a vesszőt is, de azt nem tárolja. Ilyen módon bármilyen határoló karaktereket előírhatunk beolvasáskor.
A scanf segítségével sztringeket is olvashatunk be. Ebben az esetben nem használjuk az & operátort.
<syntaxhighlight lang="c">
char sz[30];
scanf("%s", sz);
</syntaxhighlight>
A scanf egy hasznos lehetősége, hogy az adatok szűrését is lehetővé teszi. Az előbbi deklaráció szerinti sz változó értéke csak számjegy, vagy hexadecimális jegy lehet, akkor azt a következő szűréssel valósíthatjuk meg:
<syntaxhighlight lang="c">
scanf("%[0-9a-fA-F]", sz);
</syntaxhighlight>
A komplementer halmaz megadására is van módunk:
<syntaxhighlight lang="c">
scanf("%[^0-9]", sz);
</syntaxhighlight>
Ezzel a szűréssel csak betűk kerülhetnek a sztringbe.
== 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égrehajtjá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:<br />
{<br />
utasítás1;<br />
354 ⟶ 481 sor:
}<br />
<br />
11., 12., 13. feladat
== 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)<br />
<br />
428 ⟶ 554 sor:
}<br />
Figyeljük meg, hogy minden választás után használtuk a break-et. A default után nem használtuk, de ha a switch elején van, akkor ott is érdemes odafigyelni rá.<br />
14., 15., 16., 17., 18., 20. feladat
== 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)<br />
<br />
571 ⟶ 696 sor:
}<br />
}<br />
27. feladat
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.<br />
<br />
611 ⟶ 736 sor:
adatszerkezettel dolgozhatunk. Az adatszerkezet egyes elemeire való hivatkozáskor a struktúra és a tömb hivatkozásokat vegyesen alkalmazzuk.<br />
sz[2].szev=1961;<br />
28. feladat
Függvényeket a következő esetekben szokás írni:
A függvény defníció általános alakja:<br />
visszatérési_érték_típus fvnév (típus1 vált1,típus2 vált2,……)<br />
740 ⟶ 865 sor:
<br />
}<br />
A programot vizsgálva adóthat az az ötletünk, hogy a tömb méretét fölösleges volt átadni a függvénynek, azonban ez sajnos nem igaz. A függvény fejében lévő int a[0] ugyanis csak annyit közöl a fordítóval, hogy egy egészeket tartalmazó vektor fog jönni paraméterként.
A C programozási nyelvben van egy különös
int a=3,b, *p; /* a pegy egész típusú változóra mutató pointer */<br />
p=&a; /* p az a címét veszi föl értékként */<br />
1 091 ⟶ 1 216 sor:
}<br />
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.<br />
35. feladat
== Fájlkezelés ==
A C nyelvben
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)<br />
<br />
1 128 ⟶ 1 253 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.<br />
<br />
""2.13.2 Szöveges állományok''<br />''
Szöveges állományokkal kapcsolatban leggyakrabban alkalmazott függvényeket az alábbi táblázatban foglajuk össze. Minden esetben a<br />
FILE *fp;<br />
1 253 ⟶ 1 378 sor:
Az fread függvény hasonlóképpen paraméterezhető. Eltérés abban van hogy beolvasáskor nyilván a változó címét kell megadni a függvénynek, a másik három paraméter ugyanaz. Természetesen mindkét függvénynek van visszatérési értéke is. Mindkettőnél a sikeresen kiírt illetve beolvasott blokkok számát adja vissza. Ez az érték használható a sikertelen beolvasás illetve kiírás figyelésére. Ha a fenti programban a counter változó értéke nem egyenlő eggyel, akkor az azt jelenti, hogy nem sikerült beolvasni adatot az állományból. Ezeknek a változóknak a megadása nem kötelező, mint a fenti programból is látszik az fwrite függvényt enélkül hívtuk meg.<br />
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 .<br />
36., 37., 38. feladat
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ó.<br />
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:<br />
1 432 ⟶ 1 557 sor:
ultoa(lnumber,string,10); Előjel nélküli hosszú egészet alakít sztringgé<br />
<br />
39., 40. feladat
A grafikus függvénycsomagban jól használható
<br />
''2.15.1 Koordináta-rendszer''<br />
1 521 ⟶ 1 646 sor:
s a karakter méretét jelenti, ha 1 akkor 8x8 pixel, 2 esetén 16x16 pixel…<br />
<br />
41., 42., 43., 44., 45., 46. feladat
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.<br />
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<br />
1 584 ⟶ 1 709 sor:
A kiir() makró bármilyen olyan változónak kiírja az értéket, melynek a neve x-szel kezdődik. A név további részét paraméterként kell átadni.<br />
A szoveg() makró egyszerűen kiírja az átadott szöveget. Figyeljük meg, hogy híváskor nem kell a szöveget idézőjelek közétenni, azt a műveletet a változó neve elé kitett # végzi el.<br />
A szam() makró egy változó nevét és értékét írja ki olyan formátumban, aamilyet a második paramétere előír.
[[Kategória:Programozási nyelvek|C]]
| |||