3− 4 feladat — 90 perc
Mi a feladat?
Írj függvényt:
bool prim(int n) {
...
}Írj programrészt:
int x, y;
scanf("%d", &x);
...
printf("%d", y);Írj programot:
#include <stdio.h>
int main(void) {
...
}Mit kell hozni?
Általános tudnivalók?
Itt elérhető: a számonkérésekről általában.
Látjuk, hogy a tömb és az index együtt megjelölnek egy double típusú változót
a memóriában. A szamok[idx] kifejezésben a szamok mondja meg, melyik
tömbről van szó, és a idx pedig azt, hogy annak hányadik eleméről.
Az index önmagában kevés (melyik tömbről van szó?), a tömb megjelölése is kevés (annak hányadik eleméről van szó?)
ahhoz, hogy egy konkrét elemet hivatkozzunk. Mindkettőre szükség van.
tömb és index → hely
Fölmerülhet a kérdés, van-e esetleg olyan eszközünk, amely önmagában képes lenne egy
bizonyos tömbelem meghivatkozására. Ha lenne egy ilyen eszközünk, akkor megoldhatnánk az előző keresős feladatot úgy is,
hogy a kereső függvény egy hivatkozással tér vissza: hivatkozással a megtalált double típusú tömbelemre.
Ezt a gondolatmenetet általánosítani is tudjuk: egy olyan eszközt szeretnénk, amellyel tetszőleges változót megjelölhetünk, hivatkozhatunk, legyen az akár egy tömb valahányadik eleme, vagy egy önálló változó.
mágikus valami → hely
Mint az mindjárt kiderül, C-ben van ilyen. scanf("%lf", &x); – ismerős ez az első óráról?
Itt pontosan ez történik; egy double típusú változót jelölünk meg a scanf számára, hogy oda
írja a beolvasott számot.
Nézzünk meg részletesen az új nyelvi elem működését! Miért hívjuk címeknek is a pointer típusú változókban tárolt értékeket?
A számítógép memóriájának rekeszei, bájtjai meg vannak számozva. A processzor, amikor szeretne egy változóban tárolt értéket kiolvasni, vagy szeretné módosítani azt, akkor a változó helyét jelző memóriacím (memory address) segítségével hivatkozza meg. Innen tudja a memória, hogy melyik tárolt bájtot kell előszednie, vagy hogy hova tegye a megjegyzendő adatot.
Amikor pointereket használunk a programunkban, tulajdonképp ezekkel a címekkel dolgozunk. A pointer belső ábrázolása egyszerűen
a memóriacím. Az &x (address of x) kifejezéssel tudhatjuk meg egy változó memóriabeli helyét: azt a címet kapjuk
meg ezáltal, ahova a fordító a memóriában elhelyezte az x változót. Ez hasonló értelmű, mint a hétköznapi értelemben
vett postai cím. Ez mutatja a postásnak, hogy hol van az a hely, ahova a levelet vinnie kell.
A memóriacím akár eltárolható egy változóban is, aminek természetesen mutató (pointer) típusúnak kell lennie. Az előző
példához hasonlóan, a következő kódrészletben is ilyen van. A ptr nevű változó, amely double* típusú
mutató lévén, pont ilyet tud tárolni, azt, hogy mi a címe a program valamelyik double típusú változójának.
double x;
double *ptr;
ptr = &x; // cím képzése
*ptr = 3.14; // a mutatott változó
Az utolsó sor *ptr kifejezése a ptr által mutatott változót adja. A kifejezés kiértékelése során a
ptr nevű változóból kiolvasódik a memóriacím, utána pedig az így kapott memóriacím által hivatkozott helyen tárolt
változóval dolgozunk tovább, mintha csak az eredeti nevén neveztük volna. Mivel a ptr a fenti példában az
x változóra mutat a ptr = &x értékadás miatt (lásd a rajzot), *ptr-t írva tulajdonképp
az x-ről beszélünk. A címet gyakran hivatkozásnak, referenciának (reference) is szokás nevezni. Ezért mondják a
* operátorra, hogy dereferál (dereference); általa már a mutatott változót látjuk.
Figyeljük meg, hogy a * karaktert a fenti kódban két helyen is használjuk. Egyrészt deklaratív helyen, vagyis egy
változó típusának megadásakor, másrészt kifejezésben. Deklaratív helyen, azaz a double *ptr sorban a *
azt jelenti, hogy a nevezett ptr változó egy pointer lesz. Kifejezésben pedig, a *ptr = 3.14 jelentése
az, hogy a címet tartalmazó ptr változót dereferáljuk, és az általa mutatott memóriahellyel dolgozunk, oda írjuk be a
számot. A két jelentés persze nincs távol egymástól: az előbbinél megmondjuk, hogy hogyan fogjuk használni ptr-t, az
utóbbi pedig a konkrét használata.
Egy értékadásnál és egy inicializálásnál viszont ez elég nagy különbséget jelent. A fenti *ptr = 3.14; sorban a
pointer által mutatott helyen tárolt double változó kap új értéket; ott a * a meglévő pointer
dereferálását jelenti. Ha lenne egy double *ptr = &x; sorunk, abban a létrejövő pointert inicializálnánk úgy, hogy
az x változóra mutasson. Tehát a * a létrejött változó típusát adja meg ebben az esetben, és a létrejövő
pointer kap értéket. Megtévesztő lehet, mert mindkét sorban szerepel a *ptr = karaktersorozat... Ezt meg kell szokni.
Az elején sokat segít, ha külön sorba írjuk a pointer létrehozását és a változóra mutatást, ahogy a fenti példában is szerepel.
Az említett két operátor, a * dereferáló és az & címképző operátor
precedenciája viszonylag magas. A jobb oldalon álló (indexelő [], függvényhívó () stb.) operátorokénál
alacsonyabb, azonban minden kétoperandusú aritmetikai műveletnél (pl. +, - stb.) magasabb.
A precedencia fogalmáról egy másik előadásban van szó.
Lényegében azt adja meg, melyik operátor és operandus tartozik össze. Mint ahogy matematikában a szorzás és az összeadás: a 3
+ 4 * 5 kifejezésben a szorzás „erősebb”, magasabb a precedenciája, ezért 3 + (4 * 5)-ként értelmezzük.
Mutató típusú változók
Pointer típusú változót úgy definiálunk, hogy a definícióban egy *-ot teszünk a változó neve elé, mint pl. a
double *p; sorban. A pointer típusához hozzátartozik a mutatott változó típusa is, hiszen az általa mutatott hely
hivatkozásakor tudnia kell a fordítónak azt, hogy milyen típusú érték található ott – egyáltalán hány bájtból álló adatot kell
kezelni. A pointer a program futása során tetszőlegesen másik változókra állítható át, ha azok a változók megfelelő típusúak. A
fenti példában a mutató típusa double*, ezért a program bármelyik double típusú változójának címét
tárolhatná. A pointer típusú változó maga is egy teljesen szokványos változóként viselkedik: értéket kell adni neki használat
előtt! A pointerek pedig a szokványos módon átadhatók függvénynek paraméterként, és lehetnek függvények visszatérési értékei
is.
Címek és mutatott értékek: példaprogram
Az alábbi programban a p pointert hol az egyik, hol a másik változóra állítjuk be.
Így a *p kifejezés kiértékelésével hol az egyiket, hol a másikat érjük el.
#include <stdio.h>
int main(void) {
double x = 5.6;
double y = 10.9;
double *p;
p = &x;
printf("p = %p \n", (void*)p);
printf("*p = %g \n", *p);
printf("\n");
p = &y;
printf("p = %p \n", (void*)p);
printf("*p = %g \n\n", *p);
return 0;
}p=0x7fff48732580 *p=5.6 p=0x7fff48732588 *p=10.9
Egy pointer értékét, amely a memóriacím maga (vagyis a fenti példában az
x és y helye a memóriában), a printf()-fel a %p
konverzióval lehet kiírni. Ez akkor lehet jó, ha a programunkban hibát keresünk. A
pointer értéke egyébként általában nem más, mint egy szám, a hivatkozott memóriarekesz sorszáma.
A legújabb fordítók warning üzenetet adnak, ha printf %p-hez tartozó pointer nem void* típusú.
Ezért szükséges a kézi típuskonverzió a fenti kódban.
Ugyan a scanf %p képes beolvasni egy pointert, de azzal sokra
nem megyünk. Nincs értelme pl. kiírni egy fájlba egy pointert és újra használni a program későbbi
újrafuttatásánál, hiszen minden egyes futtatáskor máshova kerülhetnek a memóriában a változók.
Próbáld ki, futtasd le többször a fenti programot!
Mire jók ezek a mutatók? Például ezekkel el tudjuk érni azt, hogy a függvények módosítani tudják a nekik átadott változók értékét.
Legyen a feladatunk egy olyan függvényt írni, amely két egész típusú változó tartalmát megcseréli.
void csere(int a, int b) {
int temp;
temp = a;
a = b; // nem x és y változik!
b = temp;
}
int main(void) {
int x = 3, y = 4;
csere(x, y);
printf("%d,%d", x, y); // 3,4
}érték szerinti paraméterátadás
void csere(int *pa, int *pb) {
int temp;
temp = *pa;
*pa = *pb; // x és y változik!
*pb = temp;
}
int main(void) {
int x = 3, y = 4;
csere(&x, &y);
printf("%d,%d", x, y); // 4,3
}cím szerinti paraméterátadás
Az első kódban egy hibás próbálkozás látható. Mint tudjuk, a C nyelvben érték szerinti paraméterátadás történik, ami azt
jelenti, hogy a függvény a hívás helyén megadott kifejezések értékét, kiszámított eredményét kapja meg. Emiatt a
csere(x, y) függvényhívás azt jelenti, hogy ki kell olvasni az x és y változók tartalmát, és
az ott tárolt számokat átadni a függvénynek. Nem a változókat, hanem a számokat! Az átadott két szám, a 3 és a 4 a két
paraméterbe, azaz a két lokális változóba másolódik, amelyek tartalmát pedig a függvény hiába cseréli meg. Az két másik változó,
amelyeknek a módosítása nincs hatással az eredeti két változó értékeire.
A második függvény már működik, mert az indirekciót használ. Ez azt jelenti, hogy a híváskor a függvény nem a változók értékét, hanem a változók helyét, azaz címét kapja meg paraméterként. Tehát a hívással nem két számot adunk neki, hanem rámutatunk két rekeszre a memóriában: „az egyik változó itt található a memóriában, a másik ott, ezek tartalmát cseréld meg!” Így nem jön létre a hívás idejére két új egész típusú változó, hanem a függvény a hívó által megadott két eredeti változón dolgozik.
A második függvényben a paraméterek típusai: int*. Ez az előzőek alapján egy int változó
helyére mutat a memóriában, máshogy fogalmazva, a mutatott változó címét tárolja. A függvény ezen a mutatón
keresztül közvetetten, indirekt módon látja az eredeti változót.
A fenti módszert legtöbbször pongyolán cím szerinti paraméterátadásnak nevezzük. Azonban tudni kell, igazából
ilyenkor is érték szerinti paraméterátadás történik. A csere() függvény ilyenkor is mindent másolatként kap; annak a
pa nevű pointerében van egy másolat az x változó & operátor segítségével lekérdezett
címéről, a pb nevű paraméterben pedig egy az y változó lekérdezett címéről. Vagyis az &x
és &y kifejezések értékeit tárolják a pointerek, nem pedig a változók értékeit. Ezek viszont címként a
main() változóira mutatnak, a dereferálás után az eredeti x és y változókat lehet elérni és
akár megváltoztatni.
Nézzük meg egy kicsit alaposabban, mi is történik akkor, amikor egy tömböt átadunk egy függvénynek! Ilyenkor ugyanis nem a tömb adódik át paraméterként, hanem egy pointer.
Mivel a tömbelemek egymás után helyezkednek el a memóriában, a címeik kiszámíthatóak!
int tomb[5];
int *p1, *p2;
int tav;
p1 = &tomb[0]; // kezdőelem ptr
p1 = tomb; // így rövidítjük
p2 = &tomb[4] - 1; // tomb[4-1] címe
tav = p2 - p1; // távolság: 3
A pointeraritmetika azt jelenti, hogy memóriacímekkel végzünk számításokat. Ennek tömböknél van értelme, hiszen ezáltal a tömb kezdőcímének és a típusának ismeretében meghatározható az egyes elemek címe. (Ahogyan azt is meg tudjuk mondani, mi a szomszédos ház címe.) Ezt a kódban úgy jelöljük, hogy a pointerhez hozzáadunk egy egész számot – azt a számot, hogy a tömbben a címtől számítva hányadik elem címére vagyunk kíváncsiak. A hozzáadás a tömb vége felé, a kivonás a tömb eleje felé való mozgást jelent.
Két pointert akár ki is vonhatunk egymásból, hogy megkapjuk a közöttük lévő távolságot (ugrásszámot). Sőt még a
<=, > stb. operátorokat is használhatjuk. Természetesen ezeknek csak akkor van értelme, ha a két
pointer ugyanazon tömb belsejére mutat.
Emiatt is fontos a pointerek típusa. A típusból tudja a fordító, hogy az adott változó, amire a pointer mutat, hány bájtból áll.
Ha például a pointer egy 8 bájtos double típusra mutat, a p+1 azt jelenti, hogy 8 bájtot ad hozzá a
p pointer értékéhez. Ezzel azonban nekünk nem kell foglalkozni, a fordító ezt automatikusan megoldja a háttérben!
Nekünk csak arra kell gondolni, hogy p+1 a következő double címe, p+2 az azt követő címe
stb. A bájtok számolgatását végző kódért a fordító felel.
Tudni kell azt, hogy egy önálló int változóra mutató int *p pointer esetén is
helyes szintaktikailag a p+1, a *(p+1) és a p[1] kifejezés. Vagyis a program lefordítható,
csak szemantikailag helytelen. Ugyanis nem tudhatjuk, hogy milyen változót helyezett el a fordító az adott egész után, vagy van-e
ott egyáltalán változó. Ilyen hibákat elkövetve a tömb túlindexeléséhez hasonló misztikus hibákat és programlefagyásokat
kelthetünk.
Térjünk vissza a tömbben keresős függvényünkre! A megtalált
szám megjelölését egy pointerrel is megoldhatjuk. A tömb double elemeket tartalmaz,
ezért a függvény visszatérési értéke egy double* típusú pointer lesz:
double *hol_van(double *tomb, int meret, double keresett) {
for (int idx = 0; idx < meret; ++idx)
if (tomb[idx] == keresett)
return &tomb[idx]; // !
return NULL; // !
}Ezzel megvalósítottuk a függvényt olyan formában, ahogy az ötletünk adta. A visszatérési értéke egy pointer (figyelem:
double* van a függvény neve előtt, ott a * is!), amelyik belemutat a tömbbe, rámutat a megtalált elemre.
Használni pedig így kell majd:
int main(void) {
double szamok[5] = { 4.5, 9.2, 7.1, -6.9, 8 };
double *ptr = hol_van(szamok, 5, -6.9);
if (ptr != NULL) {
printf("%p helyen, értéke: %f", (void*)ptr, *ptr); // !
*ptr *= -1;
} else {
printf("Nincs benne ilyen.");
}
}Ha ezek után módosítani szeretnénk a megtalált elemet, *ptr = 10.2 vagy hasonló kifejezéssel
megtehetjük. Ha pedig kíváncsiak vagyunk rá, hányadik indexű, a ptr - szamok pointeraritmetikai kifejezés megadja.
Látszik a fenti kódban, hogy lehetséges a pointereknél a „nem mutat sehova” eset megjelölése is.
Az ilyen az ún. null-pointer, amelynek a jelölése a forráskódban NULL.
NULL pointer: ami nem mutat sehova
int *ptr;
int i;
ptr = &i; // most az i-re mutat
*ptr = 5;
ptr = NULL; // most nem mutat sehovaA NULL pointer egy olyan mutatót jelent, amely nem mutat semmilyen
változóra. Bármilyen típusú pointer (int*, double*,
struct Pont* stb.) lehet NULL értékű.
NULL-e? Nem NULL-e?
if (ptr != NULL)
printf("Mutat vhova.\n");
if (ptr == NULL)
printf("Sehova sem.\n");if (ptr)
printf("Mutat vhova.\n");
if (!ptr)
printf("Sehova sem.\n");A pointerek a logikai kifejezésekhez hasonlóan használhatók. Igazra értékelődnek ki, ha mutatnak valahova, és hamisra,
ha nem. Így aztán a tagadó ! operátor is működik: !ptr igazra értékelődik ki, ha ptr nem
mutat sehova, vagyis null-pointer. Emiatt if (ptr != NULL) és és if (ptr) ugyanazt jelentik. Ahogyan az
if (ptr == NULL) és if (!ptr) is ekvivalensek.
Gyakran szokott vita lenni abból még gyakorlott programozók között is, hogy ugyanaz-e a 0 és a NULL. A
C szabvány megengedi azt, hogy a NULL, vagyis a sehova nem mutató pointert 0-val jelöljük, ha a
programkód szövegéből kiderül, hogy azt pointerként kell értelmezni (lásd: ISO/IEC 9899:1999, § 6.3.2.3 (3)). Vagyis ez a kód
helyes:
int *p;
p = 0;Emiatt egy pointer null vagy nem null értékét akár a ptr == 0 vagy ptr != 0 kifejezésekkel is
ellenőrizhetjük. De ezt sokan nem tekintik szép stílusnak; jobb kiírni a NULL-t.
Gyakran a C-ben a „0”-t polimorf (többalakú) literálisnak is nevezik (polymorphic literal), hiszen jelenthet számot és pointert is. Semelyik másik literális nem képes ilyenre: se egy másik egész (pl. 1), se egy valós szám, se egy sztring. Mindez kifejezetten a C nyelv sajátja, más nyelvekben nem feltétlenül van így!
Első előadás: scanf()
int a;
scanf("%d", &a); // cím szerinti átadásÍgy már érthető! Különben nem tudná beleírni a beolvasott számot.
A többi furcsaság
- Ezért nincs tömb értékadás:
t1 = t2 - Ezért nincs sztring értékadás (azok is tömbök)
- Ezért nem lehet sztringeket
==operátorral összehasonlítani.
A következő függvény egy sztring összes karakterét nagybetűre cseréli. Ehhez a ctype.h
szabványos toupper függvényét használja, amelyik a neki paraméterként adott karaktert nagybetűsítve
adja vissza. Nincs más dolga, mint meghívni ezt minden karakterre, és a visszatérési értéket eltárolni ugyanabban
a tömbelemben, ahonnan kivette azt:
void sztringet_nagybetusit(char *sztring) {
for (int i = 0; sztring[i] != '\0'; ++i)
sztring[i] = toupper(sztring[i])
}
A sztringet címével látja, ezért meg is változtathatja azt! De vajon miért nem adjuk most át a függvénynek a tömb méretét? Az előbb a tömbök/függvények témakörben azt mondtuk, hogy mindig át kell adni. Viszont most a tömb méretének nincs köze a sztring hosszához! A lezáró 0-ból tudjuk, hol van a sztringnek vége.
A függvény használata:
char h[] = "Hello";
sztringet_nagybetusit(h); // Hello → HELLO
printf("%s", h);Figyelem: nem kell & operátor a sztring átadásánál! A sztring egy tömb, amelynek a nevét írva már eleve pointer jön létre a paraméterátadás helyén!
Mennyi a sztring hossza?
ez sem veszi át!
int sztring_hossza(char *sztring) {
int i;
for (i = 0; sztring[i] != '\0'; ++i)
; /* üres */
return i;
}Az üres ciklus igazából nem üres: ++i. Ezt a ciklust írhattuk volna i = 0; while (sztring[i] != '\0')
++i; formában is, ami teljesen ugyanezt jelentené. Azért írtuk így, mert a C szemlélete szerint „ez még belefér” számlálásos
ciklusnak. Honnan? – a nulladiktól. Meddig? – a sztring végéig. Hányasával? – egyesével. A ciklus törzse így látszólag üresnek
tűnik. Ilyen esetben illik külön sorban írni az üres utasítást, esetleg kommenttel is megjelölni, hogy látszódjon, szándékosan
írtuk így.
char h[20] = "Hello";
printf("%d", sztring_hossza(h)); // 5Ez a függvény sem kapja paraméterként a sztring hosszát – nyilván, mert épp azt várjuk a függvénytől, hogy számolja meg. :) A
ciklus i=5-nél fog megállni, mivel a sztringben az 5. indexű elem a lezáró nulla. Ez egyben pont a sztring hossza is,
vagyis a benne lévő hasznos karakterek száma (a lezáró nullán kívül). Ez azért jön ki pont így, mivel az értékes karakterek a 0.
indextől kezdődően találhatóak a tömbben.
| 0 | 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|---|
| H | e | l | l | o | \0 |
Konklúzió: a lezáró nulla pont annyiadik indexű elem a tömbben, mint amilyen hosszú benne a szöveg.
strlen() ciklusfeltételben?
Gyakran találkozunk ehhez hasonló kóddal:
char h[20] = "Hello";
for (int i = 0; i < strlen(h); ++i) // nem jó ötlet!
printf("%c\n", h[i]);De miért mutatja a jelzés, hogy ezt nem jó ötlet így írni? Azért, mert ez az strlen() lényegében ugyanúgy működik,
mint a fenti, saját függvényünk; egy ciklussal elindul a sztring elejéről, keresve a lezáró nullát. Tehát ebben a kis kódrészletben
a ciklusfeltételbe tettünk egy olyan függvényhívást, amelyik végigmegy a teljes sztringen. És ezt pontosan annyiszor
fogja megtenni, ahány karaktere a sztringnek van. Minden egyes karakternél megszámolja, hogy hány karakterből áll a sztring;
minden egyes karakter kedvéért végigmegy a teljes tömbön.
Ezért nem teszünk strlen() függvényhívást a ciklusok feltételébe, hanem a lezáró nullára építjük azt:
ez a h[i] != '\0' kifejezés jelen esetben.
A ciklus átmásolja az „értékes” karaktereket.
Utána pedig még a lezáró nullát kell, pont az ide[i] helyre!
void sztringet_masol(char *ide, char *innen) {
int i;
for (i = 0; innen[i] != '\0'; ++i)
ide[i] = innen[i];
ide[i] = '\0'; // lezáró nulla!
}
A függvény használata:
char eredeti[] = "Hello";
char masolat[20];
sztringet_masol(masolat, eredeti);Túlindexelés veszélye: a függvény nem tudja, mekkora a cél tömb!
- Emiatt nem tud felelősséget vállalni ezért! Ha túl kicsi, túlírja!
- A függvény hívója felel érte, hogy elég nagy legyen!
Sztringmásolás: a klasszikus megoldás
A sztring másolására Brian Kernighan and Dennis Ritchie „The C Programming Language” című könyvében az alábbi megoldás szerepel:
void masol(char *ide, char *innen) {
while (*ide++ = *innen++)
;
}A ciklus feltételében szándékosan értékadás van! Ennek a kifejezésnek az értéke a másolt karakter kódja. Ha a lezáró nulla, az logikai hamisként értékelődik ki. Ettől megáll a ciklus, de azt még átmásolta, mivel annak a kifejezésnek a mellékhatása a karakter másolása. A másik mellékhatás az, hogy mindkét pointer a következő karakterre mutat (postincrement, utólagos).
Hogyan oldhatjuk meg ezt a problémát? Egyik lehetőségünk, hogy a szóköz helyett keresünk valami mást. Egy olyan elválasztó karaktert, amelyik biztosan nem szerepelhet sem az angol, sem a magyar szóban. Ilyen karakter lehet például a tabulátor.
for (int i = 0; i < szt->db; ++i)
fprintf(f, "%s\t%s\n", szt->szavak[i].magyar,
szt->szavak[i].angol);Az új fájlunk tehát tabulátorral választja el a szavakat, és az eddigiekhez hasonlóan külön sorba írja a szópárokat. Az ábrán a színes nyilakkal a tabulátor karaktert jelképezzük:
tábla csoki→bar of chocolate doboz gyufa→box of matches
A visszaolvasás itt biztosan nem működne fscanf() "%s %s"-sel. Mint azt a sztringek
kapcsán láttuk, a scanf() egy "%s" konverzió megadása esetén minden szóköz jellegű karakternél
megáll, tehát a több szóból álló kifejezések esetén csak az első szót olvasná be. Emiatt például a „tábla csoki” kezdetű sornál a
magyar szót tároló adattagba tenné a táblát, az angol adattagba pedig a csokit. Valahogyan a scanf() tudatára kell
adnunk, hogy nem a szóköznél, hanem a tabulátornál van vége a sztringnek.
Ilyen feladatok megoldására találták ki a scanf() "%[]" (szögletes zárójel) jelű
konverzióját. Ez a "%s"-hez hasonlóan egy sztringet olvas be, viszont itt meg lehet adni, hogy a sztring
milyen karaktereket tartalmazhat, vagy miket nem tartalmazhat.
scanf("%[0-9a-f]", s);scanf("%[^\n]", s);Ezt kétféleképpen használhatjuk: ha a szögletes zárójelben felsorolunk valamilyen karaktereket, azzal ezt
mondjuk: addig olvassuk a sztringet, amíg a megadott karakterek sorozata jön. Ha bármi ettől eltérő, akkor ott álljunk
meg. Az első példa egy olyan sztringet olvas be: "%[0-9a-f]", amiben hexadecimális számjegyek vannak: 0 és 9, illetve
a és f között.
A második lehetőségünk, hogy kizárt karaktereket sorolunk fel. Ha a szögletes zárójel után egy ^
kalapot (caret) teszünk, utána azokat a karaktereket adhatjuk meg, amiknél meg kell állni. Vagyis bármi mást beolvas, de
az első olyannál, ami a listában van, meg fog állni a sztring. A második példa egy sort olvas be: "%[^\n]". A
sztringben bármi lehet, kivétel újsor karakter.
Ezzel már vissza tudjuk olvasni a fenti módon létrehozott fájlunkat. A magyar szó (kifejezés) tabulátorig tart, az angol pedig a sor végéig. A beolvasás tehát:
szt->db = 0;
Szo uj;
while (fscanf(f, " %[^\t] %[^\n]",
uj.magyar, uj.angol) == 2) {
szt->szavak[szt->db] = uj;
szt->db += 1;
}Ebben még egy utolsó dologra kellett figyelnünk. Nevezetesen arra, hogy a "%[]" konverzió, amikor valamelyik
karakter miatt megáll, akkor azt a határoló karaktert már nem olvassa be a fájlból. Például a magyar szó beolvasása megáll a
tabulátornál, és ez a tabulátor ott marad a bemeneten. Vagyis a következő alkalommal, amikor valamit szeretnénk a fájlból olvasni,
elsőként ezt a karaktert fogjuk megkapni.
A fenti ábrán a fölfelé mutató nyíl jelzi azt, hogy ilyenkor hol állunk a fájlban. Ha ezt a tabulátort nem lépjük át, akkor
bekerül az angol szóba, mert a "%[^\n]" konverzió elfogadja. Ezt értelemszerűen el kell kerülnünk. Erre való a
formátumsztringben használt szóköz: ez átlépi az entereket, a szóközöket és mellesleg azt a tabulátort, ami épp az
elválasztó karakterünk volt.
Ugyanez a helyzet a sor végén: az angol szó beolvasása megáll az újsor karakternél, és az ott marad a bemeneten; ha nem akarjuk, hogy a következő magyar szóba bekerüljön, akkor azt a magyar szó beolvasása előtt el kell dobni.