*p2; Programozás II. Horváth Ernő

Átírás

1 Programozás II. Horváth Ernő

2 ANSI C adattípusok Cím szerinti paraméter átadás Mutatók Mutatók és tömbök Mutatótömbök Dinamikus memóriakezelés Malloc, Calloc, Free, Realloc Random Typedef, Struktúrák State machine állapotgép Linked list (láncolt lista) Fájlkezelés Helyi beállítások Időkezelés Feladat char * 01 Feladat char * 02 Feladat valós zámok tömbbe mutatókkal Feladat memóriafoglalás Feladat - Dinamikus tömb 02 Feladat - Dinamikus tömb 03 Feladat - törlés láncolt listából Feladat - láncolt lista megfordítás Feladat fájlolvasás Feladat - függvénymutató Összes feladatmegoldás Összes feladatleírás

3 Elérhetőségek Hatwágner Ferenc Miklós Horváth Ernő Tanszéki honlap

4 A félév 1-3. hét Karaktermutatók. Karakterlánc (string) kezelő függvények. Mutatótömbök. Többdimenziós tömbök. Dinamikus memóriakezelés. Tömbök, mint függvényparaméterek. Parancssori paraméterek. Függvénymutatók. Typedef. Algoritmusok: Pontosan ellenőrzött bemenet hét Struktúrák és függvények. Uniók. Bitmezők. Névterületek. Struktúratömbök pontokhoz, dátumkezeléshez. Dinamikus adatszerkezetek: listák, fák 6-7. hét Magas szintű (stream) bemenet, kimenet. Változó paraméter lista. Fájlok másolása, egyesítése, középre igazítás hét Helyi beállítások, széles karakterek, karakterláncok, időkezelés hét Alacsony szintű (leírós) fájlkezelés. Könyvtárak kezelése, folymatok (process) cső (pipe) kezelése. Jelkezelés (signal), foglalatok (socket).

5 Követelmények Vizsga Vizsgaidőszakban Alapfeladat 2es, minden plusz feladat után egy jeggyel jobb az érdemjegy, de az alapfeladatnak működnie kell szintaktikai hiba nélkül ZH nincs Beadandó feladat aláírásért» elearning.sze.hu Katalógus nincs

6 Kabinet használat Felhasználó név: EIK Jelszó nincs L:\ - írási jog, vizsgán ide kell a végső kódnak felkerülnie D:\ - írási jog C:\temp - ide érdemes dolgozni K:\GB_IN001_2 vizsgán, órán ezek a feladatok használhatóak

7 K meghajtó \\fs-kab.eik.sze.hu\szakkabinet\kozos\gb_in001_2_programozas_2

8 Tömör C kód mutatókkal On the first day of Christmas my true love ga ve to me a partridge in a pea r tree. On the second day of Christmas my true love ga ve to me two turtle doves and a partridge in a pea r tree. #include <stdio.h> main(t,_,a)char *a;{return!0<t?t<3?main(-79,-13,a+main(-87,1-_, main(-86,0,a+1)+a)):1,t<_?main(t+1,_,a):3,main(-94,-27+t,a)&&t==2?_<13? main(2,_+1,"%s %d %d\n"):9:16:t<0?t<-72?main(_,t, "@n'+,#'/*{}w+/w#cdnr/+,{}r/*de}+,/*{*+,/w{%+,/w#q#n+,/#{l,+,/n{n+,/+#n+,/#\ ;#q#n+,/+k#;*+,/'r :'d*'3,}{w+k w'k:'+}e#';dq#'l \ q#'+d'k#!/+k#;q#'r}ekk#}w'r}ekk{nl]'/#;#q#n'){)#}w'){){nl]'/+#n';d}rw' i;# \ ){nl]!/n{n#'; r{#w'r nc{nl]'/#{l,+'k {rw' ik{;[{nl]'/w#q#n'wk nw' \ iwk{kk{nl]!/w{%'l##w#' i; :{nl]'/*{q#'ld;r'}{nlwb!/*de}'c \ ;;{nl'-{}rw]'/+,}##'*}#nc,',#nw]'/+kd'+e}+;#'rdq#w! nr'/ ') }+}{rl#'{n' ')# \ }'+}##(!!/") :t<-50?_==*a?putchar(31[a]):main(-65,_,a+1):main((*a=='/')+t,_,a+1) :0<t?main(2,2,"%s"):*a=='/' main(0,main(-61,*a, "!ek;dc i@bk'(q)-[w]*%n+r3#l,{}:\nuwloca-o;m.vpbks,fxntdceghiry"),a+1);} On the third day of Christmas my true love ga ve to me three french hens, two turtle doves and a partridge in a pea r tree. On the fourth day of Christmas my true love ga ve to me four ca lling birds, three french hens, two turtle doves and a partridge in a pea r tree. On the fifth day of Christmas my true love ga ve to me five gold rings; four ca lling birds, three french hens, two turtle doves and a partridge in a pea r tree. On the sixth day of Christmas my true love ga ve to me six geese a-laying, five gold rings; four ca lling birds, three french hens, two turtle doves and a partridge in a pea r tree. On the seventh day of Christmas my true love ga ve to me seven swans a -swimming, six geese a-laying, five gold rings; four ca lling birds, three french hens, two turtle doves and a partridge in a pea r tree. On the eighth day of Christmas my true love ga ve to me eight maids a-milking, seven swans a -swimming, six geese a-laying, five gold rings; four ca lling birds, three french hens, two turtle doves and a partridge in a pea r tree. On the ninth day of Christmas my true love ga ve to me nine ladies dancing, eight maids a-milking, seven swans a -swimming, six geese a-laying, five gold rings; four ca lling birds, three french hens, two turtle doves and a partridge in a pea r tree. On the tenth day of Christmas my true love ga ve to me ten lords a-lea ping, nine ladies dancing, eight maids a-milking, seven swans a -swimming, six geese a-laying, five gold rings; four ca lling birds, three french hens, two turtle doves and a partridge in a pea r tree. On the e leventh day of Christmas my true love ga ve to me eleven pipers piping, ten lords a-lea ping, nine ladies dancing, eight maids a-milking, seven swans a -swimming, six geese a-laying, five gold rings; four ca lling birds, three french hens, two turtle doves and a partridge in a pea r tree. On the twelfth day of Christmas my true love ga ve to me twelve drummers drumming, eleven pipers piping, ten lords a-lea ping, nine ladies dancing, eight maids a-milking, seven swans a -swimming, six geese a-laying, five gold rings; four ca lling birds, three french hens, two turtle doves and a partridge in a pea r tree. Press any key to continue...

9 Pointerek, más néven mutatók A mutató olyan változó, amelyik memóriacímet tartalmaz. Létrehozása az indirekció operátorral (*) történik. int-re mutató típusos pointer: int * p; típus nélküli pointer: void * p; A változó nevéből a címképző (&) operátorral kaphatjuk meg a változó címét: int x,*p; p=&x; Forrás: A programozás alapjai - Pohl László, Budapest, 2010

10 Mutatók int n,*p; p=&n; n=6; printf("%d\n", n); // n helyett írhattunk volna *p-t is *p=5; printf("%d\n", n); // n helyett írhattunk volna *p-t is Futás: 6 5 p címe pl. 0x0028F8D8 értéke: 06

11 Cím szerinti paraméter átadás void ertekszerint(char x){ x = 22; } void cimszerint(char *x){ *x = 33; } Futás: void main(){ Ertek szerint: 1 char e = 1, c = 1; Cim szerint: 33 ertekszerint(e); cimszerint(&c); printf("ertek szerint: %d\ncim szerint: %d", e, c); }

12 Csere mutatókkal void csere(int *px, int *py){ int tmp; tmp = *px; *px = *py; *py = tmp; } //a módosítandó értékek címének átadása Main: int a=22, b=1020; csere(&a, &b); printf("%d", b); Futás: 22

13 NULL pointer A NULL pointer egy olyan speciális mutatót jelent, amely nem mutat semmilyen változóra. Bármilyen típusú pointer lehet NULL értékű. if (ptr!= NULL) printf("valahova mutat.\n"); if (ptr == NULL) printf("sehova sem mutat.\n"); if (ptr) printf("valahova mutat.\n"); if (!ptr) printf("sehova sem mutat.\n");

14 Mutatók és tömbök A mutatók jól használhatók tömbök bejárására, feldolgozására De a mutatók nem tömbök >> memória foglalás A tömbnevének [ ] nélküli leírása egyenértékű a 0 indexű elem címével. Például: tombom ugyanazt jelenti, mint &tombom[0]. char x[100]; char *m; m=&x[0]; m=x; *(m+1); // egyenértékű x[1]

15 Mutatók és tömbök példa int tombom[10]; *(tombom + 3) = 5; //vagy ugyanez másképp: tombom[3] = 5; int *p = tombom; *(p + 2) = 8; //ugyanez: p[2] = 8; Gyakorlatilag [] indexelő operátort használva címszámítást és indirekciót (dereferálást) is végzünk. A fordító a kezdőcímhez hozzáadja az adott típusnak megfelelően foglalt memóriarészeket, így éri el az adott elemet.

16 Feladat legnagyobb - mutatókkal int legnagyobb(int *tomb, int meret){ int n; int max; max=tomb[0]; for( n=1; n<meret; n=n+1 ) if( max<tomb[n] ) max=tomb[n]; return(max); } main(){ int t[5]; t[0]=49; t[1]=40; t[2]=22; } printf("legnagyobb=%d\n", legnagyobb(t, 3) ); getchar();

17 Feladatok char * 01 Készítse el az alább felsorolt, ismert C függvények mutatós változatát! A char * visszatérésű függvények az eredmény címével térnek vissza! Sor beolvasása a szabvány bemnetről: int getline(char s[], int lim) int getline(char s*, int lim) c karakter törlése a karakterláncból: void squeeze(char s[], int c) char *squeeze(char s*, int c) Karakterlánc egésszé konvertálása: int atoi(char s[]) int atoi(char s*))

