Bevezetés a programozásba INF-501 A C programnyelv Informatikai Intézet Kógelmann Gábor

Bevezetés a programozásba A C programnyelv története B-nyelv, Ken Tompson, 1970. AT&T Bell Laboratories, UNIX operációs rendszer, DEC PDP-7 gép. B-nyelv  C-nyelv, Dennis Ritchie, 1971. (PDP-11) Brian Kernighan – Dennis Ritchie The C Programming Language (K&R, 1978.) ANSI-C szabvány, 1989. Jellemzői: Általános célú programnyelv; Hordozható (portabilis); Gépközeli (processzor-közeli); Elsősorban rendszerprogramok írására. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Az újabb fejlesztések már csak C++ nyelven. Bjarne Stroustrup, AT&T Ismertebb C (C++) fordítóprogram gyártók: Microsoft (6.0) Watcom (Code Warrior) Borland Turbo C 2.0 (TC) Turbo C++ Borland C++ 3.1 (BC, Ezt fogjuk használni!) Borland C++ 5.82 (Ez a legutolsó, 2007.) Integrated Development Environment (IDE) General Public License (GNU-licensz) alatti ingyenes fordítóprogramok és fejlesztőkörnyezetek: DEV-C++ CodeBlocks, stb. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 2. A programnyelv alapelemei 2.1 A C nyelv jelkészlete A program írására használhatók (IR-23.o.). A szöveg-konstansokban használhatók (ASCII). 2.2 Az azonosítóképzés szabályai Kötött hossz; Az első karakter betű (angol ABC!), vagy _ jel; A további pozíciókon lehetnek számok is; A kis és NAGYBETŰ különböző !! Elnevezés konvenciók; Az ANSI C kulcsszavai (IR-25.o.); Az egyes implementációk kötött kulcsszavai. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 2.3 A programok írásmódja, a C programok szerkezete Egy vagy több forrásfájl .c (.cpp) kiterjesztéssel. Általában fejléc (header) fájlok is .h kiterjesztéssel. A legegyszerűbb C program: int main(void) { } Kevésbé „szabványosan” : ( int main(){} ) A main() függvénynév kötelező. Az utasításokat, függvényhívásokat ; zárja. Egy „bonyolultabb” program: #include <stdio.h> printf("Az első programom."); return 0; /* Vissza az op.rendszerhez */ Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Megjegyzés a programban: /* Megjegyzés */ // Megjegyzés A függvényen belüli sorrend: deklarációk definíciók végrehajtható utasítások Futtatható program előállítása (DOS, Windows): fordítás: forrás program  object modul .c  .obj szerkesztés: object modul  futtatható program .obj, .lib  .exe, .com, .dll Támogatott a moduláris programozás Borland – IDE (.prj fájl) Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 3. Változók, konstansok, szimbólikus konstansok 3.1 Adattípusok a C nyelvben Egyszerű (skalár) típusok egész jellegű (integer) lebegőpontos (real) sorszámozott (enumerated) mutató (pointer) Összetett típusok tömb (array) struktúra (structure) unió (union) Típuselőírást jelentő kulcsszavak char, int, float, double, union, struct, enum, void Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Típusmódosító kulcsszavak short - int long - int, double signed - char, int unsigned - char, int near - ( * pointer, csak DOS esetén) far - ( * pointer, csak DOS esetén) Típusminősítő kulcsszavak volatile const Az adattárolást szabályozó kulcsszavak auto, static, extern A változók deklárálásakor, illetve definiálásakor a kulcsszavak kombinációja adható meg. Informatikai Intézet - INF-501 Kógelmann Gábor

