bevezetés a programozásba inf-501 a c programnyelv

Bevezetés a programozásba

INF-501

A C programnyelv

Informatikai Intézet Kógelmann Gábor


Informatikai Intézet - INF-501 Kógelmann Gábor

1. 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.



• 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.



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.



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> int main(void) { printf("Az első programom.");

return 0; /* Vissza az op.rendszerhez */ }



• 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)



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



• 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.



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 ÷ 127unsigned char 1 0 ÷ 255int, short int 2 -32 768 ÷ 32 767unsigned int,unsigned short 2 0 ÷ 65 535

long int, long 4-2 147 483 648 ÷

2 147 483 647unsigned long 4 0 ÷ 4 294 967 295float 4 7 ±3.4E-38 ÷ ±3.4E+38double 8 15 ±1.7E-308 ÷ ±1.7E+308long double 10 19 ±3.4E-4932 ÷ ±1.1E+4932



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



• 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ákAz első karakter \ (backslash), utána maximum további három. Az aktuális ASCII kódrendszer minden karaktere ezzel a módszerrel megadható.



A legfontosabb escape szekvenciák (IR-28.o.)

Escapeszekvencia

É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



• 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



• 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



• 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ő



• Példák skalár definícióra:char a; //

Karakteresstatic double B = 12.3; //

Lebegőpontoslong 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ő



• 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



• 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.



Néhány sztring kezelő függvény:char forras[] = "alma + "; char cel[20];int hossz;

strcpy(cel, forras); // Másolásstrcat(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!



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;



• 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é.



• 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 27int main(void){ char ch; printf("Kérek egy karaktert: "); ch = getch(); if(ch == ESC)

printf("\aAz Esc billentyű volt.");}



• 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_1else 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!



• 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.



• 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



• 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) { if(kifejezés_2) utasítás_1 } else utasítás_2

Üres utasítás

Utasításblokk



• 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_1else if(kifejezés_2)

utasítás_2else 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ó



• 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;



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)



• 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ó



• 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; break;case '*': e = a * b; break;case '/': e = a / b; break;



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();



switch(valasz) {

case 'i': case 'I': printf("A válasz IGEN.\n"); break;case 'n':case 'N': printf("A válasz NEM.\n"); break;default: printf("Hibás válasz!\n");

} }

• Példa (SWITCH2.C):0-7 faktoriális kiszámítása. (0! = 1)



#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);

}}



• 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;



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;}



• 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)



• 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 { . . .}



• 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.



a.) osszeg = 0;for(i=1; i<=100; i++) osszeg = osszeg + i;

b.) for(osszeg=0, i=1; i<=100; i++)

osszeg = osszeg + 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ő



• A do-while utasítás szintaktikája (hátultesztelő):do utasításwhile(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);



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ű!



• 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!



• 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 tiloshaszná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.



• Példa:Két egymásba ágyazott ciklusból kell kilépni, egy feltétel

teljesülése esetén.

for(. . .) for(. . .) {

. . . if(hiba)

{ printf("Hiba van a programban!\n");

goto hibaVolt;}

}

hibaVolt:



Az előző feladat, most goto nélkül megoldva.

hibaJel = 0;for(. . .){ for(. . .) {

. . . if(hiba)

{ printf("Hiba van a programban!\n");

hibaJel = 1; break;}

} if(hibaJel == 1) // vagy, if(hibaJel)

break;}



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.



• 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.



• 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.• A fordítóprogramnak szolgáltat információt a helyes

függvény alak ellenőrzésére.• 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ő



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.



• 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áraKé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



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))



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++



• Kétoperandusú operátorok (binary)operandus1 op operandus2a + 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)



• 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 = 6n = 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



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) . . . // vagyif(!ok) . . .



• 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;



a = b = -56;a = -2, b = a + 25;a = a + 4; // vagya += 4; // Összetett értékadása = a * (b + 1); // vagya *= 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!)



• É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.



• 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



• 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



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



• Á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)



& Bitenkénti ÉS (bitek törlése): a = 0x8E;

a = a & 0x77; // 06

^ Bitenkénti KIZÁRÓ VAGY (titkosítás): a = 0x8E; 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;



<< 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)



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

* / %

+ -

<< >>

< <= > >=

== !=

&



• 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

Operátor Asszociativitás^

|

&&

||

?:

= += -= *= /= %= <<= >>= &= |= ^=

,



Irodalomjegyzék

1. Benkő Tiborné és társai:Programozzunk C nyelvenComputerBooks Budapest, 1995.

2. B. W. Kernighan, D. M. Ritchie:A C programozási nyelvMűszaki könyvkiadó Budapest, 1985.

3. Pető Ádám:ABC programozási nyelvkönyvSZÁMALK kiadó Budapest, 1990.

4. Benkő Tiborné, Dr. Poppe András:Együtt könnyebb a programozás ( C )

ComputerBooks Budapest, 2004.

bevezetés a programozásba inf-501 a c programnyelv

Documents