C Programozás B. FÜGGELÉK

 

A. FÜGGELÉK Tartalom C. FÜGGELÉK

B. FÜGGELÉK:

A standard könyvtár

Ebben a függelékben összefoglaljuk az ANSI szabványban definiált programkönyvtárral kapcsolatos ismereteket. A standard könyvtár nem része a szűkebb értelemben vett C nyelvnek, de gondoskodik függvények deklarálásáról, valamint adattípusok és makrók definiálásáról, amivel a szabványos C nyelvet támogató környezetet hoz létre. Az ismertetésből néhány, csak korlátozottan használható vagy más függvényekből egyszerűen előállítható függvény leírását elhagytuk, csakúgy, mint a több-bájtos karakterekkel végezhető műveleteket, valamint a helyi jellegeztességektől (pl. nyelvtől) függő részleteket.A standard könyvtár függvényei, típusai és makrói standard headerekben vannak deklarálva. Ezek a standard headerek:

<assert.h>  <limits.h>  <signal.h>  <stdlib.h>
<ctype.h>   <locale.h>  <stdarg.h>  <string.h>
<errno.h>   <math.h>    <stddef.h>  <time.h>
<float.h>   <setjmp.h>  <stdio.h>

Egy headerhez az

#include <headernev>

direktívával férhetünk hozzá. A headerek bármilyen sorrendben és akárhányszor beépíthetők a programba. Egy headert bármilyen külső deklaráción vagy definíción kívül, vagy bármely, a headerben deklarált függvény, típus vagy adat felhasználása előtt kell beépíteni. A headernek nem szükséges a forrásállományban lenni.Az aláhúzással kezdődő külső azonosítók a könyvtár számára vannak fenntartva, és a könyvtárban használt összes azonosító aláhúzással kezdődik vagy nagybetűs írásmóddal és kezdő aláhúzással van jelölve.

B1. Adatbevitel és adatkivitel: az <stdio.h> header

Az adatbevitelt és -kivitelt kezelő függvények és makrók, valamint a hozzájuk tartozó adattípusok az <stdio.h> headerben vannak definiálva, és ez a header alkotja a standard könyvtár közel egyharmadát.Az adatok forrása vagy címzettje (ami lemezegység vagy más periféria lehet) adatáramot kezel. A standard könyvtár a szöveges és a bináris adatáram használatát támogatja, bár ezek néhány operációs rendszerben (pl. a UNIX esetén is) azonosak. Egy szöveges adatáram egymást követő sorokból áll, az egyes sorok nulla vagy több karaktert tartlamaznak és ‘\n‘ (újsor-) karakterrel záródnak. Egy programozási környezetben szükség lehet egy szöveges adatáram valamilyen más ábrázolásmódba való alakítására (pl. a ‘\n‘ kocsivissza- és soremelés-karakterekké alakítására). Egy bináris adatáram belső adatokat tartalmazó feldolgozatlan bájtok sorozata, és fő jellegzetessége, hogy kiírása után azonnal visszaolvassa a rendszer ellenőrzés céljából.

Egy adatáram a megnyitási folyamattal kapcsolódik egy állományhoz vagy perifériához és ez a kapcsolat az adatáram lezárásával szakítható meg. Az adatállományt megnyitó eljárás FILE típusú objektumot címző mutatóval tér vissza, és ez az objektum tartalmazza az adatáram vezérléséhez szükséges információkat. A későbbiekben, amikor nem okoz félreértést, az állománymutató és az adatáram fogalmát csereszabatosan fogjuk használni.

Amikor egy program végrehajtása megkezdődik, három adatáram, az stdin, stdout és stderr automatikusan megnyílik.

B1.1. Állománykezelő műveletek

A következőkben ismertetendő függvények végzik az állománykezelő műveleteket. A függvényekben használt size_t a sizeof operátorral létrehozott előjel nélküli, egész típusú változó.

FILE *fopen (const char *allomanynev, const char *mod)

Az fopen függvény megnyitja az adott nevű állományt és visszatér egy adatárammal (állománymutatóval) vagy NULL értékkel, ha a megnyitás közben hiba volt. A mod kezelési módot megadó paraméter lehetséges értékei:

“r” szöveges állomány megnyitása olvasásra;
“w” szöveges állomány létrehozása írásra, ha az állomány már létezik,
akkor előző tartalma elvész;
“a” hozzáfűzés: szöveges állomány megnyitása és írás az állomány végéhez;
“r+” szöveges állomány megnyitása aktuális használatra, azaz olvasásra
és írásra;
“w+” szöveges állomány létrehozása aktuális használatra, az állomány korábbi tartalma (ha volt) elvész;
“a+” hozzáfűzés: szöveges állomány megnyitása aktuális használatra és írás az állomány végéhez.

Az aktuális használatnak megfelelő üzemmód megengedi, hogy ugyanazt az állományt olvassuk és írjunk bele. Az írási és olvasási műveletek között az fflush függvényt vagy egy állományon belüli pozicionálást végző függvényt kell hívni. Ha a kezelési mód paraméter a megadott betűk után a b jelzést tartalmazza (pl. “rb” vagy “w+b”), akkor ez bináris állományra utal. Az állománynevek hossza max. FILENAME_MAX számú karakter lehet. Egy időben legfeljebb FOPEN_MAX számú állomány lehet megnyitva.

FILE *freopen (const char *allomanynev, cost char *mod, FILE *adataram)

A freopen függvény megnyitja az adott nevű állományt jelzett használati móddal és hozzárendeli a megadott adatáramot. A függvény az adatárammal tér vissza vagy ha hiba volt, a NULL értékkel. A freopen függvényt általában az stdin, stdout vagy stderr adatáramokhoz rendelt állományok megváltoztatására használják.

int fflush (FILE *adataram)

Kimeneti adatáramra híva az fflush függvény az összes pufferelt, de még ki nem írt adatot kiírja. Bemeneti adatáramra híva a függvényt az eredmény nem definiálható. A függvény normális esetben nulla értékkel, írási hiba esetén EOF értékkel tér vissza. A fflush (NULL) kiüríti az összes kimeneti adatáramot.

int fclose (FILE *adataram)

A fclose függvény az összes pufferelt kimeneti adatot kiírja a megadott adatáramba, törli a még be nem olvasott, de pufferelt adatot, felszabadítja az automatikusan kiosztott pufferterületeket, majd lezárja az adatáramot. A függvény EOF értékkel tér vissza, ha bármilyen hiba volt és nulla értékkel máskülönben.

int remove (const char *allomanynev)

A remove függvény eltávolítja (törli) a megadott nevű állományt, így az állomány megnyitására tett következő kísérlet hibát fog okozni. A függvény nem nulla értékkel tér vissza, ha a hozzáférési kísérlet hibát okozott.

int rename (const char *reginev, const char *ujnev)

A rename függvény az állomány nevét reginev-ről ujnev-re változtatja. A függvény nem nulla értékkel tér vissza, ha az állományhoz való hozzáférés sikertelen.

FILE *tmpfile(void)

A tmpfile függvény “wb+” használati móddal létrehoz egy átmeneti állományt, amelyet automatikusan töröl a lezárásakor vagy a program normális lefutásakor. A függvény visszatérésekor normális esetben az adatáramot adja, ill. ha az állomány nem hozható létre, akkor a NULL értéket.

char *tmpnam(char s[L_tmpnam])

A függvényt tmpnam(NULL) formában híva egy karaktersorozatot generál, ami nem egyezik meg egyetlen létező állomány nevével sem, és visszatéréskor ezt a karaktersorozatot tároló belső statikus tömb mutatóját adja vissza. A tmpnam (s) alakú hívás eltárolja a karaktersorozatot az s-ben, valamint függvényértékként is visszaadja. Az s tömbben legalább L_tmpnam számú karakter számára kell hogy hely legyen. A tmpnam minden hívásakor egy nevet generál és a program végrehajtása során legalább TMP_MAX számú különböző név generálása garantálható. Ügyeljünk arra, hogy a tmpnam csak nevet generál és nem állományt.