Az adattípusok jellemzői 16 bites környezetben (IR-45.o.) Bevezetés a programozásba Az adattípusok jellemzői 16 bites környezetben (IR-45.o.) Adattípus Méret (bájt) Pontosság (jegy) Értéktartomány char, signed char 1 -128 ÷ 127 unsigned char 0 ÷ 255 int, short int 2 -32 768 ÷ 32 767 unsigned int, unsigned short 0 ÷ 65 535 long int, long 4 -2 147 483 648 ÷ 2 147 483 647 unsigned long 0 ÷ 4 294 967 295 float 7 ±3.4E-38 ÷ ±3.4E+38 double 8 15 ±1.7E-308 ÷ ±1.7E+308 long double 10 19 ±3.4E-4932 ÷ ±1.1E+4932 Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 3.2 Konstansok, szimbólikus konstansok Egész típusú konstansok: Decimális 2007, -1, 0 Oktális (8-as számrendszerben) 0 – 7, az első jegy mindig 0. 04317, -0126, 010, 0 Hexadecimális (16-os számrendszerben) 0 – 9, a – f, A – F, az első jegy mindig 0X, vagy 0x. 0x6AB, 0x6aB, -0X1, 0x00 Előjel nélküli (unsigned) A konstans érték után U, vagy u. 126u, 010U, 0x1AU Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Hosszú típus (long) A konstans érték után L, vagy l. 126L, 010l, 0x1AL Az U, L együtt is használható 126lu, 010uL, 0x1ALU Karakteres konstansok: Egyszeres idézőjelben (apostrophe, aposztróf). A második karakterkészletből. 'a', 'x', 'É' Escape (‘eszkép’) szekvenciák Az első karakter \ (backslash), utána maximum további három. Az aktuális ASCII kódrendszer minden karaktere ezzel a módszerrel megadható. Informatikai Intézet - INF-501 Kógelmann Gábor