18 Feladat fehér karakter Olvasson be a szabvány bemenetről egy karakterláncot! Egy alkalmas függvény segítségével alakítsa át úgy a beolvasott szöveget, hogy» eltávolítja belőle a fehér karaktereket,» és az első szó kivételével minden szó kezdőbetűjét nagyra,» az összes többi betűjét kisbetűre változtatja. Elegendő csak az angol abc jeleivel foglalkozni. Jelenítse is meg az eredményt! A programban a tömbök elemeinek elérésére mutatókat kell használni, indexelés nem fogadható el! Valami aaa BBB valamiaaabbbcccc CcCC extra1.c

19 Getline (mutatók nélkül) Szabvány bemenetről egy sor beolvasása. A sor karaktereit rendre elhelyezi az s karaktertömbben. A befejező soremelés karaktert nem viszi át a tömbbe, hanem helyette lánczáró '\0' t ír a karakterlánc végére. Legfeljebb lim karaktert tárol a tömbben, visszatérési értéke az s tömbben elhelyezett karakterlánc hossza.

20 int getline(char s[],int lim){ int c, i; } for(i=0; i<lim && (c=getchar())!=eof &&!='\n'; ++i) s[i]=c; s[i]='\0'; while(c!=eof && c!='\n') getchar(); return(i);

21 Getline s[] indexelése helyett a t mutatóval haladunk az s karaktertömbön. A t mindig a következő szabad helyre mutat a tömbben, melynek túlírását az n elfogyása akadályozza meg. n-->0 A karakterláncot záró '\0' címéből a tömb kezdőcímét kivonva, éppen a karakterlánc hosszát kapjuk: return(t-s)

22 int getline(char *s, int n){ int c; char *t=s; while(n-- > 0 && (c=getchar())!=eof && c!='\n') *t++ = c; *t='\0'; while(c!=eof&&c!='\n') c=getchar(); return(t-s); }

23 squeeze void squeeze(char s[], int c){ int i,j; for(i=j=0; s[i]!='\0'; i++) if(s[i]!=c) s[j++]=s[i]; s[j]='\0'; }

24 *squeeze char *squeeze(char *s, int c) c karakter törlése az s karakterláncból a saját helyén.

25 *squeeze main(){ char s[]="ebben vannak n-ek"; printf("%s\n",squeeze(s,'n')); getchar(); } char *squeeze(char *s, int c){ char *p,*t; p=s; t=s; while(*p){ if(*p==c) p++; else *s++=*p++; } *s=0; return(t); }

26 *squeeze char *squeeze(char *s, int c){ char *t, *ment=s; for(t=s; *s; ++s) if(*s!=c) *t++=*s; *t='\0'; return ment; }

27 A klasszikus atoi int atoi(char s[]){ } int i,n=0,sign=1; for(i=0;s[i]==' ' s[i]=='\n' s[i]=='\t'; ++i); if(s[i]=='+' s[i]=='-') sign=(s[i++]=='+')? 1 : -1; for(;s[i]>='0'&&s[i]<='9';++i) n=10*n+s[i]-'0'; return(sign*n);

28 Atoi mutatókkal int atoi(char *s){ int n=0, sign=1; for( ; isspace(*s); ++s); if(*s=='+' *s=='-') sign=(*s++=='+')? 1 : -1; for( ; isdigit(*s); ++s) n=10*n+*s-'0'; return(sign*n); }

29 atoi Eredeti: stdlib.h Karakterlánc egésszé alakítása (isspace >> ctype.h) Íjuk meg ennek is a mutatós változatát!

30 Feladat char * 02 Készítse el az alább felsorolt, ismert C függvények mutatós változatát! A char * visszatérésű függvények az eredmény címével térnek vissza! Karakterlánc nagybetűssé alakítása: void strupr(char s[]) char *strupr(char *s) továbbá strlwr Karakterlánc megfordítása helyben: void strrev(char s[]) char *strrev(char *s) Karakterlánc feltöltése c karakterrel: void strset(char s[], int c) char *strset(char *s, int c)

31 strrev (mutatók nélkül) void strrev(char s[]){ int i, j; char kar; for(i = 0, j = strlen(s)-1; i<j; ++i, --j){ kar = s[i]; s[i] = s[j]; s[j] = kar; } }

32 strrev s[0] s[1] s[2] s[3] s[4] s[5] s[6] s[7] s[8] s[9] a b c d x '\0' [i=0] 9 b c d x a '\0' [i=1] 9 8 c d x 6 7 b a '\0' [i=2] d X 6 c b a '\0' [i=3] x d c b a '\0'

33 String bejárása - mutatók char *s="szoveg"; for(;*s!='\0'; ++s) printf("%c\n", *s); vagy röviden: for(;*s; ++s) printf("%c\n", *s);

34 Feladat - strstr, strstnext Az strstr() függvény a második karakterlánc elsőbeli első előfordulásának címével tér vissza, ill. NULL mutatóval, ha a második karakterlánc nem található meg az elsőben. int index(char s1[], char s2[]) char *strstr(char *, char *) Készítsen char *strstrnext(char *, char *) függvényt, mely ugyanazt teszi, mint az strstr(), de egy static mutató segítségével az első hívás után a második karakterlánc következő elsőbeli előfordulásának címével tér vissza, és ezt mindaddig teszi, míg NULL mutatót nem kell szolgáltatnia. AZ elofordulasai AxxAZxAZxxxAyZ-ben: Megtalaltuk a 3 indexu helytol kezdodoen. Megtalaltuk a 6 indexu helytol kezdodoen. strnext.c strstr.c

35 Feladat - titkosítás Készítsen char* titkositas(char* nyiltszoveg, char* kulcs, int hossz) függvényt, ami a titkosítja a paraméterként kapott nyílt szöveget a második paraméter kulccsal, majd visszaadja az eredményt. (Az eredmény a nyílt szöveg helyén keletkezik.) A harmadik paraméter a nyiltszoveg jeleinek száma. A titkosítást úgy végzi, hogy a nyílt szöveg első betűjének ASCII kódját kizáró vagy kapcsolatba hozza a kulcs első jelének ASCII kódjával, aztán a nyílt szöveg második jelének kódját hozza kizáró vagy kapcsolatba a kulcs második jelének kódjával, és így tovább. Ha a nyílt szöveg rövidebb lenne, mint a kulcs, akkor nem kell a kulcs minden jelét felhasználni. Ha a kulcs rövidebb, mint a nyílt szöveg, akkor a kulcsnak ismét az első, második, stb. jelét kell használni. Készítsen programot a fv. kipróbálásához! Ebben olvassa be a nyílt szöveget, majd a kulcsot, aztán jelentesse meg a titkosított szöveget! Ezt követően a már titkosított szöveget titkosítsa ismét a kulccsal! Ennek hatására az eredeti nyílt szöveget kell visszakapni. Jelenítse meg ezt is a kimeneten! Természetesen ebben a programban is csak mutatók használata megengedett, a tömbök indexelése nem! Kód: ABCDEF A nyilt szoveg: Jelszo Kodolt szoveg: '/7?) A helyreallitott szoveg: Jelszo Extra2.c

36 Mutatótömbök Mutatókat tartalmazó tömbök Pl. stringeket is tárolhatunk így tömbben A main() argumentumlistája * * 0xfa0212 0xfc00c1 0xfc00b1 S z o v e g \0 A B \0 #include <stdlib.h> #include <stdio.h> void ir( int ennyit, char **ezt ){ int n; for(n=0; n<ennyit; ++n ) printf("%s\n", ezt[n] ); } main(){ char *tomb[3]; tomb[0]="szoveg"; tomb[1]="ab"; tomb[2]="xyz"; ir(2, tomb ); getchar(); } 0xfc0012 x y \0.. []

37 A main() argumentumlistája Parancssori argumentumok fogadása Minden C programban kell lennie egy a programot elindító függvénynek, mely konzol bázisú alkalmazások esetében a main függvény. A paraméterek elhagyhatóak és nem ANSI szabványosak. Project properties >> Debugging >> Command arguments #include <stdio.h> int main( int argc, char *argv[] ){ int n; for(n=0; n<argc; ++n) printf( "%s ", argv[n] ); printf("\n"); return(0);}

38 *argv[] Az argv a paraméter karakterláncokra mutató mutatótömb, ahol az egyes elemek rendre: argv[0]: A futó program (meghajtó névvel és) úttal ellátott azonosítójára mutató mutató. argv[1]: Az első parancssori parameter karakterlancara mutató mutató. argv[2]: Az második paraméter karakterlánc kezdőcíme. argv[argc - 1]: Az utolsó parancssori paraméter karakterláncára mutató mutató. argv[argc]: NULL mutató.

39 A printf utolsó, *argv++ kifejezése Az argv t a main paraméterként kapja, tehát csak címmásolat, vagyis a main ben akár el is rontható. Az argv típusa char **, és funkcionálisan a parancssori paraméter karakterláncok kezdőcímeit tartalmazó mutatótömb kezdetének cime. A rajta vegrehajtott indirekcióval a típus char * lesz, és épp a mutatótömb első elemet (argv[0]) érjük el. Az utótag ++ operator miatt eközben az argv mar a második mutatótömb elemre (argv[1]) mutat. Elérjük ezt is, es mellékhatásként az argv megint előbbre mutat egy tömbelemmel. Tehát a ciklusban rendre végigjárjuk az összes parancssori paramétert.

40 Függvény (kód) mutató A C nyelvben a mutatóknak két fajtája van: (adat) objektumra mutató mutatók és függvényre (kód) mutató mutatók void doublerendez(double tomb[], int meret, int (*kisebb_e)(double a, double b)); int kisebb(double a, double b) { return a < b;} int abszolutkisebb(double a, double b) { return fabs(a) < fabs(b);}... doublerendez(tomb, 10, kisebb); doublerendez.c

41 Feladat - függvénymutató Írjunk függvényt, amely paraméterként kap egy double elemekből álló tömböt, és rendezi azt! A rendezés szempontja (növekvő, csökkenő, abszolútérték szerint növekvő stb.) is legyen a függvény paramétere! void doublerendez(double tomb[], int meret, int (*kisebb_e)(double a, double b)) doublerendez.c