int setvbuf(FILE *stream, char *buf, int mod, size_t meret)

A setvbuf függvény az adatáram pufferelését vezérli, és ezt a függvényt kell hívni írás, olvasás vagy bármilyen más állománykezelő művelet előtt. A mod paraméter lehetséges értékei:

_IOFBF teljes pufferelés;
_IOLBF szöveges állományok esetén sorpufferelés;
_IONBF nincs pufferelés.

Ha a hívásakor a buf paraméter nem NULL, akkor a függvény ezt fogja pufferként használni, máskülönben a rendszer rendel pufferterületet a függvényhez. A meret paraméter a puffer méretét határozza meg. A függvény hiba esetén nem nulla értékkel tér vissza.

void setbuf(FILE *adataram, char *buf)

Ha a függvény hívásakor a buf paraméter NULL, akkor az adatáram pufferelését kikapcsolja. Minden más esetben a függvény megegyezik a (void) setvbuf (adataram, buf, _IOFBF, BUFSIZ) függvénnyel.

B1.2. Formátumozott adatkivitel

A formátumozott adatkiviteli konverziót alapvetően a printf függvény különböző változatai végzik.

int fprintf(FILE *adataram, const char *format, …)

Az fprintf függvény a format karaktersorozatban leírt formátum szerint átalakítja és az adataramba írja a megadott adatok értékét. A függvény a kiírt karakterek számát adja visszatérési értékként, vagy egy negatív számot, ha hiba volt.

A formátumot leíró karaktersorozat kétféle objektumot tartalmaz: közönséges karaktereket, amelyeket változtatás nélkül bemásol a kimeneti adatáramba, valamint konverziós specifikációkat, amelyek mindegyike az fprintf soron következő argumentumának konverzióját és kiíratását vezérli. Az egyes konverziós specifikációk a % karakterrel kezdődnek és egy konverziós karakterrel végződnek. A % jel és a konverziós karakter között sorrendben a következők helyezkedhetnek el:

  • Jelzők (bármilyen sorrendben), amelyek módosítják a specifikációt: mínuszjel, ami a konvertált argumentum balra igazítását írja elő a kiírási mezőben; + jel, ami azt írja elő, hogy a számok kiírása mindig előjellel együtt történjen; szóközkarakter hatására a szám elé szóköz íródik, ha az első karaktere nem előjel; 0 számkonverzió esetén azt írja elő, hogy a kiírási mezőben a szám előtti üres helyek vezető nullákkal töltődjenek fel; # jel a kimeneti formátum megváltoztatását írja elő. o esetén a kiírt első számjegy nulla lesz (oktális szám kiírása). X vagy x esetén a nem nulla szám elé 0x vagy 0X íródik (hexadecimális szám kiírása), e, E, g és G esetén a kiírt szám mindig tartalmazza a tizedespontot és g vagy G esetén a szám végén lévő értéktelen nullák megmaradnak.
  • A kiírási mező minimális szélességét előíró szám: az átalakított argumentum legalább ilyen szélességben (vagy ha szükséges, akkor szélesebb formában) fog kiíródni. Ha az átalakított szám a megadott mezőszélességnél kevesebb karakterből áll, akkor a mező bal széle (ill. ha balra igazítás volt előírva, akkor jobb széle) helykitöltő karakterekkel fog feltöltődni. A helykitöltő karakter normális esetben szóköz, de ha 0-val való feltöltést írtuk elő, akkor nulla.
  • A pont karakter, ami elválasztja a mezőszélességet a pontosságtól.
  • A pontosságot meghatározó szám, ami megadja, hogy e, E és f konverzió esetén a tizedespont után hány számjegyet kell kiírni, vagy g és G konverzió esetén minimálisan hány számjeggyel íródjon ki egy egész szám (a szükséges szélesség elérése érdekében a szám elé vezető nullák íródnak), vagy a karaktersorozatból hány karaktert kell kiírni.
  • Hosszmódosító, ami h, l vagy L lehet. A h azt jelzi, hogy a megfelelő argumentum short vagy unsigned short formában nyomtatható, az l azt, hogy az argumentum long vagy unsigned long és az L pedig azt, hogy az argumentum long double.

A mezőszélesség vagy pontosság vagy mindkettő a * jellel is megadható, és ebben az esetben a kívánt érték a következő argumentum(ok)ból, az(ok) konverziójával számítódik ki (az erre a célra használt argumentumoknak int típusúaknak kell lenni).A konverziós karaktereket és jelentésüket a B.1. táblázat tartalmazza. Ha a % jel utáni karakter nem konverziós karakter, akkor a függvény viselkedése nincs definiálva.