A legfontosabb escape szekvenciák (IR-28.o.) Bevezetés a programozásba A legfontosabb escape szekvenciák (IR-28.o.) Escape szekvencia Érték Karakter Jelölés Értelmezés \a 0x07 ∙ BELL Csengő (sípolás) \b 0x08 ◘ BS Back Space, visszalépéses törlés \f 0x0C ♀ FF Form Feed, lapdobás \n 0x0A ◙ LF, NL Line Feed, soremelés, újsor \r 0x0D ♪ CR Carriage Return, kocsi vissza \t 0x09 ○ HT Horizontal Tabulate, tabulálás \\ 0x5C \ Backslash \' 0x27 ' Aposztróf (hiányjel) \" 0x22 " Dupla aposztróf \ooo ooo = 1-3 oktális számjegy \xhh hh = 1-2 hexadecimális számjegy Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Sztring (literál) konstansok: Dupla aposztrófok között! "Ez egy sztring konstans" A sztring végét a memóriában egy '\0' jelzi. Az üres sztring csak a záró nullát tartalmazza. Lebegőpontos konstansok: Egész rész és tizedes törtrész. Tizedespont (kötelező). Hatványkitevő jele (e, E). Hatványkitevő értéke, előjellel. Egyes részek elhagyhatók. Tárolásuk dupla pontosságú formában. .1, -2. , 187.27, 1872.7e-1 Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Egyszeres pontosságú lebegőpontos konstansok A konstans érték után F, vagy f. 3.1415F Nagy pontosságú lebegőpontos konstansok A konstans érték után L, vagy l. 3.1415L Szimbólikus konstansok: #define konstans-név helyettesítő szöveg Szokás csupa nagybetűvel elnevezni. #define ALSO 0 #define FELSO 255 #define PI 3.141592 #define HA if Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba A const típusminősítő: const int a = 30; // Kezdeti érték a = 20; // Hibás utasítás 3.3 Skalárok és tömbök definiálása, deklarálása Az értéket tároló objektumokat névvel látjuk el, ezek a nyelv változói. Minden változót definiálni, vagy deklarálni kell. Csak a blokk elején, a végrehajtható utasítások előtt lehet elhelyezni. A skalár definíció szintaktikája: <tárolási osztály> <módosító(k)> <minősítő(k)> típus változónév < =kezdőérték > <,...>; tárolási osztály: auto, static, extern, register ... : a változónévtől ismételhető Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Példák skalár definícióra: char a; // Karakteres static double B = 12.3; // Lebegőpontos long int c, d = 3, e, f = 15; // Hosszú egész Definiálás; helyfoglalás a memóriában. Deklarálás; nincs helyfoglalás, másik modulban (forrásprogramban) már definiálva (extern). A tömb definíció szintaktikája: <tárolási osztály> <módosító(k)> <minősítő(k)> típus változónév[elemszám_1]<[elemszám_2][...]> < = {érték1, érték2, ...}> <,...>; tárolási osztály: auto, static, extern, register ... : a változónévtől ismételhető Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Az indexhatárok: 0  elemszám_1-1 , 0  elemszám_2-1 Példák tömb definícióra: int vektor[5]; // Vektor char matrix[3][10]; // Mátrix (sor, oszlop) float tomb[2][5][6]; // Három dimenziós tömb A fordítóprogram nem ellenőrzi az indexhatárt! Egy objektum mérete lekérdezhető (sizeof operátor): int a, b, c, d, vekt[3]; a = sizeof vekt[0]; // a  2 (2 bájt) b = sizeof vekt; // b  6 (3 x 2 bájt) // c  3 (6 / 2) c = sizeof vekt / sizeof vekt[2]; d = sizeof(float); // d  4 Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Példák kezdeti értékadásra (inicializálás): Skalár int a = 5; float b = 3.45; Vektor Karakteres, numerikus char szo[6] = { 's', 'z', 'ó' }; int x[3] = { 1, 2, 3 }; float y[] = { 1.3, 120., 49.5}; Az elemszám megadás ilyenkor elmaradhat. Sztring char szoveg[] = "Ez egy szöveg."; Az elemszám 14+1=15 a sztring konstanst záró nulla miatt. A sztringek kezelésére könyvtári függvények vannak. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Néhány sztring kezelő függvény: char forras[] = "alma + "; char cel[20]; int hossz; strcpy(cel, forras); // Másolás strcat(cel, "körte" ); // Konkatenálás hossz = strlen(cel); // hossz  12 Mátrix Karakteres, numerikus char x[2][3] = {'a','b','c','d','e','f'}; int y[3][2] = { 6, 5, 4, 3, 2, 1 }; Sztring char sztring[][6] = { "körte", "alma" }; Csak a sorok száma hiányozhat! Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 4. A C nyelv utasításai Az ANSI C szabvány hat csoportot definiál: Kifejezés és üres utasítás ( ; ) Összetett utasítás ( { } ) Szelekciós utasítások ( if, else, switch ) Cimkézett utasítások ( case, default, címke ) Iterációs utasítások ( for, while, do ) Vezérlésátadó utasítások ( break, continue, goto, return ) 4.1 Utasítások és blokkok Egy kifejezés utasítás lesz, ha pontosvesszővel zárjuk. x = y + 2; i++; v = z = fv(x, y) + 4; Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Az üres utasítás ; do, for, while és if esetén szükség lehet rá. Összetetett utasítás (blokk) { } Mindenhol használható, ahol egy utasítás is állhat. { lokális definíció, deklaráció utasítások } 4.2 A szelekciós (döntési) utasítások A programban bizonyos utasítás(ok) végrehajtását egy kifejezés értékétől tesszük függővé. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Az if utasítás szintaktikája: if(kifejezés) utasítás Példa (IF1.C): Az Esc billentyű vizsgálata. #include <stdio.h> #include <conio.h> #define ESC 27 int main(void) { char ch; printf("Kérek egy karaktert: "); ch = getch(); if(ch == ESC) printf("\aAz Esc billentyű volt."); } Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba A kifejezés igaz, ha értéke nem nulla. Ebben az esetben végrehajtja az utasítást, vagy utasítás blokkot. Az if-else szerkezet szintaktikája: if(kifejezés) utasítás_1 else utasítás_2 A kifejezés hamis, ha értéke nulla. Ez esetben az else utáni utasítást, vagy utasítás blokkot hajtja végre. Az utasítás helyén legalább egy üres utasításnak ( ; ) kell állnia! Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Példa (IF2.C): Páros-páratlan számok. #include <stdio.h> int main(void) { int n; printf("Kérek egy egész számot: "); scanf("%d", &n); if(n % 2 == 0) printf("\nA szám páros."); else printf("\nA szám páratlan."); } Az n % 2 maradékos osztás végez. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Az if utasítások egymásba is ágyazhatók: if(kifejezés_1) if(kifejezés_2) utasítás_1 else utasítás_2 Az elképzelésünk és a valóság néha nem egyezik… A helyes működés elérésére több lehetőség is kínálkozik. Ezt akartuk Ez lett Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba A lehetséges megoldások: a.) if(kifejezés_1) if(kifejezés_2) utasítás_1 else ; else utasítás_2 b.) if(kifejezés_1) { } Üres utasítás Utasítás blokk Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Az if-else szerkezet helyett használható a feltételes operátor: ? : kifejezés_1 ? Kifejezés_2 : kifejezés_3; [ ha igaz ] [ ha hamis ] x = a < b ? a : b; Az else if szerkezet szintaktikája: if(kifejezés_1) utasítás_1 else if(kifejezés_2) utasítás_2 else if(kifejezés_3) utasítás_3 < else utasítás_4 > Az igaz kifejezés_n utasítását végrehajtja. Elhagyható Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Példa (IFCALC.C): Négyműveletes, egyszerű számológép. #include <stdio.h> #include <stdlib.h> int main(void) { double a, b, e; char op; printf("Kérem az elvégzendő műveletet: "); scanf("%lf %c %lf", &a, &op, &b); if(op == '+') e = a + b; else if(op == '-') e = a - b; Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba else if(op == '*') e = a * b; else if(op == '/') e = a / b; else { printf("Hibás művelet!\n"); exit(-1); // Kilépés a programból } printf("%.2lf %c %.2lf = %.3lf\n", a, op, b, e); } Példa a művelet beírására: 32.1 + 142.56 <Enter> 32/142 <Enter> Ha osztónak nullát adunk meg, program megszakítás okoz! (Divide by 0) Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba A switch utasítás szintaktikája: switch(kifejezés) { case konstans kifejezés_1: utasítás_1 case konstans kifejezés_2: utasítás_2 < default: utasítás_3 > } A kifejezés kiértékelése során kapott értéket hasonlítja a konstans kifejezés_n értékhez, ahol igaz, belép. Az utasítás végrehajtás megszakítható: break, return A kifejezések csak egész jellegűek lehetnek. A konstans értékeknek egyedinek kell lenniük. Elhagyható Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Példa (SWCALC.C): Négyműveletes számológép switch-el megoldva. (részlet) . . . . switch(op) { case '+': e = a + b; break; case '-': e = a - b; case '*': e = a * b; case '/': e = a / b; Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba default: printf("Hibás művelet!\n"); return -1; } // a switch lezárása . . . . Példa (SWITCH1.C): Igen-Nem válasz vizsgálata. #include <stdio.h> int main(void) { char valasz; printf("A válasz [I/N]? "); valasz = getchar(); Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba switch(valasz) { case 'i': case 'I': printf("A válasz IGEN.\n"); break; case 'n': case 'N': printf("A válasz NEM.\n"); default: printf("Hibás válasz!\n"); } Példa (SWITCH2.C): 0-7 faktoriális kiszámítása. (0! = 1) Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba #include <stdio.h> int main(void) { int num, fakt = 1; printf("Kérek egy egész számot (0-7): "); scanf("%d", &num); switch(num) default: printf("Hibás szám: %d\n", num); break; case 7: fakt = fakt * 7; . . . case 2: fakt = fakt * 2; case 1: case 0: printf("%d! = %d\n", num, fakt); } Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Példa: Egyjegyű int (0-9) konvertálása char típusra. (részlet) a.) switch-case (bonyolult) int a; char b; switch(a) { case 0: b = '0'; break; . . . . case 9: b = '9'; break; } b.) Gondolkodva valahogy így … b = a + 48; vagy b = a + 0x30; Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 4.3 Ciklusszervező (iterációs) utasítások A programban bizonyos utasításainak ismételt végrehajtása, egy feltétel teljesüléséig. A while utasítás szintaktikája (előltesztelő): while(kifejezés) utasítás Példa: Az első 100 pozitív szám összege (részlet). int i = 1; int osszeg = 0; while(i <= 100) { osszeg = osszeg + i; i = i + 1; } Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Végtelen ciklus: while(1) Kilépés: break -el { . . . } Veszélyek: while(a == b) while(a = b) Hiba! { { . . . . . . } } while(a == b + c) helyett while(b + c == a) float x = 1.0; while(x != x + 1) Elvileg végtelen ciklus! x = x * 2.0; printf("A ciklus vége x = %e\n", x); Kilépés: x = 1.84e19 -nél (BC) Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba A for utasítás szintaktikája (előltesztelő): for(kifejezés_1; kifejezés_2; kifejezés_3) utasítás A kifejezés_1 mindig végrehajtódik. A ciklusmag csak akkor, és addig hajtódik végre, ha a kifejezés_2 igaz (nem nulla). A kifejezés_3 a ciklusmag után kerül sorra. Bármelyik kifejezés elmaradhat, csak a pontosvesszőket kötelező megadni. Végtelen ciklus: for(;;) Kilépés: break -el { . . . } Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Tipikusan így használjuk: for(i=0; i<n; i++) { . . . } Ez is egy lehetséges formátum: for(i=0; i<n;) i = i + 1; Példa: Az első 100 pozitív szám összege (részlet). Több megoldást is láthatnak, melyek teljesen egyenértéküek. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba a.) osszeg = 0; for(i=1; i<=100; i++) osszeg = osszeg + i; b.) for(osszeg=0, i=1; i<=100; i++) c.) for(osszeg=0, i=1; i<=100; osszeg = osszeg + i, i++); d.) for(osszeg=0, i=1; i<=100; osszeg = osszeg + i++); e.) for(osszeg=0, i=1; i<101; osszeg += i++); Vessző Pontosvessző Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba A do-while utasítás szintaktikája (hátultesztelő): do utasítás while(kifejezés); Végtelen ciklus: do Kilépés: break -el . . . while(1); Példa: Az első 100 pozitív szám összege (részlet). osszeg = 0; i = 100; do { osszeg = osszeg + i; i--; } while(i>0); Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 4.4 A vezérlésátadó utasítások A break és a return utasítás szintaktikája: break; // Kilép a ciklusból return; // Visszatér a hívó függvényhez Példa: Ha i eléri a harmincat, kilép a ciklusból. for(i=0 ;; i++) { if(i == 30) break; // vagy, return; . . . } // break; esetén itt folytatódik a program. // return; esetén ide már nem jut el ... A break gyakori használata nem célszerű! Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba A continue utasítás szintaktikája: continue; // Az iteráció folytatása Példa: A hárommal osztható számok kihagyása az összegzésből. for(osszeg=0, i=1; i<101; i++) { if((i % 3) == 0) continue; osszeg += i; } A ciklusfej kiértékelésével folytatódik a program. A continue gyakori használata nem javasolt! Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba A goto utasítás szintaktikája: goto cimke; // Vezérlés átadás a cimkére . . . cimke: A strukturált programozás alapelvei szerint tilos használni! Csökkenti a program olvashatóságát. Ennek ellenére a gyakorlatban előfordulhat olyan eset, amikor használatával egyszerűbbé válik a program. A cimkének a függvényen belül kell lennie. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Példa: Két egymásba ágyazott ciklusból kell kilépni, egy feltétel teljesülése esetén. for(. . .) { . . . if(hiba) printf("Hiba van a programban!\n"); goto hibaVolt; } hibaVolt: Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Az előző feladat, most goto nélkül megoldva. hibaJel = 0; for(. . .) { . . . if(hiba) printf("Hiba van a programban!\n"); hibaJel = 1; break; } if(hibaJel == 1) // vagy, if(hibaJel) Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 5. Függvények a C nyelvben Bizonyos részfeladatok, illetve gyakran ismétlődő utasítások végrehajtására a programban függvényeket készítünk. 5.1 Függvények definíciója, deklarációja, prototípusa A saját függvényeket mindig definiálni kell, és csak egyszer fordulhat elő a forrásprogramban. Ha a függvény definíció megelőzi a függvény hívás helyét, akkor egyben deklarációnak, illetve prototípusnak is minősül. Ezért szokás a main függvényt a forrásprogram végére helyezni. Az include fájlok tartalmazzák a könyvtári függvények prototípusát is. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba A függvény definíció szintaktikája: <típus> függvénynév(<paraméterlista>) { // A függvény törzse <lokális definíciók, deklarációk> utasítás(ok) <return <kifejezés>;> } A típus helyén a változóknál megismert típuselőírások lehetnek. Ebben az esetben a return kifejezés; utasítás kötelező, és a kifejezés értékének a visszatérési típusra konvertálható típusúnak kell lennie. Amennyiben a típus void, azaz nincs visszatérési értéke a függvénynek, akkor csak üres return; lehet, vagy el is maradhat. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba A függvény deklaráció szintaktikája: <típus> függvénynév( ); A fordítóprogramnak szolgáltat információt a helyes függvény alak ellenőrzésére. A függvény prototípus szintaktikája: <típus> függvénynév(<paraméterlista>); Az ANSI C vezette be. Itt a paraméterlistát is meg kell adni, ha a függvény tartalmaz paramétert. A deklarációt, vagy a prototípust a definíció, illetve a hívás előtt kell elhelyezni a forrásprogramban. Pontosvessző Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 5.2 Az argumentum, a paraméter és a visszatérési érték A függvény meghívásakor argumentumokat adunk át, a meghívott függvénynek. (Amennyiben szükséges.) Az argumentumok és paraméterek típusának, sorrendjének, darabszámának meg kell egyeznie. Lehetőség van kevesebb argumentummal is meghívni a függvényt, ekkor azonban a prototípusban az elhagyható paramétereket három ponttal jelölni kell. A listában a paramétereket vesszővel kell elválasztani. Példa: A könyvtári printf() függvény. int printf(const char *format, ...); A visszatérő érték a kiírt bájtok száma. A skalár argumentum átmásolódik a paraméterbe. Tömb esetén a tömb kezdőcíme kerül a paraméterbe. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Ha elmarad a prototípusban a visszatérő érték típusa, akkor a fordító int típust feltételez! (Hibalehetőség.) 5.3 Összefoglaló példa a függvények használatára Két érték közül a kisebb kiválasztása, és visszaadása a hívónak. int smin(int a, int b); // A prototípus int main(void) // A főprogram { int x = 8, y = 3, z; z = smin(x, y); // A függvény hívás printf("A kisebb érték: %d\n", z); } A printf() a következő is lehetne: printf("A kisebb érték: %d\n", smin(x, y)); Elmaradhat Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba int smin(int a, int b) // A definíció { if(a < b) return a; else return b; } A következő is lehetne: return a < b ? a : b; Az stdlib.h include fájlban függvényszerű makróutasításként van definiálva (min és max): #define min(a, b) (((a) < (b)) ? (a) : (b)) #define max(a, b) (((a) > (b)) ? (a) : (b)) Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 6. Operátorok és kifejezések Kifejezés: Vagy egyetlen operandusból, vagy operandusok és műveleti jelek (operátorok) kombinációjából áll. Az operandus lehet: Konstans érték Változó Függvényhívás Összetett kifejezés zárójellel, vagy anélkül. Az operandusok száma szerint: Egyoperandusú operátorok (unary) op operandus, vagy operandus op alakban [prefix alak] [postfix alak] -a, sizeof a, a++ Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Kétoperandusú operátorok (binary) operandus1 op operandus2 a + b, a << 2, a += b Háromoperandusú (egy van) a < 0 ? -a : a 6.1 Aritmetikai, relációs és logikai operátorok Aritmetikai operátorok: + - * / % (maradékképzés, moduló operátor) - (előjel, egyoperandusú) ++ (inkrementálás, léptető operátor) -- (dekrementálás, léptető operátor) Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Az osztás maradékának meghatározása: int a = 16, b, e; b = a / 12; e = a - (b * 12); // e = 4 Vagy egyszerűbben: e = a % 12; // e = 4 A léptető operátor posztfix, illetve prefix helyzetben: int n = 5, x; x = n++; // x = 5, n = 6 n = 5; x = ++n; // x = 6, n = 6 Érdekesség: int a = 1, b = 2, e; e = a+++++b; // Hibás! e = a++ + ++b; // Jó printf("%d %d %d", a, b, e); //  2 3 4 Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba int a = 1, b = 2, e; e = a++-++b; // Ez viszont jó printf("%d %d %d", a, b, e); //  2 3 -2 Relációs (összehasonlító) operátorok: < <= > >= == != A hasonlítás eredménye int típusú, és értéke 1 igaz esetén, illetve 0 nem igaz esetén. int a = 1, b = 2; if(a < b) . . . //  igaz (1) Logikai operátorok: && || ! Ha egy változó nem igaz értékére akarunk rákérdezni: if(ok == 0) . . . // vagy if(!ok) . . . Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Példa a relációs és logikai operátorok használatára: Szökőév eldöntése. Szökőév van, ha az évszám néggyel osztható, de nem osztható százzal, kivéve a négyszázzal osztható éveket. int ev; . . . if((ev%4 == 0 && ev%100 != 0) || ev%400 == 0) printf("Szökőév van . . ."); else printf("Nincs szökőév . . ."); 6.2 Az értékadó kifejezés, és a típuskonverzió Példák értékadó kifejezésekre: int a, b; b = (a + 2) / 10 - 4; b = 5 * (a = 12) - 3; Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba a = b = -56; a = -2, b = a + 25; a = a + 4; // vagy a += 4; // Összetett értékadás a = a * (b + 1); // vagy a *= b + 1; // Összetett értékadás Az összetett értékadás általánosan: kifejezés1 op= kifejezés2 Az op helyén a következő operátorok állhatnak : + - * / % << >> & | ^ (Az öt utóbbi bitművelet!) Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Értékadás feltételes operátorral: kifejezés1 ? kifejezés2 : kifejezés3 Példa: 0 -15 számérték hexadecimális számjeggyé konvertálása. char ch; int n; . . . ch = n >= 0 && n <= 9 ? ' 0' + n : ' A' + n - 10; Típuskonverzió: Automatikus típuskonverzió (implicit) Általánosan igaz, hogy a szűkebb operandus adatvesztés nélkül konvertálható a szélesebbe. Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Lebegőpontos számok: float  double  long double Egész jellegű típusok: char  short int  int  long int long int  float . . . Aritmetikai konverzió: Kétoperandusú műveletek esetén az eredményt a szélesebb (pontosabb) típusba konvertálja. Példa: int a = 9, b = 2; float e; e = a / b; // e = 4 !! e = a / 2; // e = 4 !! e = a / 2.0 // e = 4.5 Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Kikényszerített típuskonverzió (explicit) Típuskonverzió operátor (cast) : (típusnév) kifejezés Gyakran használjuk könyvtári függvények helyes argumentum-típussal történő meghívásakor. Példa: int a; a = sqrt((double) 56); implicit explicit konverzió ( A prototípus: double sqrt(double szám); ) int a = 9; float e; e = (float) a / 2; // e = 4.5 e = (float) (a / 2); // e = 4 !! e = a / (float) 2; // e = 4.5 Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 6.3 Bitműveletek Alkalmazható: char, short int, int, long int típusok esetén Bitenkénti logikai műveletek: Operátor Művelet ~ 1-es komplemens | bitenkénti VAGY (OR) művelet & bitenkénti ÉS (AND) művelet ^ bitenkénti KIZÁRÓ VAGY (XOR) művelet Igazságtáblázat: a b a & b a | b a ^ b ~a --------------------------------- 0 0 0 0 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 1 0 0 Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Általában a hardver elemek programozásánál használatos. Bitek beállítása, törlése. Maszkolás. char típus esetén a bitek számozása: 1 0 1 1 0 0 0 1 Maszkbit értékek (példa) 7 6 5 4 3 2 1 0 Számozás (BITMUV.C) ~ Egyes komplemens: a = 0x00; a = ~a; //  FF | Bitenkénti VAGY (bitek egybe állítása): a = 0x0E; a = a | 0x81; //  8F, (0x81 a maszk) Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba & Bitenkénti ÉS (bitek törlése): a = 0x8E; a = a & 0x77; //  06 ^ Bitenkénti KIZÁRÓ VAGY (titkosítás): a = a ^ 0x77; //  F9 (Titkos szöveg) a = a ^ 0x77; //  8E (Nyílt szöveg) ^ Bitenkénti KIZÁRÓ VAGY (értékcsere): a = 12; b = 69; //  a = 69 , b = 12 a = a ^ b; b = b ^ a; a = a ^ b; Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba << Bitek balra tolása (left shift): a = 8; a = a << 4; //  128 >> Bitek jobbra tolása (right shift): a = 128; a = a >> 3; //  16 Példa: Kék háttér, és piros előtér szín beállítása (Borland C). textattr((BLUE << 4) + RED); 0 0 0 0 0 0 0 1 << 4 A kék eltolása 4 bittel 0 0 0 1 0 0 0 0 Az eltolás után + 0 0 0 0 0 1 0 0 A piros hozzáadása ------------------- 0 0 0 1 0 1 0 0 Az eredmény ( 0x14) Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba 6.4 Precedencia, asszociativitás, rövidzár Precedencia: Elsőbbségi szabály, kiértékelési sorrend. Asszociativitás: A kiértékelés iránya azonos szint esetén. Operátor Asszociativitás () [] . ->  ! ~ - ++ -- & * (típus) sizeof  * / % + - << >> < <= > >= == != & Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Operátor Asszociativitás ^  | && || ?:  = += -= *= /= %= <<= >>= &= |= ^= , Rövidzár (short circuit): char a = 1, b = 2, c; c = a || b++; // b=2, c=1 !! c = b++ || a; // De most b=3, c=1 Informatikai Intézet - INF-501 Kógelmann Gábor

Bevezetés a programozásba Irodalomjegyzék 1. Benkő Tiborné és társai: Programozzunk C nyelven ComputerBooks Budapest, 1995. 2. B. W. Kernighan, D. M. Ritchie: A C programozási nyelv Műszaki könyvkiadó Budapest, 1985. 3. Pető Ádám: ABC programozási nyelvkönyv SZÁMALK kiadó Budapest, 1990. 4. Benkő Tiborné, Dr. Poppe András: Együtt könnyebb a programozás ( C ) ComputerBooks Budapest, 2004. Informatikai Intézet - INF-501 Kógelmann Gábor