42 Dinamikus memóriakezelés A C fordító a memóriát három részre osztja: 1. heap segment» dinamikus adatterület» dinamikusan, futásidőben foglalt, változó méretű memóriablokkok 2. stack segment» verem adatterület» lokális objektumok, függvények paraméterei 3. data segment» elsődleges adatterület» globális objektumok, konstansok, statikus objektumok Az stdlib.h fejfájl dinamikus memóriakezelést megvalósító függvényei: void *malloc(m), void *calloc(a,b), void free(void *memória), void realloc(c,m) stb. Heap Stack Static / global Code (text)

43 Dinamikus memóriakezelés #include <stdio.h> #include <stdlib.h> int globeredmeny; int negyzet(int x) { return x*x; } int negyzosszeg(int x, int y) { return negyzet(x + y); } Stack Global Heap void main(){ int a = 1, b = 2, *p; globeredmeny = negyzosszeg(a, b); p = (int*)malloc(sizeof(int)); *p = globeredmeny; printf("p ereteke: %d", *p); free(p); } p = (int*)malloc (sizeof(int)) negyzet x negyzosszeg x, y main() a, b int globeredmeny; free(p); negyzosszeg x, y main() a, b main() a, b Heap Stack (verem) Static / global Code (text) Forrás: mycodeschool

44 void *malloc(m), void *calloc(a,b) A malloc-nak egy paramétere van: hány bájtot szeretnénk lefoglalni. Ezzel szemben a calloc-nak két paramétere van, és a kettő szorzata adja a kívánt bájtszámot. A malloc által lefoglalt memóriaterület memóriaszemetet tartalmaz, azaz a dinamikusan lefoglalt változó kezdeti értéke bármi lehet, ahogyan ezt az egyszerű, nem dinamikus változóknál is megszoktuk. A calloc ezzel szemben a lefoglalt terület minden bájtját kinullázza. NULL-lal tér vissza hiba esetén.

45 void free(void *memória), void realloc(c,m) A free a malloc által lefoglalt területet szabadítja fel. Első paramétere az a mutató, amit még a malloc adott vissza. A realloc a lefoglalt terület méretét változtatja meg. Első paramétere a memóriacím, második pedig az új méret.

46 memcpy, memccpy void memcpy(void *cél, const void *forrás, size_t db); a memóriaterület tartalmát másolhatjuk át void memccpy(void *cél, const void *forrás, int keres, size_t db); a memóriaterület tartalmát másolhatjuk át, adott méret vagy hatójel alapján

47 memmove, memset <string.h> void *memmove(s, ct, n) A memmove hasonló a memcpy függvényhez, de egymást átfedő objektumok esetén is használható. void *memset(s, c, n) A memset elhelyezi a c karaktert az s első n karakterében és visszatérési értéke az s mutatója.