B.1. táblázat. A printf függvény konverziós karakterei
A konverziós karakter Az argumentum típusa A nyomtatás módja
d, i int decimális szám
o int előjel nélküli oktális szám vezető nullák nélkül)
x, X int előjel nélküli hexadecimális szám (a vezető 0x vagy 0X nélkül), a 10…15 jelzése az abcdef vagy ABCDEF karakterekkel
u int előjel nélküli decimális szám
c int egyetlen karakter
s char* karaktersorozatból karaktereket nyomtat a ‘\0‘ végjelzésig vagy a pontossággal megadott darabszámig
f double [-]m.dddddd alakú decimális szám, ahol d számjegyeinek számát a pontosság adja meg (alapfeltételezés szerint d=6)
e, E double [-]m.dddddde xx vagy [-]m.ddddddE xx alakú decimális szám, ahol d számjegyeinek számát a pontosság adja meg (alapfeltételezés szerint d=6
g, G double %e vagy %E alakú kiírást használ, ha a kitevő < -4 vagy >= pontosság, különben a %f alakú kiírást használja. A tizedespont és az utána következő értéktelen nullák nem íródnak ki
p void * mutató a géptől függő kiírási formában
n int * a printf függvény aktuális hívásakor kiírt karakterek száma beíródik az argumentumba. Az argumentum nem konvertálódik
% nincs konvertálandó argumentum egy % jelet ír ki

int printf(const char *format, …)

A printf függvény teljesen egyenértékű az fprintf (stdout, …) függvénnyel.

int sprintf(char *s, const char *format, …)

A sprintf függvény megegyezik a printf függvénnyel, kivéve, hogy a kimenetet az s karaktersorozatba írja, majd a \0 végjellel lezárja. Az s karaktersorozatnak elegendően hosszúnak kell lennie, hogy az eredményt tárolni tudja. A függvény visszatérésekor a kiírt karakterek számát adja (a végjel nélkül számolva).

vprintf(const char * format, va_list arg)
vfprintf(FILE *adataram, const char *format, va_list arg)
vsprintf(char *s, const char *format, va_list arg)

A vprintf vfprintf és vsprintf függvények megegyeznek a printf függvénnyel, kivéve, hogy a változó hosszúságú argumentumlistát az arg helyettesíti, ami a va_start makróval inicializálható és a va_arg makróval kezelhető. A változó hosszúságú argumentumlistát kezelő eljárások az <stdarg.h> headerben találhatók és használatukat a B7. pontban írjuk le.

B1.3. Formátumozott adatbevitel

A formátumozott adatbeviteli konverziót alapvetően a scanf függvény különböző változatai végzik.

int fscanf(FILE *adataram, const char *format, …)

Az fscanf függvény a karaktersorozatként megadott formátumleírással vezérelt módon beolvas az adataram-ból egy adatot, majd annak konvertált értékét hozzárendeli a soron következő argumentumhoz. Az adatokat tároló argumentumoknak kötelezően mutató típusúaknak kell lenni! A függvény akkor fejezi be a működését, ha a teljes formátumleírást feldolgozta. A függvény visszatérési értéke EOF, ha bármilyen adatkonverzió előtt állományvége-jelet érzékelt, vagy a beolvasás során hiba történt. Minden más esetben a visszatérési érték a konvertált és argumentumokhoz hozzárendelt bemeneti adatok száma.

A formátumot leíró karaktersorozat konverziós specifikációkat tartalmaz, amelyek közvetlenül felhasználhatók a bemenet értelmezéséhez. A formátumot leíró karaktersorozat tartalma:

  • Szóközök vagy tabulátorok, amelyeket a függvény a formátum feldolgozása során figyelmen kívül hagy.
  • Közönséges karakterek (nem % jel), amelyek várhatóan illeszkednek a bemeneti adatáram következő nem üreshely-karaktereihez.
  • Konverziós specifikációk, amelyek a % jelből, a * opcionális hozzárendelés-elnyomó karakterből, a max. mezőszélességet meghatározó számból (opcionális), a célként megadott argumentum szélességét jelző h, l vagy L karakterből (opcionális), valamint egy konverziós karakterből tevődnek össze.

A konverziós specifikáció a következő bemeneti mező konverziójának módját határozza meg. Normális esetben a konverzió eredménye a megfelelő argumentummal címzett változóba kerül. Ha a * hozzárendelés-elnyomó karaktert alkalmaztuk, mint pl. a %*s esetben, akkor a függvény a bemeneti mezőt egyszerűen átlépi és nem történik meg a beolvasott érték hozzárendelése a változóhoz. A bemeneti mező nem üres helyekből álló karaktersorozatként van definiálva, és a következő üreshely-karakterig, vagy ha megadtuk, akkor a mezőszélességnek megfelelő számú karakterig tart. Ez azt jelenti, hogy a scanf függvény a bemenet keresése közben folyamatosan átolvas a sorhatárokon, mivel az új sor is üreshely-karakternek számít. (Üreshely-karakter a szóköz, a tabulátor, az új sor, a kocsivissza, a soremelés, a függőleges tabulátor és a lapemelés.)A konverziós karakterek jelzik a bemeneti mező értelmezését. A megengedett konverziós karaktereket a B.2. táblázat tartalmazza.

A d, i, n, o, u és x konverziós karakterek előtt a h jelzés állhat, ha a mutatóval címzett argumentum nem int, hanem short típusú, vagy a l jelzés, ha a mutatóval címzett argumentum long típusú. Az e, f és g konverziós karakterek előtt állhat az l, ha az argumentumként megadott mutató float helyett double típusú változót címez és az L, ha a mutató long double típusú változót címez.

int scanf (const char * format, …)

A scanf(…) függvény megegyezik az fscanf(stdin, …) függvénnyel.

int sscanf(char *s, const char *format, …)

A sscanf(s, …) függvény megegyezik a scanf(…) függvénnyel, kivéve, hogy a bemeneti karakterek az s karaktersorozatból olvasódnak.

B.2. táblázat. A scanf függvény konverziós karakterei
A konverziós karakter Az argumentum típusa A beolvasott adat
d int * decimális egész
i int * egész szám, ami lehet oktális (vezető nullákkal) vagy hexadecimális (vezető 0x vagy 0X karakterekkel)
o int * oktális egész szám (vezető nullákkal vagy azok nélkül)
u unsigned int* előjel nélküli decimális egész szám
x int * hexadecimális egész szám (a vezető 0x, ill. 0X karakterekkel vagy azok nélkül)
c char * karakterek. A következő bemeneti karakterek (alapfeltételezés szerint 1) elhelyezése a kijelölt mezőben. Az üres helyek átlépését (mint normális esetet) elnyomja, ha a következő nem üres karaktert akarjuk beolvastatni, akkor a %1s specifikációt kell használni
s char * karaktersorozat (aposztrófok nélkül). A char * mutató egy elegendően nagy karaktersorozatra mutat és a záró ‘\0‘ jelzést a beolvasás után automatikusan elhelyezi
e, f, g float * lebegőpontos szám, opcionális előjellel opcionális tizedesponttal és opcionális kitevővel
p void * mutató, olyan formában, ahogyan azt a printf(“%p”) kiírta
n int * az aktuális scanf hívással beolvasott karakterek száma beíródik az argumentumba. Nem történik adatbeolvasás, a konvertált tételek száma nem nő
[…] char * a bemeneti karakteráramból beolvassa a zárójelek közötti karakterekkel (illeszkedési halmazzal) megegyező karakterekből álló leghosszabb nem üres karaktersorozatot és lezárja a \0 végjellel. A []…] formában megadott halmaz esetén a ] karakter a halmaz része lesz
[^…] char * az illeszkedési halmazzal nem megegyező karakterekből álló karaktersorozat beolvasása és \0 végjellel történő lezárása. A [^]…] formában megadott halmaz esetén a ] karakter a halmaz része lesz
% nincs hozzárendelés % jel mint karakteres állandó

B1.4. Karakteres adatbevitelt és adatkivitelt kezelő függvények

int fgetc(FILE *adataram)

Az fgetc függvény visszatér az adatáramból a következő karakterrel. A beolvasott karakter unsigned char típusú, amely int típusúvá alkul. A visszatérési érték EOF, ha az olvasás elérte az állomány végét vagy az olvasás közben hiba történt.

char *fgets(char *s, int n, FILE *adataram)

Az fgets függvény a következő legfeljebb n-1 darab karaktert beolvassa az s karakteres tömbbe. A beolvasás leáll, ha újsor-karakter fordul elő, de az új sor beíródik az s tömbbe. A beolvasott karaktersorozat kiegészül a \0 végjellel. A függvény az s tömbbel, ill. hiba vagy állomány vége esetén NULL értékkel tér vissza.

int fputc(int c, FILE *adataram)

Az fputc függvény a c karakter unsigned char típusra konvertált értékét kiírja az adatáramba. Visszatérési értéke maga a kiírt karakter vagy EOF, ha hiba történt.

int fputs(const char *s, FILE *adataram)

Az fputs kiírja az s karaktersorozatot (amelynek nem szükséges \n újsorkaraktert tartalmazni) az adatáramba és normális esetben nem negatív értékkel, hiba esetén EOF értékkel tér vissza.

int getc(FILE *adataram)

A getc megegyezik az fgetc függvénnyel, kivéve, hogy makróként van megvalósítva.

int getchar(void)

A getchar megegyezik a getc(stdin) függvénnyel.

char *gets(char *s)

A gets függvény beolvassa a következő bemeneti sort az s karakteres tömbbe és helyettesíti a sort lezáró újsor-karaktert a \0 végjellel. A függvény az s tömbbel vagy állomány vége, ill. hiba esetén NULL értékkel tér vissza.

int putc(int c, FILE *adataram)

A putc megegyezik az fputc függvénnyel, kivéve, hogy makróként van megvalósítva.

int putchar(int c)

A putchar megegyezik a putc (c, stdout) függvénnyel.

int puts(const char *s)

A puts függvény az stdout-ra kiírja az s karaktersorozatot és lezárja egy újsorkarakterrel. Visszatérési értéke normális esetben nem negatív, hiba esetén EOF.

int ungetc(int c, FILE *adataram)

Az ungetc függvény visszateszi c unsigned char típusúra konvertált értékét a bemeneti adatáramba, ahonnan az a következő olvasással elővehető. Csak egy karakter visszahelyezése esetén garantálható a helyes működés. Az EOF karaktert nem lehet visszahelyezni az adatáramba. A függvény visszatérési értéke maga az adatáramba visszahelyezett karakter vagy EOF, ha hiba történt.

B1.5. A közvetlen adatbevitel és adatkivitel függvényei

size_t fread(void *ptr, size_t meret, size_t nobj, FILE *adataram)

Az fread függvény az adatáramból a ptr mutatóval címzett tömbbe olvas legfeljebb nobj számú, meret méretű objektumot. A függvény visszatérési értéke a beolvasott objektumok száma, ami kisebb lehet a megadott darabszámnál. Az állapot meghatározásához a feof és ferror makrókat kell használni.

size_t fwrite(const void *ptr, size_t méret, size_t nobj, FILE *adataram)

A fwrite függvény a ptr mutatóval címzett tömbből nobj számú, meret méretű objektumot ír ki az adatáramba. A függvény viszatér a kiírt objektumok számával, ami hiba esetén kisebb, mint nobj.

B1.6. Állományon belül pozicionáló függvények

int fseek(FILE *adataram, long offset, int bazis)

Az fseek függvény az adatáram aktuális pozícióját úgy állítja be, hogy a következő olvasás vagy írás ettől a pozíciótól kezdődően fog végbemenni. Bináris állományok esetén az új pozíció a bazis-tól számított offset számú karaktere lesz, és a bazis értéke SEEK_SET (az állomány kezdete), SEEK_CUR (a régi aktuális pozíció) vagy SEEK_END (az állomány vége) lehet. Szöveges állományok esetén offset értéke nulla kell legyen vagy az ftell függvénnyel előállított értéknek (ilyenkor a bazis-nak a SEEK_SET értéket kell adni). Az fseek hiba esetén nem nulla értékkel tér vissza.

long ftell(FILE *adataram)

Az ftell függvény visszatér az adataram-hoz tartozó állomány aktuális pozíciójával vagy hiba esetén a -1L értékkel.

void rewind(FILE *adataram)

A rewind(allomanymutato) megegyezik az fseek(allomanymutato, 0L, SEEK_SET); clearerr(allomanymutato) függvényhívásokkal.

int fgetpos(FILE *adataram, fpos_t *ptr)

Az fgetpos függvény a ptr mutatóval címzett változóba olvassa az adataram-hoz tartozó állomány aktuális pozícióját. A kapott érték az fsetpos függvényben használható. Az fpos_t típus olyan, hogy alkalmas a pozíció tárolására. A függvény hiba esetén nem nulla értékkel tér vissza.

int fsetpos(FILE *adataram, const fpos_t *ptr)

Az fsetpos függvény az adataram-hoz tartozó állományt az fgetpos függvénnyel meghatározott és a ptr mutatóval címzett helyre eltárolt pozícióba állítja. A függvény hiba esetén nem nulla értékkel tér vissza.

B1.7. Hibakezelő függvények

A könyvtári függvények többsége hiba- vagy állományvége-jelzés esetén beállítja az állapotjelzőket. Ezeket az állapotjelzőket explicit módon lehet beállítani és vizsgálni. Ezenkívül még az errno egész típusú kifejezés (amely az <errno.h> headerben van deklarálva) tartalmazhat egy hibaszámot, ami további információt szolgáltat a legutoljára előfordult hibáról.A hibakezelő függvények:

void clearerr(FILE *adataram)

A clearerr függvény törli az adataram-hoz tartozó, az EOF-ot és a hibákat tartalmazó állapotjelzőket.

int feof(FILE *adataram)

A feof függvény nem nulla értékkel tér vissza, ha az adataram-hoz tartozó EOF állapotjelző be van állítva.

int ferror(FILE *adataram)

A ferror függvény nem nulla értékkel tér vissza, ha az adataram-hoz tartozó hibaállapot-jelző be van állítva.

void perror(const char *s)

A perror függvény kiírja az s karaktersorozatot, valamint az errno hibaszámhoz tartozó, gépi megvalósítástól függően definiált hibaüzenetet. A függvény úgy működik, mintha az

fprintf(stderr, "%s: %s\n", s, "hibaüzenet");

utasítást adtuk volna ki. A hibaüzenet az strerror függvénnyel határozható meg, ennek leírása a B3. pontban található.

B2. Karakteres vizsgálatok: a <ctype.h> header

A <ctype.h> headerben vannak a karakteres vizsgálatok függvényei deklarálva. Az egyes függvények argumentuma int típusú, amelynek értéke EOF vagy unsigned char típusban ábrázolható kell hogy legyen. A függvények visszatérési értéke int típusú, és nem nulla (logikailag igaz), ha a c argumentum kielégíti az adott feltételt, ill. nulla (logikailag hamis), ha nem. Az egyes függvények (az igaz értékhez tartozó feltételt megadva):

isalnum(c) ha isalpha(c) vagy isdigit(c) igaz (azaz c betű vagy decimális számjegy);
isalpha(c) ha isupper(c) vagy islower(c) igaz (azaz c nagy- vagy kisbetű);
iscntrl(c) ha c vezérlőkarakter;
isdigit(c) ha c decimális számjegy;
isgraph(c) ha c nyomtatható karakter (kivéve a szóközt);
islower(c) ha c kisbetű;
isprint(c) ha c nyomtatható karakter, beleértve a szóközt is;
ispunct(c) ha c nyomtatható karakter, de nem szóköz, betű vagy számjegy;
isspace(c) ha c szóköz, lapemelés, új sor, kocsivissza, tabulátor, függőleges tabulátor (üreshely-karakter);
isupper(c) ha c nagybetű;
isxdigit(c) ha c hexadecimális számjegy.

A hétbites ASCII karakterkészletben a nyomtatható karakterek kódja a 0x20-tól (‘ ‘) 0x7E-ig (‘~’) terjed. A vezérlőkarakterek kódja 0-tól (NUL) 0x1F-ig (US) terjed és ide tartozik még a 0x7F (DEL) kódja.
Még további két konverziós függvény használható a betűkre:

int tolower(int c) c értékét kisbetűvé alakítja;
int toupper(int c) c értékét nagybetűvé alakítja.

Ha c egy nagybetű, akkor a tolower (c) a megfelelő kisbetűvel, a különben magával a c értékével tér vissza. Ha c egy kisbetű, akkor a toupper (c) visszatér a megfelelő nagybetűvel, különben visszaadja a c értékét.

B3. Karaktersorozat-kezelő függvények: a <string.h> header

A karaktersorozatot kezelő függvényeknek két csoportja van deklarálva a <string.h> headerben. Az első csoportba tartozó függvények neve az str karakterekkel kezdődik, a második csoportba tartozóké pedig a mem karakterekkel. A memmove függvény kivételével a függvények viselkedése definiálatlan, ha átfedő objektumokra alkalmazzuk azokat. Az összehasonlító függvények az argumentumukat unsigned char típusú tömbként kezelik.
A következő táblázatban s és t char * típusú, cs és ct const char * típusú, n size_t típusú, valamint c char típusra konvertált int típusú.

char *strcpy(s, ct)

Az strcpy függvény a ct karaktersorozatot átmásolja az s karaktersorozatba, beleértve a ct-t záró \0 végjelet is. A függvény visszatérési értéke s mutatója.

char *strncpy(s, ct, n)

Az strncpy függvény a ct-ből n karaktert átmásol s-be és visszatér s mutatójával. Az s végét \0 végjelekkel tölti fel, ha ct n karakternél rövidebb volt.

char *strcat(s, ct)

Az strcat függvény a ct karaktersorozatot az s karaktersorozat végéhez fűzi (konkatenálja) és visszatér s mutatójával.

char *strncat(s, ct, n)

Az strncat függvény a ct karaktersorozatból n karaktert az s karaktersorozat végéhez fűz, s-t lezárja a \0 végjellel és visszatér s mutatójával.

int strcmp(cs, ct)

Az strcmp függvény összehasonlítja a cs karaktersorozatot a ct karaktersorozattal és visszatér negatív értékkel, ha cs < ct, nulla értékkel, ha cs == ct és pozitív értékkel, ha cs > ct.