48 Figyeljünk az érvénytelen mutatókra! Súlyos és veszélyes programozási hiba az érvénytelen mutatók használata, például egy free() parancs után. Elképzelhető, hogy elsőre működik a program, mert a felszabadított memóriaterületen még megtalálható a helyes érték. Például hibás kódrészlet: char *fuggveny() { char c = 'a'; return &c; // hiba! } char *p = fuggveny(); // hiba!

49 sizeof A sizeof egyoperandusos magas prioritású művelet, mely az operandusa tárolásához szükséges memória mennyiségét szolgáltatja bájtban. sizeof(egyoperandusos-kifejezés) pl. sizeof(tomb) sizeof(típusnév) pl. sizeof(int) Az egyoperandusos kifejezés típusát a fordító a kifejezés kiértékelése nélkül határozza meg, azaz ha az operandus tömbazonosító, az egész tömb bájtokban mért helyfoglalásához jutunk.

50 2d tömb indexelése int tomb2d[2][4]={{1,2,3,4},{5,6,7,8}}; Indexelés: tomb2d[i][j] máshogy: *(tomb2d[i] + j) (*(tomb2d + i))[j] *((*(tomb2d tomb2d+ i)) + j) *(&tomb2d[0][0] + 4*i + j) Tömbreprezentáció: A memóriában, sorfolytonosan:

51 Feladat - dinamikus mátrix Allokáljon memóriát egy n x n méretű int típusú adatokat tartalmazó mátrix számára, a főátlót töltse fel egyesekkel, a többi elem legyen nulla. Jelezze is ki az értékeket. Főátlónak a bal felső és a jobb alsó sarkot összekötő átlót hívjuk. A példa n = 5 esetét mutatja. 'dinmtx' elemei: dinmatrix01.c

52 Feladat - 2d dinamikus tömb Írjon olyan függvényt, amely cím szerint átvett paraméterben adja vissza a lefoglalt 2D dinamikus tömbre mutató pointert! void foglal(float ***ptomb, int szeles, int magas) Figyeljünk arra, ha a változó típusa float **, akkor a címének típusa float ***, így cím szerinti paraméterátadásnál is így kell használni. dinmatrix02.c

53 Feladat - 2d dinamikus tömb megoldás void foglal(float ***ptomb, int szeles, int magas) { float **uj; int y, z; uj = (float**)malloc(magas * sizeof(float*)); for (y = 0; y < magas; ++y){ uj[y] = (float*)malloc(szeles * sizeof(float)); for(z = 0; z < szeles; ++z){ uj[y][z] = (float)(y + z); //printf("%.1f\n", uj[y][z]); } } *ptomb = uj; // *ptomb >> a float** típusú változó! }

54 Feladat - Mátrix elemei és címeik 'dinmtx' elemei (es cimeik): dinmtx[0]: (00825AB8) [0][0]=1 (0082A748) [0][1]=2 (0082A74C) [0][2]=3 (0082A750) dinmtx[1]: (00825ABC) [1][0]=4 (0082A790) [1][1]=5 (0082A794) [1][2]=6 (0082A798) dinmtx[2]: (00825AC0) [2][0]=7 (0082A7D8) [2][1]=8 (0082A7DC) [2][2]=9 (0082A7E0) dinmatrix03.c

55 Random - Véletlenszám #include <stdio.h> #include <time.h> #include <stdlib.h> #define MAX 20 void main(){ int r = 0, i; srand(time(null)); for(i=0; i<20; i++){ r = (rand() % MAX); printf("%d\n", r); } getchar(); } Álvéletlen számok (pseudo-random numbers)

56 Random - Véletlenszám A véletlenszám-generátor használata: program elején inicializálni kell (srand) egyszer, és utána a rand() ad egy véletlen számot. A %100 hatására között lesz, ehhez 1-et adva kapjuk az tartományt. A működéshez a stdio.h, time.h, stdlib.h headerek szükségesek. srand(time(null)); r = rand()% ;

57 Feladat - mátrix összeadás Készítsen programot két mátrix összeadására! A mátrixoknak foglaljon helyet a memóriában! A mátrixok mérete azonban csak futás időben dől el. A számok beolvasásához felhasználható az int getint(int *) függvény, de feltétlenül lássuk el minimális inputellenőrzéssel! mtx.c

58 Feladat - Bűvös mátrix (magic square) Olyan (ált. 1 és n 2 közötti) egész számokat tartalmazó négyzetes mátrix, melynek minden sorösszege, minden oszlop összege, főátlójában és mellékátlójában lévő számok összege azonos Buvos matrix? Igen Buvos matrix? Nem buvosmatrix.c

59 Feladat - Sudoku generálás Generáljunk egy 9 x 9-es tömböt, úgy, hogy 1-től 9-ig legyenek benn számok, de tetszőleges sorban, oszlopban mindegyik szám csupán egyszer forduljon elő. Megjegyzés: a játékban ennél több szabály van. Megoldható *p és **p megvalósítással sudoku1d.c sudoku2d.c

60 2D tömb megvalósítások 1. Sorfolytonosan 2. Soronkénti foglalás 3. Leképezés és mutatótömb "jagged array"

61 Soronkénti foglalás egydimenziós mutatótömbbel #include <stdio.h> #define MERET 3 void main(){ char* muttomb[meret] = {"Egy","két","há"}; int i; printf("'muttomb' elemei: \n"); for (i = 0; i<meret; i++) printf("%s (%p) (%p)\n", muttomb[i], &muttomb[i], &muttomb[i][0]); printf("\n"); getchar(); } 'muttomb' elemei: Egy (0114FE18) ( ) két (0114FE1C) ( C) há (0114FE20) ( ) Memóriában: 0x0114FE18: c cccccccc 0x : e96b 0000e d27 0x : Egy.két.há.. 0x C: két.há...x 0x : há...xxxxx

62 Feladat valós számok tömbbe, mutatókkal Készítse el a PELDA24.C-hez hasonlóan a valós számok tömbbe olvasását és visszaírását! Az int getint(int*) függvény int getfloat (float *)-ra változtatandó! Az int bufp; lecserélendő char *bufp;-re! Tegyünk legalább annyi inputellenőrzést a getfloat-ba, hogy legalább egy numerikus karakter meglétét megkövetelje, ill. konvertálhatatlan karakterek esetén ürítsük ki a bemeneti puffert a legközelebbi fehér karakterig!

63 Struktúrák Összetett adattípus, mint a tömbök, de nem csak egyféle típus alkothatja őket Változók csoportjának egyszerűbb kezelése Lehetőségek:» hozzárendelés (másolás)» átadhatók függvénynek paraméterként» lehet függvény visszatérési értéke» képezhető méretük (sizeof) és címük (&)» nem lehetséges: összehasonlítás (csak tagonként)» struktúratag szinte bármiből lehet

64 Struktúrák #include <stdio.h> struct Pont{ int x; int y; int z; char nev[32]; }; void main(){ struct Pont p1, p2; p1.x=8; p1.y=5; } A ; nem véletlen a struktúrák után.

65 Typedef #include <stdio.h> typedef int egesz; void main(){ egesz e = 42; printf("e=%d\n", e); } Új típust a typedef kulcsszóval vezethetünk be. Az egesz típus közvetlenül az int típusból származik. Persze ez így még nem túl hasznos.

66 Typedef és struktúra #include <stdio.h> struct Pont{ int x; int y; int z; }; typedef struct Pont pont; int kiir( pont *p ){ printf("x=%d\ny=%d\nz=%d\n",p->x, p->y, p->z); } void main(){ pont p1, p2; p1.x=1; p1.y=42; p1.z=84; kiir(&p1); } A Pont egy struktúra, a pont pedig típusdefiníció. A ; nem véletlen a struktúrák után. typedef struct Pont { int x; int y; int z; } pont; Elhagyható névtelen struktúra.

67 Struktúrák typedef struct { //egy pont a síkban double x; double y; } Pont; typedef struct { //szakasz két pont közt Pont eleje; Pont vege; } Szakasz; typedef struct { //középpont és sugár Pont kozeppont; double sugar; } Kor;

68 Structure dereference operator Structure dereference (röviden: nyíl) operátor jelentése a mutató által mutatott struktúra adattagja. Egyrészt dereferál, másrészt adattagot is kiválaszt, így rövidebb. (*p).adattag vagy rövidebb jelöléssel: p->adattag A pont "." adattag kiválasztó operátor nagyobb precedenciájú, mint a "*" índirekció operátor. Ezért is kell zárójelezni, a nyíl operátor erre ad könnyebb módot.

69 Feladat - szakasz Írjon programot, mely a jelzett adatstruktúrákat használja. Egy double szakaszhossza(szakasz *sz) prototípusú függvény visszatérési értékeként számolja ki a megadott szakasz hosszát! typedef struct{ double x; double y; }Pont; //szakasz két pont közt typedef struct{ Pont eleje; Pont vege; }Szakasz; Megoldás: szakasz.c

70 Feladat - osztálytárs Írjon programot, mely a jelzett adatstruktúrákat használja. A feladatban tartsuk számon, hogy az osztálytársak kit tartanak a legjobb barátjuknak. Írjon függvényt, mely kiírja, hogy az adott személy barátsága kölcsönös-e. Továbbá listázza az összes személy barátait. typedef struct{ char nev[32]; int legjobbbarat; } diak; // strukturákból alló tömb diak osztalytarsak[10]; // kölcsönös-e a barátság int kolcsonos(int szemely){ if (osztalytarsak[osztalytarsak[szemely].legjobbbarat].legjobbbarat = szemely) return 1; else return 0; } Megoldás: osztalytars.c

71 Feladat - Dinamikus tömb 02 Írjon programot, amely bekéri, egy sokszög csúcsainak számát, ezután pedig egyesével a csúcsok koordinátáit! A koordinátákat egy struktúrában tárolja, melynek dinamikusan foglaljon memóriát. Inputellenőrzés! (lebege, egesze) typedef struct{ double x, y; } Pont; Pont *sokszog; A struktúra méretét megadja az n*sizeof(pont) kifejezés. sokszog=(pont*)malloc(n*sizeof(pont)); Megoldás: dinstrukt02sokszog.c

72 Feladat - Dinamikus tömb 03 Írjon programot, amelyben egy int valogat(double *eredeti, int meret, double **ujtomb, int *ujmeret) függvény egy paraméterben kapott double tömbből kiválogatja az átlagnál kisebb értékeket, és egy újonnan lefoglalt dinamikus tömbbe rakja azokat! Az új tömb címével és méretével térjen vissza cím szerint átadott paraméterben! A visszatérési érték legyen IGAZ, ha sikerült a művelet, és HAMIS, ha nem. Megoldás: dinstrukt03valogat.c

73 Uniók Hasonlít a struktúrákra, de a tagok azonos tárcímen kezdődnek» az uniót címző mutató egyben valamennyi tagot is címzi (de a mutató típusok eltérőek lehetnek) Unió tárigénye = legnagyobb tag tárigénye #include<stdio.h> void main() { union byte { unsigned negy; unsigned short ket[2]; unsigned char egy[4]; } adat = { 0x Ful }; printf("'adat' cime: %p, merete: %lu byte\n" "'adat.negy' cime: %p, merete: %lu byte, erteke: %08x\n" "'adat.ket' cime: %p, merete: %lu byte, ertekei: %04x; %04x\n" "'adat.egy' cime: %p, merete: %lu byte, " "ertekei: %02x; %02x; %02x; %02x\n", &adat, sizeof(adat), &adat.negy, sizeof(adat.negy), adat.negy, &adat.ket, sizeof(adat.ket), adat.ket[0], adat.ket[1], &adat.egy, sizeof(adat.egy), adat.egy[0], adat.egy[1], adat.egy[2], adat.egy[3]); } 'adat' cime: 0037FD04, merete: 4 byte 'adat.negy' cime: 0037FD04, merete: 4 byte, erteke: f 'adat.ket' cime: 0037FD04, merete: 4 byte, ertekei: 070f; 0103 'adat.egy' cime: 0037FD04, merete: 4 byte, ertekei: 0f; 07; 03; 01

74 Linked list (láncolt lista) Olyan önhivatkozó adatszerkezet, ahol az egyes elemek láncba vannak fűzve azáltal, hogy tárolják a soron következő elem címét. typedef struct elem{ //egy listaelem unsigned adat; //nem csak egy elem lehet struct elem *kov; //itt még kell a struct } elem;

75 Egyszerű láncolt lista typedef struct elem { char nev[100]; //név unsigned eletkor; //életkor struct elem *kov; } elem_t; elem_t *kezd; kezd = malloc(sizeof(elem_t)); kezd->eletkor = 19; kezd->kov = malloc(sizeof(elem_t)); kezd->kov-> eletkor = 88; Megjegyzés: A typedef segítségével létrehozunk egy rövidebb nevet, a struktúrán belül mégis a struct kulcsszót kell használni, hiszen ott még nem létezik az alternatív név. Ebben az esetben tehát nem használhatjuk a névtelen struktúrát.

76 Láncolt lista bejárása 1. elem címe: eleje 2. elem címe: eleje->kov (*eleje).kov 3. elem címe: eleje->kov->kov (*(*eleje).kov).kov 4. elem címe: eleje->kov->kov->kov (*(*(*eleje).kov).kov).kov 0xcc6 0xcc1 0xcb0 0xcca ListaElem *eleje 0xcc xcc1 0xcb0 0xcca NULL

77 A lista bejárása ListaElem *iter; for (iter = eleje; iter!= NULL; iter = iter->kov) printf("%d ", iter->szam); ListaElem *iter Nézzünk erre egy példát! lancolt00alap.c 0xcc6 0xcc1 0xcb0 0xcca ListaElem *eleje 0xcc xcc1 0xcb0 0xcca NULL

78 Feladat láncolt lista létrehozás, bejárása Írjon rövid C programot, amely létrehozza a jelzett adatstruktúrában a láncolt listát, majd rendre kiíratja az elemeit. typedef struct Lista { int adat; struct Lista *kov; }Lista; [1] [0066A820] [0066A7D8] [17] [0066A7D8] [0066A790] [12] [0066A790] [0066A748] [14] [0066A748] [00665AB8] [8] [00665AB8] [ ] printf("[%d]\t[%p]\t[%p]\n", iter->adat, iter, iter->kov); lancolt00alap.c

79 Törlés láncolt listából Törlés a lista elejéről:» az előtte lévő mutató kov elemét az utána lévőre állítjuk» felszabadítjuk a törlendőt Törlés algoritmusa a lista belsejéből:» megkeressük a törlendő elemet» az előtte lévő mutató kov elemét az utána lévőre állítjuk» felszabadítjuk a törlendőt

80 Törlés tömbből/láncolt listából És ha ez sokkal több elem? [0] [1] [2] [3] [4] [5] Tömb Műveletigény? [0] [1] [2] [3] [4] X Láncolt lista Műveletigény?

81 Tömbök/láncolt listák tömbök előnye:» a sorfolytonos tárolás miatt közvetlenül címezhető» gyors adatelérés tömbök hátránya:» lassú átméretezés» nem ideális beszúrás/törlésintenzív feladatokra láncolt listák előnye:» gyors átméretezés: beszúrás, törlés láncolt listák hátránya:» nincs közvetlen elérés

82 Feladat - törlés láncolt listából Írjon programot, amely a beolvasott karakterláncokat (stringeket) láncolt listában tárolja el. Törölje ki belőle azokat, amelyek pontosan öt betűből állnak. typedef struct Szo { char szo[max+1]; struct Szo *kov; } Szo; Figyeljünk, arra, ha az első elemet szeretnénk törölni, a kezdőcím is megváltozik (sőt ha az első N darabot, akkor is). Gondoljuk át, hogy nézne ki az algoritmus láncolt listák helyett, többdimenziós tömbökkel. Megoldás: lancolt01torol.c

83 Beszúrás a lista elejére Amit tudnia kell a függvénynek: a lista elejére mutató pointert az új, eltárolandó adatot Az algoritmus: az új elemnek memóriát allokálni, adatait beállítani, a "kov" lesz az új lista elejére mutató pointer üres lista esetén az új elem egymaga lesz a lista meg kell tudnia változtatni az "eleje" mutatót, ezzel tér vissza Lista *lise = NULL; lise = listaelejere(lise, 5); lise = listaelejere(lise, 10);

84 Beszúrás a lista elejére //lista elejére tesz számokat Lista *listaelejere(lista *eleje, int adat) { Lista *uj=(lista*)malloc(sizeof(lista)); uj->kov = eleje; 0xcc1 uj->adat = adat; 0xcc1 eleje = uj; Lista *eleje return eleje; 0xcc6 0xcc1 } 0xcc6 Lista *eleje 0xcc xcb0 0xcca NULL 0xcb0 0xcb0 0xcca 0xcca Lista *uj 0xcb0 0xcca NULL

85 Beszúrás a lista végére 0xcc1 0xcb0 0xcca Amit tudnia kell a függvénynek: a lista elejére mutató pointert 0xcc1 az új, eltárolandó adatot Az algoritmus: az új elemnek memóriát allokálni, adatait beállítani, a "kov" értéke most NULL lesz üres lista esetén az új elem egymaga lesz a lista végigiterálunk a listán és megkeressük az utolsó elemet az utolsó elem "kov" mutatóját beállítjuk az új elem címére xcb0 0xcca NULL Lista *lisv = NULL; lisv = listavegere(lisv, 5); lisv = listavegere(lisv, 10); 0xcc1 0xcc1 0xcb0 0xcca 0xc xcb0 0xcca 0xc00 NULL

86 Beszúrás a lista végére //lista végére tesz számokat Lista *listavegere(lista *eleje, int adat) { Lista *mozgo, *uj; uj=(lista*)malloc(sizeof(lista)); uj->adat = adat; uj->kov = NULL; if (eleje == NULL)//üres lista? return uj; for(mozgo = eleje; mozgo->kov!=null; mozgo=mozgo->kov) ; //üres ciklus, megkeresi az utolsó elemet mozgo->kov = uj; return eleje; }

87 Feladat - láncolt lista megfordítás Fordítsunk meg egy listát az elemei átláncolása által. Írjon programot, mely számokat olvas be, és kiírja a keletkező listát eredeti sorrendjében (és ezáltal a számokat eredeti sorrendjükben), továbbá kiírja a megfordítottat is. Mindig a lista elejéről veszünk el egy elemet, majd a megfordított lista elejére betesszük azt, így a lista megfordul. Végül az eredeti lista elfogy, amint ez megtörténik, a megfordított lista kész. Megoldás: lancolt02megfordit.c Forrás: A programozás alapjai - Pohl László, Budapest, 2010

88 Láncolt lista megfordítása átrakott következő 3 Szam *listamegfordit(szam *lista) { Szam *eredeti=lista; Szam *megforditott=null; while (eredeti!=null) { Szam *atrakott=eredeti; Szam *kovetkezo=eredeti->kov; 1 atrakott->kov=megforditott;//új elejére be 2 megforditott=atrakott; 3 eredeti=kovetkezo;//régiből kihagy } return megforditott; } eredeti megfordított 2 1 Mindig a lista elejéről veszünk el egy elemet, majd a megfordított lista elejére betesszük azt, így a lista megfordul. Végül az eredeti lista elfogy, amint ez megtörténik, a megfordított lista kész.

89 Kétszeresen láncolt lista Doubly linked list Hátrafelé és előrefelé is be tudjuk járni» Az egyszeresen láncoltat csak előre Két plusz "strázsa" elem, amelynek nem tartalmaznak hasznos adatot, tehát a hasznos adatok listája az eleje ("első") strázsa utáni elemtől a vége ("utolsó") elemig tart. typedef struct elem{ unsigned adat; struct elem *kov, *elozo; } elem;

90 További listás megvalósítások queue, FIFO» first in, first out» pl. producer-consumer (termelőfogyasztó probléma) stack, LIFO» last in, first out» pl. syntax parsing circular list» pl. round-robin

91 State machine - állapotgép Az állapotgép egy gyakran használt tervezési minta (design pattern), A lényege, hogy az adott alrendszer csak egy állapotban lehet egyszerre, ebből az átmenetek és az egyes állapotok tevékenységei pontosan definiáltak. Megadható állapot és tevékenységtáblás, UML diagram és nem szabványos módokon.»

92 Forrás: A programozás alapjai - Pohl László, Budapest, 2010 Szövegfeldolgozó állapotgéppel Tegyük fel, hogy nem tudjuk, milyen hosszú egy sor» nem olvashatunk tömbbe egy sort» karakterenként olvassunk Szűrjük ki a /*-gal kezdőtő és */-ig tartó kommenteket Szöveg* valami /*komment ** és /*/ hh /*a*/ szöveg

93 4 állapotú state machine implementáció //state machine - állapotgép #include <stdio.h> typedef enum {normal,komment,cs_var,p_var} allapotok; int main(void){ int c; allapotok a = normal; //CTR+Z-ig while((c=getchar())!=eof){ switch (a){ case normal: if(c!='/')putchar(c); else a = cs_var; break; } case cs_var: if(c=='*') a = komment; else{ putchar('/'); if(c!='/'){ putchar(c); a=normal; } } break; case komment: if(c=='*') a = p_var; break; case p_var: if(c=='/') a = normal; else if(c!='*') a = komment; break; } } Forrás: A programozás alapjai - Pohl László, Budapest, 2010

94 Komment /* */ szűrő Állapottábla Állapot * / egyéb normál normál csillagra vár normál csillagra vár megjegyzés csillagra vár normál megjegyzés perre vár megjegyzés megjegyzés perre vár perre vár normál megjegyzés Tevékenységtábla Állapot * / egyéb normál másol nem másol másol csillagra vár nem másol előző / kiírása, nem másol előző / kiírása, másol Forrás: A programozás alapjai - Pohl László, Budapest, 2010

95 Komment /* */ szűrő egyéb, '*' '/' egyéb, '/' '*' normal cs_var megj p_var '/' '*' egyéb egyéb '*' '/' Az implementációba be lehet tenni egy plusz állapotot - végállapotot -, amibe bármikor elérhetünk EOF hatására.

96 Helyi beállítások locale.h fejfájl ANSI/ISO szabványos típusok, szimbolikus állandók és függvények használatához. Ország, nyelv, dátum formátuma, pénznem, stb. Ezeket az összetevőket helyi kategóriáknak nevezzük. Szimbolikus állandók, a program helyi információjának mely részéről van szó. A hely bizonyos vonatkozásait a könyvtári rutinok automatikusan kezelik. Például: strcoll, strxfrm. Más vonatkozások viszont kívül esnek a rutinok hatáskörén. Például a (hiba)üzenetek nyelve. Alapértelmezés a "C" hely, és programindításkor. char *setlocale(int kategoria, const char *locale);

97 Helyi beállítások Francia Kanadához ANSI alapértelmezett kódlapot állít. setlocale(lc_all, "French_Canada.ACP"); Francia Kanadához OEM alapértelmezett kódlapot állít. setlocale(lc_all, "French_Canada.OCP"); Alapértelmezés: setlocale(lc_all, "C"); setlocale(lc_all, NULL); Az operációs rendszer értékei: setlocale(lc_all, ""); A következő, két setlocale hívás funkcionálisan ekvivalens: setlocale(lc_all, "English"); setlocale(lc_all, "English_United States.1252");

98 Helyi beállítások A struct lconv tagjai leírják, hogyan kell formázni a numerikus és a pénzügyi értékeket, mint például a nemzetközi pénznem szimbólumát, a decimális pontot stb. A struct lconv *localeconv(void) az aktuális helyi numerikus és pénzügyi beállításokat egy statikus lconv struktúrában helyezi el, és visszaadja ennek címét. A setlocale kategória paramétere nem csak LC_ALL, hanem többek között LC_TIME (dátum és idő beállításokra hat) vagy LC_MONETARY (pénzügyi beállításokra hat) is lehet.

99 Helyi beállítások //Alapbeállítások printf("\nhely: %s\n", setlocale(lc_all, NULL)); printf("szam: %.2f\n\n", atof("3.14")); //Tizedespont //Alapértelmezett hely beállítása strcpy(puff, setlocale(lc_all, "")); printf("\nhely: %s\n", puff); printf("szam: %.2f\n\n", atof("3,14")); //Tizedesvessző // Tizedespont és pénznem karakter: plconv = localeconv(); printf("nem penzugyi decimalis pont: %s\n", plconv->decimal_point); printf("penznem szimbolum: %s\n", plconv->currency_symbol); // A hely visszaállítása C környezetre: setlocale(lc_all, "C"); Elérhető: helyi01.c

100 Karakterkódolás, ékezetek Az egybájtos karakterkódolások:» ASCII» 128 karakter, 7 bit (2^7 = 128)» Latin-1» másnéven ISO8859-1» az első 128 ugyanaz, mint az ASCII, de, utána még 96 betűt használ ( tartományban), így is belefér az egy bájtba (2^8 = 256)» nincs benn magyar ő és ű csak û és õ» Latin-2» hasonló a Latin-1-hez, de ebben a magyar ő és ű is megtalálható» Windows-1250» ez hasonlít a Latin-2-hez, többek közt a Windows szöveges fájok is használják, konzolos alkalmazásoknál előfordul, célszerű ezt használnunk C programok esetében.» OEM-852» konzolban szintén előfordulhat (a, de nem hasonlít a Latin- 2-höz

101 Karakterkódolás, ékezetek A többbájtos karakterkódolások:» Unicode» Az első 128 karaktere ugyanaz, az ASCII-é, de több, mint karaktert tartalmaz a világ majdnem összes nyelvén. 2 bájtos, így már nem fér bele a char adattípusba, egybájtosról viszonylag könnyen átalakítható kódolás, de vissza már kevésbé, hiszen egy Unicode karakter nem biztos, hogy létezik pl.: Latin-2-ben. További probléma, hogy a 2 bájtot nem minden architektúra ugyanabban a sorrendben tárolja. Ezt a BOM (byte order mark) hivatott jelezni, mely vagy 0xFEFF vagy 0xFFFE. (C90: wchar_t típus» 16 biten kódolja a karaktereket)» UTF-8» Változó méretű karakterkódolás, 1 bájtos egységeket használ, így nem csak sorrendben, de tényleges bináris kódban is kompatibilis az ASCIIvel, hiszen az egy bájtba beleférő értékeket egy bájton is tárolja.

102 Ajánlott beállítások Windows környezetre A magyar nyelvű Windowsban a programok nagy része Windows-1250 karakterkódolást használ, ez a Latin-2-vel sok hasonlóságot mutat. Első lépésként a Visual Studioban át kell állítanunk a forrásfájl kódlapját (File» Advanced Save Options) Ezután a konzol ki és bemeneti kódlapját kell átállítani. (Nem szabványos, Windows specifikus) #if defined(win32) defined(_win32) #include <windows.h> #endif #if defined(win32) defined(_win32) SetConsoleCP(1250); SetConsoleOutputCP(1250); #endif

103 Helyi beállítások és ékezetek #include <stdio.h> #include <stdlib.h> #include <string.h> #include <locale.h> #if defined(win32) defined(_win32) #include <windows.h> #endif void main() { struct lconv *plconv; char puff[256]; strcpy(puff, setlocale(lc_all, NULL)); plconv = localeconv(); // Beállítások nélkül printf("\nhely: %s\n", puff); printf("nem pénzügyi decimális pont: %s\n", plconv->decimal_point); printf("árvíztűrő tükörfúrógép\n\n"); // Op.rendszer által használt nyelvi környezet strcpy(puff, setlocale(lc_all, "")); plconv = localeconv(); printf("hely: %s\n", setlocale(lc_all, puff)); printf("nem pénzügyi decimális pont: %s\n", plconv->decimal_point); printf("árvíztűrő tükörfúrógép\n"); printf("pénznem szimbólum: %s\n", plconv->currency_symbol); // A konzolablak kódlapjának beállítása (out és in) #if defined(win32) defined(_win32) SetConsoleCP(1250); SetConsoleOutputCP(1250); #endif printf("gépeljen szöveget:\n\n"); getline(puff, 255); printf("a begépelt szöveg: [%s]", puff); getchar(); } Feltételezzük a magyar Windows operációsrendszert Hely: C Nem púnz³gyi decimßlis pont:. rvizt¹r t³k rf r¾gúp Hely: Hungarian_Hungary.1250 Nem pénzügyi decimális pont:, Árvíztűrő tükörfúrógép Pénznem szimbólum: HUF Gépeljen szöveget: AbcÁÉŰőö A begépelt szöveg: [AbcÁÉŰőö] Elérhető: helyi02.c

104 Magas szintű bemenet, kimenet Absztrakt módon, fájlok és eszközök (billentyűzet, képernyő, nyomtató, stb.) rugalmas, hasonló módon történő független kezelése ún. folyamok (stream) segítségével.

105 Fájlkezelés Az stdio.h-ban megadott FILE* típusú pointerrel és függvényekkel. FILE *fp; Megnyitás módja: írás (w) v. olvasás (r), szöveges (t) v. bináris (b), hozzáfűzés (a) írás és olvasás (w+) fp=fopen("t.txt", "wt"); Az fopen() visszatérési értéke: hivatkozás a nyitott fájlra. Sikertelen megnyitásnál értéke: NULL pointer ezt ellenőrizni kell. if (fp == NULL) printf("nem sikerült megnyitni!");

106 fopen - fclose FILE *fopen(const char *fajlazon, const char *mod); A függvény megnyitja a fajlazonnal megnevezett fájlt, és folyamot kapcsol hozzá. Visszaadja a fájlinformációt tartalmazó FILE struktúrára mutató pointert, mely a rákövetkező műveletekben azonosítani fogja a folyamot, ill. NULL mutatót kapunk tőle, ha a megnyitási kísérlet sikertelen volt. Az első paraméter legfeljebb FILENAME_MAX méretű karakter lehet. Lezáráshoz: int fclose(file *fp) - 0-t ad vissza siker esetén; EOF-ot, ha nem sikerült lezárni

107 Fájlok kezelése Szöveges c 6c 6f 2c c d 0a 30 0d 0a 31 0d 0a Hello, vilag! 0 1 fgets, fgetc, fscanf... Bináris 6c cc cc cc 55 8b ec 8b 45 0c 83 f b 0c c5 lìììu;>ì-ƒø.w#å4â Å fread, fwrite...

108 Szöveges fájlok A szövegfájlokat az fprintf()-fel és az fscanf()-fel lehet kezelni. Ezeknek első paramétere a megnyitott fájl, a folytatás pedig ugyanúgy van, mint printf()-nél és az scanf()-nél. Egyes rendszerek máshogy jelzik a szövegfájlokban a sorok végét ('\n'). Windowson két bájt, CR LF (0x0D 0x0A), Unixokon csak LF (0x0A), a fájlvég karakter pedig 0x1A C 6C 6F 2C C D 0A 30 0D 0A 31 0D 0A 1A Hello, vilag!x0dx0a 0x0Dx0A 1x0Dx0Ax1A

109 Bináris fájlok fp=fopen(nev, " b") fread(void *ptr, size_t elem_meret, size_t elem_szam, FILE *a_file); fwrite(const void *ptr, size_t elem_meret, size_t elem_szam, FILE *a_file); Lemezre történő kimenet esetén a folyam a sorlezáró '\n' karaktert "\r\n" karakter párral (CR-LF) helyettesíti. Megfordítva: lemezes bemenetnél a CR-LF karakter párból ismét LF karakter lesz. Ezt nevezzük transzlációnak. Ez csak szöveges fájloknál megy végbe binárisnál nem.

110 Pozícionálás A folyamokat rendszerint szekvenciális fájlok olvasására, írására használják. A magas szintű bemenet, kimenet a fájlt bájtfolyamnak tekinti, mely a fájl elejétől (0 pozíció) indul és a fájl végéig tart. A fájl utolsó pozíciója a fájlméret-1. Az adatátvitel mindig az aktuális fájlpozíciótól kezdődik, megtörténte után a fájlpozíció a fájlban következő, át nem vitt bájtra mozdul. A fájlpozíciót fájlmutatónak is szokás nevezni.

111 Fájlkezelő függvények fseek(fp, pozíció, honnan) Ugrás a bájtban megadott pozícióra. A honnan értékei: SEEK_SET=elejétől, SEEK_END=végétől, SEEK_CUR=aktuális pozíciótól számolva, a számozás itt is 0-tól kezdődik. ftell(fp) Az aktuális pozíció lekérdezése (bájtokban). fputc(c, fp), fgetc(fp) A putchar() és getchar() párja. fputs(str, fp), fgets(str, méret, fp) A puts() és a gets() párja. errno Globális változó, ami a legutolsó hiba kódját tartalmazza.

112 Fájlméret Írjunk fájlméretet megállapító függvényt! A fajlmeret elteszi a pillanatnyi pozíciót az aktpoz változóba, hogy a fájl végére állítás után helyre tudja hozni a fájlmutatót. A lekérdezett fájlvég pozíció éppen a fájlméret. #include <stdio.h> long fajlmeret(file *stream) { long aktpoz, hossz; aktpoz = ftell(stream); fseek(stream, 0L, SEEK_END); hossz = ftell(stream); fseek(stream, aktpoz, SEEK_SET); return(hossz); }

113 Getline és scanf megfelelői fájlokra char *fgets(char *s, int n, FILE *stream); Vegyük észre, hogy a jegyzet eleje óta használt getline függvény csak annyiban tér el az fgets től, hogy: A beolvasott karakterlánc méretét adja vissza. A szabvány bemenetről (stdin) olvas, s nem más folyamból, így eggyel kevesebb a paramétere. n karaktert hoz be legfeljebb, vagy '\n'-ig, de magát a soremelés karaktert nem teszi be az eredmény karakterláncba. int fscanf(file *stream, const char *format<, cim,...>); Az fscanf minden mezőt a format karakterláncnak megfelelően konvertál, es letárol rendre a paraméter címeken. A format karakterláncban ugyanannyi konverziót okozó formátumspecifikációnak kell lennie, mint ahány bemeneti mező van

114 Fájlolvasás - szöveges fájlok #include <stdio.h> #include <stdlib.h> void main() { FILE *f; char c; f=fopen("c:\\temp\\szoveg.txt","rt"); if(f!= NULL){ while((c=fgetc(f))!=eof){ printf("%c ",c); } fclose(f); } getchar(); } #include <stdio.h> #include <stdlib.h> void main() { FILE *f; char szoveg[100]; f=fopen("c:\\temp\\szoveg.txt","rt"); if(f!= NULL){ while((fscanf(f, "%s", szoveg))!=eof){ printf("%s\n", szoveg); } fclose(f); } getchar(); }

115 Fájlolvasás - szöveges fájlok #include <stdio.h> #include <stdlib.h> #include SORHOSSZ 200 void main() { FILE *f; char sor[sorhossz + 1]; f=fopen("c:\\temp\\szoveg.txt","rt"); if(f!= NULL){ while(fgets(sor,sorhossz,f)){ printf("%s ",sor); } fclose(f); } getchar(); } Karakter beolvasása: c=fgetc(f); Sor beolvasása: fgets(sor, HOSSZ, f); Szöveg beolvasása formázottan: fscanf(f,"%s", szoveg); fscanf(f,"%s %s %d",s1,s2,&szam);

116 Abszolút/relatív útvonal A fájlok elérési útvonala (path) megadható abszolút vagy relatív módon is. Pl: C:\Solution\Debug\Project.exe FILE *relative1; FILE *relative2; FILE *absolute; relative1 = fopen("myfile.txt","r"); relative2 = fopen("data\\myfile.txt","r"); absolute = fopen("c:\\tmp\\myfile.txt","r");

117 Feladat - fájlolvasás Adott egy szöveges állomány, amelyben angol szavak vannak, minden szó után egy szóköz áll. Írjunk programot, amely képernyőre írja azokat a sorokat (több ilyen is lehet), amelyekben a legkevesebb szó van! Feltételezhetjük, hogy a feldolgozandó állomány neve és helye c:\temp\szoveg.txt, és az állomány egyetlen sora sem tartalmaz 200-nál több karaktert. Megoldás: fajlolvasas06kevesebbszo.c

118 Feladat fájlolvasás CSV Olvasson be tetszőleges szöveges CSV állományt, ennek elérési útvonalát parancssori paraméterekkel lehessen megadni. Listázza az egyes mezőket rendre egymás utáni sorokban. A CSV fájlformátum szemléltetése Megoldás: fajlolvasas07csv.c

119 CSV beolvasás kovmezo függvénnyel char* kovmezo(char* sor) { } static char* mm = NULL; char *eleje, *vege; char idezet = 0; if (sor) mm = sor; else if (!mm) return NULL; eleje = vege = mm; while (*mm && (*mm!= ELVALASZTO idezet)) { } if (*mm == SZOVEGHAT) if (!idezet) idezet = 1; else if (*(mm + 1) == SZOVEGHAT) *vege++ = *mm++; else idezet = 0; else *vege++ = *mm; mm++; if (*mm) mm++; else mm = NULL; *vege = '\0'; return eleje; SZOVEGHAT» pl.: " vagy ' ELVALASZTO» pl.: ; vagy, Hívása pl.: while (fgets(sor, MAX, f)){ mezo = kovmezo(sor); while (mezo!= NULL) { printf("\t%s", mezo); mezo = kovmezo(null); } } fclose(f);

120 Feladat fájlolvasás CSV Adott egy szöveges csv állomány, pontosvesszővel tagolva. Keresse meg a Jani nevű felhasználót és írja ki a hozzá tartozó címet. Valósítsa meg ezt egy char* nevkeres(char *f, char *keresendostring) prototípusú függvénnyel. Feltételezhetjük, hogy a Jani létezik, további feladatként viszont készüljön fel minél több lehetséges hibára. (hosszú sorok, hibás fájl, nem elérhető, nem létező fájl, stb.) Megoldás: nevek02.c nevek01.c

121 Feladat - szöveges fájl1 írás #include <stdio.h> #include <stdlib.h> void main(){ FILE *f = fopen("c:\\temp\\szoveg.txt", "w"); if (f == NULL){ printf("hiba\n"); getchar(); } else { fprintf(f, "Szoveg.\nEs meg tobb szoveg."); fclose(f); } }

122 CSV fájlformátum Notepad szinusz1;szinusz2;koszinusz1 0,0500;0,1100;0,9988 0,0998;0,2598;0,9950 0,1494;0,2494;0,9888 0,1987;0,2587;0,9801 0,2474;0,3074;0,9689 0,2955;0,3155;0,9553 0,3429;0,4429;0,9394 0,3894;0,5000;0,9211 0,4350;0,5350;0,9004 0,4794;0,5194;0,8776 0,5227;0,5827;0,8525 Excel szinusz1 szinusz2 koszinusz1 0,05 0,11 0,9988 0,0998 0,2598 0,995 0,1494 0,2494 0,9888 0,1987 0,2587 0,9801 0,2474 0,3074 0,9689 0,2955 0,3155 0,9553 0,3429 0,4429 0,9394 0,3894 0,5 0,9211 0,435 0,535 0,9004 0,4794 0,5194 0,8776 0,5227 0,5827 0,8525 Coma Separated Values, szöveg alapú fájl

123 Feladat - szöveges fájl2 Írjon CSV fájlba szinusz, véletlenszámmal módosított szinusz és koszinusz értékeket. Figyeljen a helyi beállítások használatára (tizedes vessző!) szinusz1 szinusz2 koszinusz1 0,05 0,11 0,9988 0,0998 0,2598 0,995 0,1494 0,2494 0,9888 0,1987 0,2587 0,9801 0,2474 0,3074 0,9689 0,2955 0,3155 0,9553 0,3429 0,4429 0,9394 0,3894 0,5 0,9211 0,435 0,535 0,9004 0,4794 0,5194 0,8776 0,5227 0,5827 0, szinusz1 szinusz2 koszinusz1 Megoldás: fajliras02csv.c

124 Feladat szöveges fájl3 Hozzon létre a felhasználó által megadatott nevű fájlt, majd írjon bele egy sakktábla mintázatot a felhasználó által megadott mérettel. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Megoldás: fajliras03csillag.c

125 Feladat - szövegfájl egyesítés Készítsen programot, mely az indító parancssorban megadott szövegfájlokat egyesíti a megadás sorrendjében a parancssorban utolsóként előírt azonosítójú szövegfájlba! Ha parancssori paraméter nélkül indítják a programot, akkor ismertesse a képernyőn, hogyan kell használni! Ha csak egy fájlazonosító van a parancssorban, akkor a szabvány bemenet másolandó bele. A fájlok egyesítése során a folyamat előrehaladásáról tájékoztatni kell a képernyőn! A szabvány bemenet másolása esetén végül közlendő az eredményfájl mérete!

126 Feladat - szövegfájl Készítsen programot, mely eldönti az indító parancssorban megadott azonosítójú fájlról, hogy ASCII kódú szövegfájl-e, vagy bináris fájl-e! Ha parancssori paraméter nélkül futtatják a programot, akkor ismertesse a képernyőn a használatát!

127 Feladat szöveges fájl 8 Írjunk programot, amely egy létező szöveges állomány minden sorát 80 karakter hosszúságúra egészíti ki szóközökkel, ha a sorok 80 karakternél rövidebbek, és csonkítja őket a végükön, ha 80 karakternél hosszabbak! Az új sorokat egy új szöveges állományba kell írni. Megoldás: fajlolvasas08.c

128 Könyvtárak listázása #include <stdio.h> #include <io.h> #include <direct.h> #include <conio.h> #include <ctype.h> #include <string.h> void main(){ char path[50] = "C:\\temp"; struct _finddata_t fajllista; long hfile; if(mkdir("c:\\temp\\ujmappa")) fprintf(stderr, "Nem hozhato letre a mappa\n"); printf("listazzuk a %s tartalamt\n\n", path); if(_chdir(path)) fprintf(stderr, "Nem talalom: %s\n", path); else{ hfile = _findfirst("*.*", &fajllista); while(_findnext(hfile, &fajllista) == 0){ if(!strcmp(fajllista.name, "Program Files")!strcmp(fajlLista.name, "ujmappa")) printf("- %s\n", fajllista.name); else printf(" %s\n", fajllista.name); } } _findclose(hfile); } getchar();

129 Időkezelés ANSI/ISO szabványos függvények lekérdezik, tárolják, konvertálják, stb. az aktuális (rendszer) időt. Két típusuk:» Az időzónának megfelelő helyi idő.» Egyezményes (UTC) naptári idő, amit korábban greenwichi közép időnek (GMT) neveztek. Kezelése: time.h fejfájl. Típusok és típusok közti konverziók. Idők különbségei másodpercben double Jelmagyarázat: típusok time 1970 óta eltelt másodpercek time_t ctime Dátum, idő stringként char * függvények Dátum, idő struktúraként struct tm*

130 Időkezelés Több függvény osztozik két statikus élettartamú pufferen. Ezek: Az idő karakterlánc char * típusú, statikus karaktertömbben. Pontosan 26 karakteres: "Tue Jan 05 12:03: \n\0" formájú. 24-órás az időszámítás. Minden mező konstans szélességű. Az új sor és a lezáró null karakter mindig a vég. Az idő struktúra struct tm típusú struktúra, melynek tagjai int ek. A tagok:» tm_sec: Másodperc (0 59).» tm_min: Perc (0 59).» tm_hour: Óra (0 23).» tm_mday: Nap a hónapon belül (1 31).

131 Időkezelés Az idő struktúra tagjai még:» tm_mon: Hónap az éven belül (0 11, a január a 0).» tm_year: Év » tm_wday: A hét napja (0 6, a vasárnap a 0).» tm_yday: Napszám az éven belül (0 365, a január 1 a zérus).» tm_isdst: Nyári időszámítás jelző, mely pozitív, ha a nyári időszámítás hatályban van, és 0, ha nincs. Negatív a jelző, ha a nyári időszámítás állapota ismeretlen.

132 Időkezelés A time_t aritmetikai típus (többnyire long). A time_t time(time_t *sectime); függvény az aktuális rendszer időt január elseje éjfél óta eltelt másodpercek számában, time_t típusban szolgáltatja. A double difftime(time_t ido1, time_t ido0); visszaadja az ido1 és az ido0 naptári idők különbségét, azaz a közben eltelt időt másodpercekben.

133 Időkezelés size_t strftime (char *puffer, size_t maxmeret, const char *format, const struct tm *idoptr); size_t wcsftime (wchar_t *puffer, size_t maxmeret, const wchar_t *format, const struct tm *idoptr); Az strftime és a wcsftime függvények az idoptr mutatta, struct tm típusú időértéket megformázzák a format vezérlő karakterláncban előírtak szerint, és az eredmény karakterláncot elhelyezik a legfeljebb maxmeret karakteres puffer ben. A függvények között, hogy a különbség a puffer 1 vagy 2 bájtos karakter-e.

134 Időkezelés struct tm *gmtime (const time_t *ido); struct tm *localtime (const time_t *ido); A függvények a paraméter, time_t típusú, GMT (UTC, vagy egyezményes) idő értéket statikus, tm típusú struktúrába konvertálják, és ennek az idő struktúrának a címét visszatérési értékként szolgáltatják. Ha az ido érték január elseje éjfél előtti, akkor a rutinok NULL mutatót adnak vissza. A localtime korrigálja az időt a helyi időzónára, míg a gmtime ilyet nem tesz.

135 Időkezelés char *ctime (const time_t *ido); Az ido mutatta, time_t típusú időt alakítja a helyi időzóna beállításoknak is megfelelő idő karakterlánccá. A fenti függvény elhelyezi a statikus pufferben, és erre mutató mutatót ad vissza.

136 Időkezelés #include <stdio.h> #include <time.h> void main(){ int yy, mm, dd; struct tm when = {0}; char buffer[100] = ""; // dátum beolvasása sscanf_s(" ", "%d.%d.%d", &yy, &mm, &dd); when.tm_year = yy ; when.tm_mon = mm - 1; when.tm_mday = dd; mktime(&when); // kiíratás v1 strftime(buffer,80,"%y %b %d %I:%M%p -- %c\n", &when); printf(buffer); } // kiíratás v2 printf("%d.%d.%d (%d. nap)\n", when.tm_year, when.tm_mon + 1, when.tm_mday, when.tm_yday + 1); // nap növelése when.tm_mday+=1; mktime(&when); //kiíratás újra printf("%d.%d.%d (%d. nap)\n", when.tm_year, when.tm_mon + 1, when.tm_mday, when.tm_yday + 1); getchar(); 2015 Dec 31 12:00AM -- 12/31/14 00:00: (365. nap) (1. nap)

137 Várakozás [ms] #include <Windows.h> //így OS függő lesz Sleep(900); //900 ms = 0,9 másodperc #include <stdlib.h> _sleep(900); //obsolete elavult Más nyelveken általában delay, wait vagy sleep esetleg pause.

138 Várakozás [sec] #include <time.h> void sleep(clock_t sec) { clock_t ig = sec*clocks_per_sec + clock(); while (ig > clock()); } A clock_t clock(); függvény a hívó folyamat által elhasznált processzor időt szolgáltatja, a clock_t aritmetikai típus (többnyire long). A clock által visszaadott értékből úgy kapunk másodpercet, hogy elosztjuk a CLOCKS_PER_SEC szimbolikus állandóval. Tehát a fenti függvény sec másodpercet vár.

139 Feladat Nézzük az idok.c példaprogramot, amely illusztrálja jó néhány időkezelő függvény használatát januar 1. ota eltelt masodpercek szama: A UNIX ido es datum: Sun Apr 17 13:16: Az egyezmenyes ido: Sun Apr 17 11:16: oras ido: 01:16:18 du Karacsony Fri Dec 25 12:00: Karacsony + 10 nap: Mon Jan 4 12:00: January 4. Monday van a(z) Romance Standard Time idozonaban január 4. hétfo van a(z) Romance Standard Time idozonaban. Megoldás: idok.c

140 Változó paraméterlista Néhány fv. hívásonként eltérő számú paramétert fogad, pl.: int printf(const char *format,...); stdarg.h typedef char *va_list; #define _INTSIZEOF(x) ((sizeof(x)+sizeof(int)-1)&~(sizeof(int) -1)) #define va_start(ap, utsofix) (ap=(va_list)&utsofix+_intsizeof(utsofix)) #define va_arg(ap, tipus) (*(tipus *)((ap+=_intsizeof(tipus)) - _INTSIZEOF(tipus))) #define va_end(ap) ap = (va_list)0

141 Változó paraméterlista #include <stdio.h> #include <stdarg.h> void sum(char *uzen,...) { int osszeg = 0, tag; va_list param; va_start(param, uzen); while(tag = va_arg(param, int)) osszeg += tag; va_end(param); printf(uzen, osszeg); } void main() { sum(" = %d\n", 1, 2, 3, 4, 0); getchar(); }

142 Feladat változó paraméterlista 1 Írjunk egy változó paraméterszámú függvényt, amely összefűz tetszőleges számú sztringet, és az így kapott új sztringgel tér vissza! A függvény első paramétere az összefűzendő sztringek darabszáma, további paraméterei pedig maguk a sztringek. konkat(5, "Ez ", "egy ", "jó ", "hosszú ", "sztring!"); Megoldás: valtozoparam01.c

143 Feladat változó paraméterlista 2 Írjunk egy változó paraméterszámú függvényt, amely összefűz tetszőleges számú sztringet, és az így kapott új sztringgel tér vissza! A függvény legalább egy sztringet vár paraméterként, utolsó paraméterének a NULL pointernek kell lennie, ezzel jelezzük a paraméterlista végét. konkat("ez ", "egy ", "jó ", "hosszú ", "sztring", NULL); Megoldás: valtozoparam02.c

144 Numerikus integrálás húrtrapézformulával A trapéz szabály egy közelítő numerikus eljárás a határozott integrál meghatározására b න f x dx (b a) a f b + f(a) 2

145 Numerikus integrálás húrtrapézformulával න i i+1 f x dx T x[i] + x[i + 1] 2 dt * (x[i] + x[i+1]) / 2.0

146 Numerikus integrálás húrtrapézformulával න i i+1 f x dx T x[i] + x[i + 1] 2 // x - az integrálandó tömb // xsize - x mérete // dt - delta T a mintavételezés időköze double numintegraltrapez(double *x, int xsize, double dt){ int i; double result = 0; for(i = 0; i < xsize - 1; i++) result += (dt * (x[i] + x[i+1]) / 2.0); return result; }

147 Feladat - Szenergy A csatolt szenergy_2014_10_18_17_18_murcia.csv és szenergy_2014_10_17_16_06_rotterdam.csv táblázatos formában tartalmazza egyetemünk Szenergy hallgatói csapatának telemetriás adatait egy spanyol és egy holland versenyről. Feladatunk a rendelkezésekre álló adatokból a körönként megtett távolság kiszámítása. Mivel a fájl tartalmazza a körök számát is az értékekhez, így nem csak a verseny, de a körönkénti távolság is kiszámítható. Ezek közel azonos érték kellenek, hogy legyenek, de előzések és a pályán belüli eltérő nyomvonalak okozhatnak némi eltérést. Figyeljünk rá, hogy csak m/s-ből tudunk métert számolni. for (i = 0; i < recordnumber; i++) pspeedmps[i] = pspeedkmph[i] / 3.6; Megoldás: szenergy00.c szenergy01.c szenergy02.c

148 Lineáris és Lagrange interpoláció 35 Lineáris interpolált alappontok Lagrange interpolált alappontok

149 Feladat - interpoláció Vegyük a példaként is említett alappont-érték párosokat. x 0 = 1; y 0 = 10,3 x 1 = 2; y 1 = 18,956 x 2 = 3,3; y 2 = 12 x 3 = 5; y 3 = 30 Írjunk programot, amely a standard kimenetre kiírja 0,1-es lépésközzel az interpoláció értékeit mind Lagrange, mind lineáris módszerrel. Plusz feladatként írjuk csv fájlba az eredményt. Megoldás: interpolacio01.c

150 Lineáris és Lagrange interpoláció // *x - az interpolációs alappontok helye // *y - az interpolációs alappontok értéke // n - az interpolációs alappontok darabszáma (*y és *y tömb elemszáma) // x1 - a hely, ahol meg szeretnek kapni *y1 érteket int lininterp(double *x, double *y, int n, double x1, double *y1){ int i; for (i = 0; i < n - 1; i++){ if ((x[i] <= x1) && (x[i + 1] >= x1)){ *y1 = y[i] + (y[i + 1] - y[i]) / (x[i + 1] - x[i])*(x1 - x[i]); return 0; } } return 1; } int lagrangeinterp(double *x, double *y, int n, double x1, double *y1){ double p = 0.0, s; int i, j; for (i = 0; i < n; i++){ s = 1.0; for (j = 0; j < n; j++){ if (i!= j){ if (x[i] == x[j]) return 1; else s = s*(x1 - x[j]) / (x[i] - x[j]); } } p += y[i] * s; } *y1 = p; return 0; }

151 Header fájlok Kódfájlok (.c) függvények definíciói Fejlécfájlok (.h) mennek a függvények deklarációi #include <stdio.h> #include "sajat.h"» A két megadás között a különbség annyi, hogy más mappában keresi majd a fordító.

152 Header fájlok Az alábbi példában is a kódfájlokban (.c) a függvények definíciói, a fejlécfájlokban pedig (.h) a függvények deklarációi kaptak helyet. main.c oraifuggvenyek.h oraifuggvenyek.c #include <stdio.h> #include "oraifuggvenyek.h" void main(){ char s[21]; getline(s, 20); printf(s); } int getline(char *s, int n); opcionális #include <stdio.h> #include "oraifuggvenyek.h" int getline(char *s, int n){ int c; char *t = s; while (n-- > 0 && (c = getchar())!= EOF&&c!= '\n') *t++ = c; *t = '\0'; while (c!= EOF&&c!= '\n') c = getchar(); return(t - s); }

153 Feladat - autószerviz Egy autószerviz számítógépe minden megbízásról egy-egy sort ír a SZERVIZ.TXT fájlba. Egy sor a következő adatokat tartalmazza pontosvesszővel elválasztva: RENDSZÁM : 6 karakter TULAJDONOS NEVE : 40 karakter (legfeljebb 40) FORG. ENG. SZÁMA : 8 karakter DÁTUM : 11 karakter ( ) ÖSSZEG : 6 karakter (legfeljebb 6 karakter, egész szám) Írjon C programot, amely a SZERVIZ.TXT fájl alapján névsorban kiírja azoknak az autótulajdonosoknak a nevét, akik az átlagosnál többször javíttatták 2013 februárjában autójukat. A fájlt csak egyszer olvashatja be! Használjon dinamikus adat szerkezetet! Megoldás: szerviz.c

154 Feladat - címek Írjon egy olyan szabványos ANSI C programot, amely parancssori paraméterként kapja két szövegfájl nevet! Az első fájl egy weboldalt leíró html szöveg. A program gyűjtse ki a fájlban található címeket, melyeket aztán lista adatszerkezetben taroljon (egy címet elég egyszer eltarolni)! Az címek olyan karaktersorozatok, melyek az angol ABC kis- es nagybetűiből, számokból, pontokból (.), kötőjelekből(-) es aláhúzás (_) jelekből állnak, es kötelezően tartalmaznak pontosan karaktert. Az címben nem állhat egymás mellett két pont, valamint nem állhat egymás mellett egy pont es Minden egyéb, itt fel nem sorolt karakter elválasztó karakternek minősül. Egy cím hossza maximum 100 karakter. Ha ennél hosszabb, amúgy érvényes karaktersorozatra bukkanunk, azt ne tekintsük e- mail címnek! A nem cím karaktersorozatok hossza bármekkora lehet, ezek fix hosszúságú tömbben való eltarolása súlyos hibának minősül. A második parancssori paraméterként kapott szövegfájl minden sora egy-egy, korábban kigyűjtött címet tartalmaz. A program olvassa be az címeket, es fésülje össze a most talált címekkel, majd mentse el ugyanebbe a fájlba az összes címet abc sorrendben, minden címet csak egyszer taroljon!

155 _CRT_SECURE_NO_WARNINGS Project» Properties» Configuration properties» C/C++» Prepocessor _CRT_SECURE_NO_WARNINGS _CRT_NONSTDC_NO_WARNINGS Amennyiben a következő error fogad, akkor célszeű használni: "This function or variable may be unsafe."