int strncmp(cs, ct, n)

Az strncmp függvény összehasonlítja a cs karaktersorozat legfeljebb n karakterét a ct karaktersorozattal és visszatér negatív értékkel, ha cs < ct, nulla értékkel, ha cs == ct és pozitív értékkel, ha cs > ct.

char *strchr(cs, c)

Az strchr függvény a c karakter cs-beli első előfordulási helyének mutatójával, ill. ha c nem található meg cs-ben, akkor NULL értékű mutatóval tér vissza.

char *strrchr(cs, c)

Az strrchr függvény a c karakter cs-beli utolsó előfordulási helyének mutatójával, ill. ha c nem található meg cs-ben, akkor NULL értékű mutatóval tér vissza.

size_t strspn(cs, ct)

Az strspn függvény visszatérési értéke a cs karaktersorozat elejéről vett és ct-ben megtalálható részsorozat hossza. (Az elején egyező rész hossza.)

size_t strcspn(cs, ct)

Az strcspn függvény visszatérési értéke a cs karaktersorozat elejéről vett és ct-ben nem megtalálható részsorozat hossza. (Az elején különböző rész hossza.)

char *strpbrk(cs, ct)

Az strpbrk függvény visszatérési értéke a cs karaktersorozat ct karaktersorozaton belüli első előfordulásának kezdetét címző mutató, vagy NULL, ha cs nem található meg ct-ben.

char *strstr(cs, ct)

Az strstr függvény visszatérési értéke a ct karaktersorozat cs-beli első előfordulásának kezdetét címző mutató, vagy NULL, ha a ct nem található meg cs-ben.

size_t strlen(cs)

Az strlen függvény visszatérési értéke a cs karaktersorozat hossza.

char *strerror(n)

Az strerror függvény az n hibaszámhoz tartozó, a gépi megvalósítástól függő hibaüzenet karaktersorozatának mutatójával tér vissza.

char *strtok(s, ct)

Az strtok függvény megkeresi az s karaktersorozatban a ct karaktersorozatból vett karakterekkel határolt tokeneket. (A függvény működésének leírását l. alább.)

Az strtok(s, ct) függvény sorozatos hívásával az s karaktersorozat tokenekre bontható és az egyes tokeneket a ct-ben lévő karakter határolja. A függvény első hívásának s nem NULL értékével kell történnie, és ekkor a függvény megkeresi az s-ben az első, ct-ben nem lévő karakterekből felépített tokent, majd az s következő karakterét a \0 végjellel felülírva visszatér a tokent címző mutatóval. A további hívásokat az s NULL értéke jelzi, és a függvény ilyenkor a következő token (amelyet az előzőleg talált token végétől kezd keresni) mutatójával tér vissza. Ha az strtok nem talál további tokent, akkor a visszatérési értéke NULL lesz. A ct karaktersorozat hívásról hívásra változhat.A mem kezdetű függvények különböző objektumokkal mint karakteres tömbökkel való manipulációkra használhatók, és megírásukkal a hatékony adatkezelő eljárások kialakítása volt a cél. A következő táblázatban s és t void * típusú, cs és ct const void * típusú, n size_t típusú, valamint c unsigned char típusúvá alakított int típusú.

void *memcpy(s, ct, n)

A memcpy függvény a ct-ből n karaktert átmásol az s-be és visszatér s mutatójával.

void *memmove(s, ct, n)

A memmove függvény megegyezik a memcpy függvénnyel, kivéve, hogy egymást átfedő objektumok esetén is használható.

int memcmp(cs, ct, n)

A memcmp függvény összehasonlítja a cs első n karakterét ct-vel. A függvény visszatérési értékei megegyeznek az strcmp visszatérési értékeivel.

void *memchr(cs, c, n)

A memchr függvény visszatérési értéke a c karakter cs-beli első előfordulásának helyét címző mutató, vagy NULL, ha c nem található meg cs első n karakterében.

void *memset(s, c, n)

A memset függvény elhelyezi a c karaktert az s első n karakterében és visszatérési értéke az s mutatója.

B4. Matematikai függvények: a <math.h> header

A matematikai eljárások függvényei és makrói a <math.h> headerben vannak deklarálva.Az <errno.h> headerben deklarált EDOM és ERANGE nem nulla értékű egész állandók, amelyek a függvények értelmezési tartomány és értékkészlet hibáját jelzik, a HUGE_VAL értéke pedig pozitív, double típusú szám. Az értelmezési tartomány hiba akkor fordul elő, ha a függvény argumentuma a függvénydefinícióban megadott tartományon kívülre esik. Az értelmezési tartomány hiba esetén az errno beáll EDOM értékére és a visszatérési érték (a hibaüzenet) a gépi megvalósítástól függ. Az értékkészlet hiba akkor fordul elő, ha a függvénnyel kapott eredmény nem ábrázolható double típusú változóval. Ha az eredmény túlcsordult, akkor a függvény visszatérésekor a helyes előjelnek megfelelően állítja be a HUGE_VAL-t és az errno az ERANGE értékének megfelelően áll be. Ha az eredmény alácsordult, akkor a függvény nulla értékkel tér vissza és az errno a gépi megvalósítástól függő módon áll be ERANGE értékére.

A függvények leírását tartalmazó táblázatban x és y double típusú, n értéke int típusú, és minden függvény visszatérési értéke double típusú. A trigonometrikus függvények argumentumát radiánban kell megadni. A matematikai függvények:

sin(x) az x argumentum szinusza;
cos(x) az x argumentum koszinusza;
tan (x) az x argumentum tangense;
asin(x) az x argumentum árkusz szinusza, az értékkészlet a [-π/2, π/2] tartomány, x E [-1, 1];
acos(x) az x argumentum árkusz koszinusza, az értékkészlet a [0, π] tartomány, x E [-1, 1];
atan(x) az x argumentum árkusz tangense, az értékkészlet a [-π/2, π/2] tartomány;
atan2(y, x) az y/x érték árkusz tangense, az értékkészlet a [-π, π] tartomány;
sinh(x) az x argumentum szinusz hiperbolikusa;
cosh(x) az x argumentum koszinusz hiperbolikusa;
tanh(x) az x argumentum tangens hiperbolikusa;
exp(x) az ex exponenciális függvény;
log(x) az x argumentum természetes alapú logaritmusa (ln(x))), x>0;
log10(x) az x argumentum tízes alapú logaritmusa (lg(x))), x>0;
pow(x, y) az xy alakú hatványfüggvény, értelmezési tartomány hiba lép fel, ha x=0 és y<0, vagy ha x<0 és y értéke nem egész szám;
sqrt(x) az x argumentum négyzetgyöke, x>0;
ceil(x) az x argumentumnál nem kisebb legkisebb egész szám, double típusra konvertálva;
floor(x) az x argumentumnál nem nagyobb legnagyobb egész szám, double típusra konvertálva;
fabs(x) az x argumentum abszolút értéke (|x|);
ldexp(x, n) az x*2n függvény értéke;
frexp(x, int *exp) a függvény az x argumentum értékét az [1/2, 1) intervallumba eső normált törtrésszé alakítja és ezzel az értékkel tér vissza. A 2 hatványaként értelmezett kitevő a *exp című változóba tárolódik. Ha x=0, akkor az eredmény törtrésze és kitevője egyaránt nulla lesz;
modf(x, double *ip) az x argumentum eredeti x előjelével azonos előjelű egész- és törtrészre bontása. Az egészrész az *ip című változóban tárolódik, a függvény visszatérési értéke a törtrész lesz;
fmod(x, y) az x/y lebegőpontos osztás lebegőpontos maradéka, ami ugyanolyan előjelű mint x. Ha y=0, akor az eredmény a gépi megvalósítástól függ.

B5. Kiegészítő rendszerfüggvények: az <stdlib.h> header

Az <stdlib.h> standard headerben vannak deklarálva a számkonverziós, tárkezelő és más hasonló, általános jellegű függvények. Az egyes függvények leírása:

double atof(const char *s)

Az atof függvény az s karaktersorozat tartalmát double típusú számmá alakítja. A függvény egyenértékű az strtod(s, (char**)NULL, 10) függvénnyel.

int atoi(const char *s)

Az atoi függvény az s karaktersorozat tartalmát int típusú számmá alakítja. A függvény egyenértékű az (int)strtol(s, (char**)NULL, 10) függvénnyel.

long atol(const char *s)

Az atol függvény az s karaktersorozat tartalmát long típusú számmá alakítja. A függvény egyenértékű az strtol(s, (char**)NULL, 10) függvénnyel.

double strtod(const char *s, char **endp)

Az strtod függvény az s karaktersorozatot a bevezető üreshely-karakterek elhagyása után egy double típusú előtaggá (amely a függvény visszatérési értéke lesz), valamint egy konvertálatlan utótaggá (kivéve, ha *endp értéke NULL) alakítja. Az utótagot címző mutató a *endp helyen tárolódik. Ha az eredmény túlcsordul, akkor a HUGE_VAL a helyes előjelnek megfelelő értéket veszi fel; ha az eredmény alácsordul, akkor a visszatérési érték nulla lesz. Az errno mindkét esetben az ERANGE értékére áll be.

long strtol(const char *s, char **endp, int alap)

Az strtol függvény az s karaktersorozatot a bevezető üreshely-karakterek elhagyása után egy long típusú előtaggá (amely a függvény visszatérési értéke lesz), valamint egy konvertálatlan utótaggá (kivéve, ha *endp értéke NULL) alakítja. Ha az alap argumentum értéke 2 és 36 közé esik, akkor a konverzió úgy megy végbe, hogy feltételezi a bemeneti adat adott számrendszerbeli ábrázolását. Ha az alap nulla értékű, akkor az átalakítás oktális, decimális vagy hexadecimális számrendszerbe történik, a bemeneti adat írásmódjától függően (ha a számjegykarakterek sorozata 0 karakterrel kezdődik, akkor oktális, ha pedig 0x vagy 0X karakterekkel, akkor hexadecimális szám lesz az eredmény). A karaktersorozatban szereplő betűk minden esetben a 10 és az (alap – 1) közötti számjegyeket jelölik; a hexadecimális számoknál megengedett a bevezető 0x vagy 0X. Az utótagot címző mutató a *endp helyen tárolódik. Ha az eredmény túlcsordul, akkor a függvény visszatérési értéke az eredmény előjelétől függően LONG_MAX vagy LONG_MIN és az errno az ERANGE értékére áll be.

unsigned long strtoul(const char *s, char **endp, int alap)

Az strtoul függvény megegyezik az strtol függvénnyel, kivéve, hogy az eredmény (visszatérési érték) unsigned long típusú és túlcsordulás esetén a visszatérési érték ULONG_MAX értékű.

int rand(void)

A rand függvény egy 0 és RAND_MAX közötti pszeudovéletlen egész számmal tér vissza. RAND_MAX értéke legalább 32 767.

void srand(unsigned int indul)

Az srand függvény az indul értékével egy új pszeudovéletlen számsorozatot generál. A véletlenszám-generátor, kezdeti induló értéke 1.

void *calloc(size_t nobj, size_t meret)

A calloc függvény egy nobj számú, egyenként meret méretű objektumot tartalmazó tömb számára lefoglalt tárterület kezdetét címző mutatóval tér vissza. A mutató értéke NULL, ha a helyfoglalási igény nem elégíthető ki. A lefoglalt tárterület nulla értékű bájtokkal van feltöltve.

void *malloc(size_t meret)

A malloc függvény egyetlen meret méretű objektum számára lefoglalt tárterület kezdetét címző mutatóval, vagy ha az igény nem elégíthető ki, akkor NULL értékkel tér vissza. A lefoglalt tárterület inicializálatlan.

void *realloc(void *p, size_t meret)

A realloc függvény a p mutatóval címzett objektum méretét meret-re változtatja. Az objektum tartalma a régi és új méretek közül a kisebb méretig változatlan marad. Ha az új méret nagyobb a réginél, akkor az új tárterület mutatójával tér vissza, ill. a NULL értékkel, ha az igény nem elégíthető ki (ilyenkor *p változatlan marad).

void free(void *p)

A free függvény felszabadítja a calloc, malloc vagy realloc függvényekkel lefoglalt, a p mutatóval címzett tárterületet. Ha p értéke NULL, akkor a függvény nem csinál semmit.

void abort(void)

Az abort függvény a program futásának abnormális befejezését okozza. A függvény működése megegyezik a raise(SIGABRT) függvényhívás működésével.

void exit(int allapot)

Az exit függvény a program futásának normális befejezését okozza. Az atexit függvény hívásával kiüríti a megnyitott állományok puffereit, lezárja a megnyitott adatáramokat és a vezérlést visszaadja az operációs rendszernek. Az operációs rendszernek visszaadott állapot állapotjelzés értelmezése a gépi megvalósítástól függ, de a nulla érték mindig a normális (sikeres) befejezést jelenti. Az állapot EXIT_SUCCESS és EXIT_FAILURE értéke szintén használható.

int atexit(void (*fcn)(void))

Az atexit függvény végrehajtásra előjegyzi az fcn függvényt a program normális befejezése esetén. A függvény nem nulla értékkel tér vissza, ha az előjegyzés nem hajtható végre.

int system(const char *s)

A system függvény végrehajtásra átadja az operációs rendszernek az s karaktersorozatot. Ha s értéke NULL, akkor a függvény nem nulla értékkel tér vissza létező parancsprocesszor esetén. Ha s értéke nem NULL, akkor a függvény visszatérési értéke a gépi megvalósítástól függ.

char *getenv(const char *nev)

A getenv függvény visszatérési értéke az operációs rendszertől kapott nev nevű karaktersorozat vagy NULL, ha nincs karaktersorozat. A függvény működésének részletei a gépi megvalósítástól függenek.

void *bsearch (const void *kulcs, const void *tabla, size_t n, size_t meret, int (*comp) (const void *kulcsv, const void *datum))

A bsearch függvény a tabla[0]…tabla[n-1] táblázat elemei (amelyek mérete meret) közül megkeresi a kulcs-csal megegyezőt. A bsearch függvény az összehasonlításhoz a cmp függvényt használja, amely negatív értékkel tér vissza, ha az első argumentuma kisebb a másodiknál, nullával, ha a két argumentum megegyezik és pozitív értékkel, ha az első argumentum nagyobb a másodiknál. (Az első argumentum a kulcs, a második a táblázat megfelelő eleme.) A tabla tömb elemeinek növekvő sorrendbe rendezettnek kell lenni. A bsearch függvény a kulcs-csal megegyező elem mutatójával, ill. ha a kulcs-nak megfelelő elem nem található meg a tömbben, akkor NULL értékkel tér vissza.

void qsort(void *tabla, size_t n, size_t meret, int (*cmp) (const void *, const void *))

A qsort függvény növekvő sorrendbe rendezi a tabla[0]…tabla[n-1] meret méretű objektumokból álló tömböt. Az összehasonlítást a bsearch függvénynél alkalmazott cmp függvény végzi.

int abs(int n)

Az abs függvény visszatérési értéke az egész típusú argumentumának abszolút értéke (egész értékként).

long labs(long n)

A labs függvény long típusú vissztérési értéke a long típusú argumentum abszolút értéke.

div_t div(int szaml, int nevez)

A div függvény kiszámítja az egész típusú argumentumokra felírt szaml/nevez tört hányadosát és maradékát. Az eredmény egy div_t típusú struktúra quot és rem nevű, int típusú tagjaiban tárolódik (a quot a hányadost, rem a maradékot tárolja).

ldiv_t ldiv(long szaml, long nevez)

Az ldiv függvény kiszámítja a long típusú argumentumokra felírt szaml/nevez tört hányadosát és maradékát. Az eredmény egy ldiv_t típusú struktúra long típusú, quot és rem nevű tagjaiban tárolódik (a quot a hányadost, rem a maradékot tárolja).

B6. Programdiagnosztika: az <assert.h> header

Az assert makró a programdiagnosztika segítésére használható. A makró általános formája:

void assert(int kifejezés)

A makrót az

assert(kifejezés)

formában híva az az stderr állományba az

Assertion failed: kifejezés, file állománynév, line nnn

üzenetet fogja kiírni. Ezután hívható az abort függvény, amellyel a program futása befejezhető. Az üzenetben szereplő állománynevet és sorszámot az assert az előfeldolgozó rendszerben definiált és kezelt __FILE__ és __LINE__ azonosítójú helyekről veszi. Ha az <assert.h> header beépítésekor az NDEBUG név definiálva van, akkor az assert makrót a rendszer figyelmen kívül hagyja (nem hajtja végre).

B7. Változó hosszúságú argumentumlisták kezelése: az <stdarg.h> header

Az <stdarg.h> headerben definiált függvények és változók lehetővé teszik ismeretlen számú és típusú argumentumot tartalmazó függvényhívás argumentumlistájának feldolgozását.Tételezzük fel, hogy a f(a1, a2, utarg, …) alakú függvényhívásban utarg az utolsó névvel ellátott argumentum, amelyet már a változó argumentumrész követ. Ekkor az f függvényhez

va_list ap;

formában deklarálható egy va_list típusú ap változó (argumentummutató), amely az egyes argumentumokat címzi. Az ap mutatót az első meg nem nevezett argumentumhoz való hozzáférés előtt a va_start makróval a

va_start(va_list ap, utarg);

módon inicializálni kell. Ezek után a va_arg makró hívásával vehető elő a lista következő, meg nem nevezett argumentuma. A va_arg makró a

típus va_arg(va_list ap, típus);

formában hívható, és visszatérési értéke az ap által címzett argumentum értéke a megadott típusra konvertálva. A hívás során a va_arg makró az ap mutatót a következő meg nem nevezett argumentumra lépteti. Az f függvényben az argumentumlista feldolgozása után, de még a függvényből való visszatérés előtt egyszer hívni kell a va_end makrót a

void va_end(va_list ap);

formában, ami lezárja az argumentumlista feldolgozását.

B8. Nem lokális vezérlésátadások: a <setjmp.h> header

A <setjmp.h> header deklarációi lehetőséget nyújtanak a normális függvényhívások és visszatérések elkerülésére, és tipikusan lehetővé teszik, hogy mélyen beágyazott függvényhívásokból közvetlenül térjünk vissza. Az egyes makrók:

int setjmp(jmp_buf env)

A setjmp makró az env változóba elmenti az állapotinformációt. Az elmentett információ a longjmp makró hívásakor használható fel. A setjmp makrót közvetlenül híva a visszatérési értéke nulla. Ha a setjmp-ot a soron következő longjmp makró hívta, akkor a visszatérési értéke nem nulla. A setjmp hívása csak meghatározott programkörnyezetekben fordulhat elő, alapvetően a switch, if utasítások, ill. ciklusok ellenőrző részében és csak egyszerű relációs kifejezésekben. A setjmp használatát a következő programrészlet szemlélteti:

if (setjmp(env) == 0)
   /* a setjmp közvetlen hívása */
else
   /* itt következik a longjmp-on
   keresztüli setjmp hívás */

void longjmp(jmp_buf env, int ert)

A longjmp makró helyreállítja a korábbi setjmp makró hívásával elmentett, env változóban lévő állapotot, majd a végrehajtás úgy folytatódik, mintha egy setjmp makrót hajtanánk végre és a visszatérés egy nem nulla ert értékkel történik. A longjmp makróban lévő setjmp hívás nincs lezárva. A longjmp hívásakor értéket kapott objektumok értéke hozzáférhető marad, kivéve a setjmp hívásakor érvényben lévő nem volatile automatikus tárolási osztályú változókat, amelyek definiálatlanná válnak, ha az értékük a setjmp hívása után megváltozott.

B9. Jelzések kezelése: a <signal.h> header

A <signal.h> header lehetőséget nyújt a program végrehajtása során előforduló váratlan események, mint pl. külső forrástól érkező megszakításkérés, végrehajtási hiba stb., kezelésére. Az eseményt kezelő függvény általános alakja:

void (*signal (int sig, void (*handler) (int))) (int)

A signal függvény meghatározza, hogy a rendszer a soron következő jelzést hogyan fogja kezelni. Ha handler-nek a SIG_DFL lett megadva, akkor a gépi megvalósításban meghatározott alapfeltételezés szerinti kezelést végez, ha pedig a SIG_IGN lett megadva, akkor a jelzést figyelmen kívül hagyja. Minden más esetben a handler-ben megadott, a jelzés típusának megfelelő argumentummal hívott függvény végzi a jelzés kezelését. A megengedett sig jelzések:

SIGABRT program abnormális befejezése, pl. az abort függvénytől kapott jelzés;
SIGFPE aritmetikai hiba, pl. nullával való osztás vagy túlcsordulás;
SIGILL illegális függvényhívás, pl. illegális utasítás;
SIGINT interaktív jelzés, pl. megszakításkérés;
SIGSEGV illegális tároló-hozzáférés, pl. címzés a tárhatáron kívülre;
SIGTERM lezárási igény küldése a programhoz.

A signal függvény a megadott jelzéshez tartozó handler előző értékével vagy hiba esetén a SIG_ERR értékkel tér vissza. Amikor a sig jelzés bekövetkezik, akkor a signal függvény alapállapotba áll vissza, majd (*handler)(sig) formában létrejön a jelzést kezelő függvény hívása. A jelzést kezelő függvényből való visszatérés után a program végrehajtása ott folytatódik, ahol a jelzés megjelenésekor félbeszakadt. A jelzések kezdeti állapota a gépi megvalósítástól függ.

int raise(int sig)

A raise függvény a sig argumentummal megadott jelzést küldi a programnak. Ha a jelzés átadása sikertelen volt, akkor a visszatérési értéke nem nulla.

B10. Dátumot és időt kezelő függvények: a <time.h> header

A <time.h> headerben vannak deklarálva a dátummal és idővel kapcsolatos műveletekhez szükséges adattípusok és függvények. Néhány függvény a helyi időt dolgozza fel, amely különbözhet a naptári időtől, pl. más időzóna miatt. A clock_t és time_t az idő ábrázolására alkalmas aritmetikai adattípusok, és a struct tm a naptári idő komponenseit tartalmazza a következő felosztásban:

int tm_sec; a percet követő másodpercek, 0-tól 61-ig;
int tm_min; az órát követő percek, 0-tól 59-ig;
int tm_hour; az éjféltől eltelt órák száma, 0-tól 23-ig;
int tm_mday; a hónap napja, 1-től 31-ig;
int tm_mon; a január óta eltelt hónapok, 0-tól 11-ig;
int tm_year; az évszám 1900 óta;
int tm_wday; a napok vasárnap óta, 0-tól 6-ig;
int tm_yday; a január 1. óta eltelt napok száma, 0-tól 365-ig;
int tm_isdst; óraátállítás-jelző.

A tm_isdst pozitív, ha az óraátállítás érvényben van, nulla ha nincs érvényben és negatív, ha az erre vonatkozó információ nem áll a rendelkezésünkre.

A dátumot és időt kezelő függvények:

clock_t clock(void)

A clock függvény visszatérési értéke a program kezdete óta eltelt processzoridő, vagy ha ez nem áll rendelkezésünkre, akkor a -1 érték. A processzoridő a clock() /CLOCKS_PER_SEC összefüggéssel számolható át másodpercre.

time_t time(time_t *tp)

A time függvény visszatérési értéke az aktuális naptári idő, vagy -1, ha az nem áll a rendelkezésünkre. Ha tp nem NULL értékű, akkor a visszatérési érték a *tp helyen is eltárolódik.

double difftime(time_t time2, time_t time1)

A difftime függvény visszatérési értéke a time2 – time1 különbség másodpercben kifejezve.

time_t mktime(struct tm *tp)

Az mktime függvény a struktúra *tp helyén lévő helyi időt a time függvénynek megfelelő ábrázolású naptári idővé alakítja. Az idő egyes komponensei a leírtak szerinti tartományba fognak esni. A függvény visszatérési értéke a naptári idő, vagy -1, ha az nem ábrázolható a megfelelő formában.

A következő négy függvény statikus objektumhoz tartozó mutatóval tér vissza és ezek az objektumok más függvényhívásokkal felülírhatók.

char *asctime(const struct tm *tp)

Az asctime függvény a *tp strutúrában található naptári időt a

Sun Jan 3 15:14:13 1994\n\0

alakú karaktersorozattá alakítja.

char *ctime(const time_t *tp)

A ctime függvény a *tp címen lévő naptári időt helyi idővé alakítja. A függvény egyenértékű az asctime(localtime(tp)) függvényhívással.

struct tm *gmtime(const time_t *tp)

A gmtime függvény a *tp címen lévő naptári időt a koordinált univerzális idővé (UTC) alakítja. A függvény NULL értékkel tér vissza, ha az UTC nem áll rendelkezésre. A gmtime elnevezés történeti okokra vezethető vissza.

struct tm *localtime(const time_t *tp)

A localtime függvény a *tp címen található naptári időt helyi idővé lakítja.

size_t strftime(char *s, size_t smax, const char *fmt)

Az strftime függvény a *tp helyen található dátum- és időadatokat az fmt formátum szerint karaktersorozattá alakítja és elhelyezi az s karaktersorozatban. Az fmt formátumleírás megegyezik a printf függvény formátumleírásával. A formátumleírásban lévő közönséges karakterek (beleértve a lezáró \0 karaktert is) átmásolódnak az s karaktersorozatba, a %c alakú elemek pedig a következőkben leírtak szerint, a helyi operációs rendszer megfelelő értékeit felhasználva helyettesítődnek. Az s karaktersorozatban legfeljebb smax számú karakter helyezhető el. Az strftime függvény visszatérési értéke az s-ben elhelyezett karakterek száma (beleértve a lezáró \0 karaktert is), vagy nulla, ha smax-nál több karaktert kívántunk elhelyezni. A %c alakú formátumspecifikációk:

%a a nap neve, rövidítve;
%A a nap neve, teljesen kiírva;
%b a hónap neve, rövidítve;
%B a hónap neve, teljesen kiírva;
%c helyidátum- és helyiidő-ábrázolás;
%d a hónap napja számmal (01…31);
%H az óra (24 órás kiírás, 00…23);
%I az óra (12 órás kiírás, 01…12);
%j az év napja számmal (001…365);
%m a hónap számmal (01…12);
%M a perc (00…59);
%p az AM vagy PM helyi megfelelője (pl. de vagy du);
%S a másodperc (00…61);
%U a hét sorszáma az évben (a hét első napjának a vasárnapot tekintve, 00…53);
%w a hét napja számmal (vasárnap a 0., 0…6);
%W a nap sorszáma az évben (a hét első napjának hétfőt tekintve, 000…365);
%x helyidátum ábrázolás;
%X helyiidő-ábrázolás;
%y az évszám, évszázad nélkül (00…99);
%Y az évszám évszázaddal;
%Z az időzóna elnevezése, ha van;
%% % jel.

B11. A gépi megvalósításban definiált határértékek: a <limits.h> és <float.h> headerek

A <climits.h> headerben vannak az egész típusú adatok méreteit megadó állandók definiálva. Az itt megadott értékek a szabvány szerint szóba jöhető minimális nagyságot jelentik, ezeknél nagyobb értékek is használhatók az egyes gépi megvalósításokban.

B.3. táblázat. Az egész típusú adatok méretét meghatározó állandók
Azonosító Érték Jelentés
CHAR_BIT 8 a bitek min. száma egy char típusú változóban
CHAR_MAX UCHAR_MAX vagy SCHAR_MAX egy char típusú változóban tárolható max. érték
CHAR_MIN 0 vagy SCHAR_MIN egy char típusú változóban tárolható min. érték
INT_MAX +32767 egy int típusú változóban tárolható max. érték
INT_MIN -32767 egy int típusú változóban tárolható min. érték
LONG_MAX +2147483647 egy long típusú változóban tárolható max. érték
LONG_MIN -2147483647 egy long típusú változóban tárolható min. érték
SCHAR_MAX +127 egy signed char típusú változóban tárolható max. érték
SCHAR_MIN -127 egy signed char típusú változóban tárolható min. érték
SHRT_MAX +32767 egy short típusú változóban tárolható max. érték
SHRT_MIN -32767 egy short típusú változóban tárolható min. érték
UCHAR_MAX 255 egy unsigned char típusú változóban tárolható max. érték
UINT_MAX 65535 egy unsigned int típusú változóban tárolható max. érték
ULONG_MAX 4294967295 egy unsigned long típusú változóban tárolható max. érték
USHRT_MAX 65535 egy unsigned short típusú
változóban tárolható max. érték

A következő táblázat a <float.h> headerben definiált, a lebegőpontos aritmetikával kapcsolatos állandók egy részét tartalmazza. A megadott értékek itt is a szabvány szerinti minimumot jelentik, az egyes gépi megvalósítások más, ennél nagyobb értéket is megengedhetnek.

B.4. táblázat. A valós típusú adatok méretét meghatározó állandók
Azonosító Érték Jelentés
FLT_RADIX 2 a lebegőpontos számábrázolásban a számrendszer alapszáma
FLT_ROUNDS lebegőpontos kerekítési mód összeadásra
FLT_DIG 6 float típusú szám decimális számjegyekben mért pontossága
FLT_EPSILON 1E-5 az a legkisebb float típusú x szám, amelyre 1.0+x != 1.0
FLT_MANT_DIG az FLT_RADIX számrendszerű ábrázolásban a mantissza számjegyeinek száma
FLT_MAX 1E+37 egy float típusú lebegőpontos szám max. értéke
FLT_MAX_EXP az a max. n szám, amelyre az FLT_RADIXn-1 még ábrázolható
FLT_MIN 1E-37 egy normál float típusú lebegőpontos szám min. értéke
FLT+MIN+EXP az a min. n szám, amelyre 10n egy normált számot ad
DBL_DIG 10 double típusú szám decimális számjegyekben mért pontossága
DBL_EPSILON az a legkisebb double típusú x szám, amelyre 1.0+x != 1.0
DBL_MANT_DIG az FLT_RADIX számrendszerű ábrázolásban a mantissza számjegyeinek száma
DBL_MAX 1E+37 egy double típusú lebegőpontos szám max. értéke
DBL_MAX_EXP az a max. n szám, amelyre az FLT_RADIXn-1 még ábrázolható
DBL_MIN 1E-37 egy normált double típusú lebegőpontos szám min. értéke
DBL_MIN_EXP az a min. n szám, amelyre 10n egy normált számot ad
A. FÜGGELÉK Tartalom C. FÜGGELÉK

 



megosztom