A programozás alapjai - C#

A programozás alapjai C# nyelven Készítette Kovács Norbert 2020. július 21.

2

Tartalomjegyzék 1. Változók és azok működése 1.1. A változók tárolása . . . . . . . . . .

1.1.1. Memória felépítése . . . . . .

1.1.2. Bináris számrendszer . . . . .

1.1.3. Memória elérés . . . . . . . .

1.2. Primitív típusok, és azok fejlődése .

1.2.1. Primitív típusok . . . . . . .

1.2.2. Modern típusok . . . . . . . .

1.3. Változókra alkalmazható operátorok 1.3.1. Túlcsordulás . . . . . . . . .

1.3.2. Operátorok viselkedése . . . .

1.4. Konstans változók . . . . . . . . . .

1.5. Változó élettartam és hatáskör . . .

1.6. Névadási szabályok . . . . . . . . . .

1.7. A konzol használata . . . . . . . . .

1.8. Gyakorlati feladatok . . . . . . . . .

1.8.1. Megoldások . . . . . . . . . .

2. Elágazások, és jelentőségük 2.1. Egyszerű elágazás . . . . . . . . .

2.2. Feltételek kiértékelése . . . . . .

2.2.1. Relációs operátorok . . .

2.2.2. Logikai operátorok . . . .

2.3. Összetett elágazások . . . . . . .

2.4. Feltételek tervezése . . . . . . . .

2.4.1. Első példafeladat . . . . .

2.4.2. Második példafeladat . . .

2.5. Gyakorlati feladatok . . . . . . .

2.5.1. Megoldások . . . . . . . .

. . . . . . . . . .

3

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . . . . . . . .

3 3 3 4 5 5 5 6 9 9 10 11 12 13 14 15 16

. . . . . . . . . .

17 17 18 18 19 21 22 22 25 31 32

4

TartalomjegyzĂŠk

Előszó A programozás egy olyan különleges feladatkör, ahol a programozó megtanul egyfajta speciális gondolkodásmódot elsajátítani, amiben másképpen közelíti meg a hétköznapi világ problémáit. Algoritmikus szemlélettel nézi a dolgokat, és általánosságban figyeli meg a dolgok viselkedését. Egy problémát „lefordít” magának lépésekre, amik eredményeképp a feladat megoldódik. Ehhez számos eszköz működését meg kell értenie a programozó növendéknek. Egy asztalosmesternek is meg kell értenie a fa felépítését, szerkezetét, hogy azt úgy használhassa, és módosíthassa hogy elérje a kívánt eredményt, nem beszélve eszközei kiváló használatáról. A programozónak is szükségszerű értenie a számára elérhető szerszámokat, és nyersanyagokat, hogy azokat a legjobb módon használhassa fel.

Esetünkben ezek a típusok, függvények, elágazások, ciklusok és metódusok. Az első programnyelvünk során sokszor szintaktikai nehézségekbe fogunk ütközni, ami azt jelenti hogy egy konkrét programozási nyelv nyelvtani szabályait be kell tartanunk, ami sok esetben nehezíti az algoritmikus gondolkodás elsajátítását, mert nem a nagy egész működését figyeljük, hanem elveszünk a szintaktikai részletekben. Ezektől a szintaktikai hibáktól ne tartsunk. Tanuljunk belőlük, hogy mélyebben megértsük minden mögöttes működését.

Ahogy idővel egyre elmélyültebben sajátítjuk el a programozási nyelv szabályait, úgy egyre kevesebb szintaktikai hibát fogunk véteni. Ezenkívül tanulás közben, használhatunk nem szintaktikailag kötött pszeudó nyelvet is, hogy leírjuk gondolatmenetünk lépéseit.

Ebben a könyvben, megpróbálom végigvezetni az olvasót, az első programozási nyelvének megtanulásában, és megértésében. A következő tanult nyelveink, erre fognak alapozni, és tizedannyi idő alatt fogja az olvasó elsajátítani őket. Utazásának legrögösebb része most kezdődik, ezért nagyon fontos, hogy az olvasó megértse: csak a saját munkája árán fog fejlődni. Nem elég elolvasni a könyvet, gyakorolnia kell, és saját problémákra átültetni a tanultakat. Minden fejezet végén van, egy nagyon egyszerű feladatsor, ami a fejezetben tanultakat hivatott felfrissíteni. Ezek a feladatok nem tartogatnak kihívást, hiszen a megoldásuk a fejezetben szemléltetett, apróbb változtatásokkal. Ezenkívül a fejezetekben néha, amennyiben a témakör igényli, példafeladatokkal szemléltetem a problémát.

Ezek, többnyire igen részletesen térnek ki a megoldásra, ábrákkal, diagramokkal segítve a megértést. Kövessük őket végig figyelemmel, és próbáljunk részese lenni a megoldásnak, esetleg a példafeladat megoldásának elolvasása előtt, gondolkodjunk el mi miképpen gondolkodnánk.

5

6

TartalomjegyzĂŠk

1. fejezet

Változók és azok működése 1.1. A változók tárolása 1.1.1. Memória felépítése Hogyan tárolunk adatokat a memóriában? Először ismerjük meg a felépítését a számítógépünkben található eszköznek (RAM ), amiben a változóinkat tároljuk. Képzeljük el, hogy a memóriánk apró kis rekeszekre van osztva. Ezek a rekeszek tárolják az információt, amire szükségünk van. Ennek részletes, fizikai működése számunkra most nem fontos.

A memóriánkat elméleti alapon végtelennek tekintjük, de ez természetesen nincs így.

Ha kiemelnénk egy részt, valahogy így nézne ki :

0 0 0

0 1 1

1 0 1

0 0 0

1 0 0

0 1 0

0 0 1

1 0 0

0 0 0

0 1 0

0 0 0

1 0 1

0 1 0

0 0 1

0 0 1

Ezek a rekeszek két jel tárolására alkalmasak. Esetünkben ezt kényelmi okokból 1-nek, és 0-nak fogjuk jelölni. Azonban észrevehetjük hogy logikai szempontból az alkalmazott jelrendszer nem okoz változást. Jelölhetnénk a nullát egy mosolygó fejjel, az egyest pedig egy szomorú fejjel, a lényeg hogy két különböző állapotot tudjunk ábrázolni. Minden szabályunk, amit lefogunk írni, változatlan marad, azonban könnyebb ezekkel a számokkal dolgoznunk.

J

Álltalánosságban elmondható hogy N darab jelölőre van szükségünk egy N alapú számrendszer esetén. ( {0,1,2,3,4,5,7,8,9}(10) - 10db )

Belátható hogy a {0,1} halmaz tartalmaz minden jelölést, amire szükségünk van hogy kettes alapú számrendszerben kifejezzük magunkat, így a számítógép memóriájában tudunk tárolni minden számunkra szükséges adatot.

7

8

1. fejezet. Változók és azok működése

1.1.2. Bináris számrendszer Ahhoz hogy megértsük a bináris számrendszert, hívjuk segítségül az általunk már jól ismert Decimális számrendszert. A 10-es alapú számrendszert napi szinten használjuk, de talán nem mindenki érti a mögötte megbúvó matematikai alapokat. Pontosabban talán túlságosan magától értetődő hogy kérdéseket tegyünk fel. Írjunk fel egy példát : 162(10) 1 Ez a szám kettő darab egyest tartalmaz, hat darab tízest, és egy darab százast. Egyértelműnek tűnik, hiszen ezt a számrendszert használjuk nap mint nap, és ránézésre megtudjuk állapítani a helyi értékek értékét. De pontosan miért tízesek, százasok, ezresek a helyi értékeink? Ha jobban megnézzük, észre fogjuk venni hogy ezek a számrendszer alapjának a hatványai.

100 = 1, 101 = 10, 102 = 100, és így tovább.

J

Minden szám nulladik hatványa egy, és minden szám első hatványa önmaga. Így bármilyen számrendszer első két helyiértéke könnyedén meghatározható.

Tehát ahhoz hogy egy N alapú számrendszer helyi értékeit kiszámoljuk, annak sorra kell vennünk a hatványait. Tehát, a kettes számrendszer helyi értékei a következőek : ...

25

...

0

24

32 0

0

23

22

21

20

16

8

4

2

1

0

1

0

1

1

11 A 1011(2) tehát, egy darab egyest, egy darab kettest, nulla darab négyest, és egy darab nyolcast tartalmaz, aminek összege 11(10) . Miért fontos ez? Mivel a memóriánkban kettes számrendszerben tudunk adatokat tárolni, ezért látnunk kell hogy az általunk létrehozott változók értéke hogyan jelenik meg a bináris számrendszerben. Egy említett tárolórekesz, ami kétféle állapot tárolására alkalmas, egy bit-nek (binary unit) nevezzük. Egy byte 8 ilyen egységből épül fel. Esetünkben a képen látható 00001011(2) szám 1 byte-on ábrázolja a 11(10) -et.

1

Ez a jelölése annak hogy milyen alapú számrendszerben tüntettük fel a számot. (162, tízes alapon)

9

1.2. Primitív típusok, és azok fejlődése

1.1.3. Memória elérés Nem fogunk részletesen belemenni a memóriacímzés részleteibe, de lássuk be, hogy a végtelennek tekintett memóriánkban ezek az adatok eltűnhetnek a sokaságban, ha valamilyen módon nem tartjuk őket számon. Azis fontos honnan, és meddig olvasunk ki egy adatot a memóriából. Ha az előző példában az utolsó bit-et elhagyjuk, és úgy számoljuk át tízes számrendszerbeli alakjára a 101(2) -t, akkor 5(10) -öt kapunk, ami nem az az adat, amit szerettünk volna lementeni.

0

0

0

0

1

0

1

1

5 Ez esetben a legegyszerűbb számológép sem volna képes műveleteket végezni. Valamilyen módszert kell hát találnunk, és rendszereznünk a memóriánk. Jó módszer lenne a memóriánkban lévő biteket összecsoportosítani, byte-okká, és azoknak első bit-jéhez rendelni egy memóriacímet. Azonban ezen felül, arról is gondoskodnunk kell, hogy ne legyen lehetőségünk részlegesen kiolvasni az értékeket a memóriából, az érték átfedésekről, és még számos egyéb problémáról.

1034 1035 1036 1037 0

0

0

0

→ → → → 1

1034

00001011 10010110 11100110 00110000 0

1

1

1

0 ...

1035

Memória címzése Ebben az esetben egy végtelen hosszú szalagként képzelhetjük el a memóriánkat, amik egységekre (byte) van osztva. A valóságban ez valamivel bonyolultabb módon történik, azonban a probléma megértéséhez, elég így magunk elé képzelnünk a memóriacímzés mikéntjét.

1.2. Primitív típusok, és azok fejlődése 1.2.1. Primitív típusok Az Assembly programokban főként, csupán memóriacímekkel lehetett találkozni. Ez a megoldás igen nehezen követhető. Azt hogy az 1034 -es memóriacímen milyen érték sze-

10

1. fejezet. Változók és azok működése

repelt, milyen feladatkörrel, csak az algoritmus részletes elemzése után lehetett megmondani, tehát a feladat igen körülményes. A másik probléma hogy a memóriacím nem jelöli hogy az adat hány byte-ot foglal el, hiszen csak a kezdő címet jelenti.

Ennek megoldására a programozók konstansokat készítettek, ezekkel a memóriacímekkel. Ez számos előnnyel járt, a konstans elnevezésével már könnyebb volt jelezni egy feladatkört, amire az adott memóriacímet kívántuk használni.

Eletero Sebzes Pontok

= = =

1034 1035 1039

Ezzel indult el a változók fejlődése.

Azt is láthatjuk hogy kiolvasható, hogy az első konstans mérete 1 byte, a másodiké már 4, hiszen ennyivel arrébb rögzítettük a következő konstanst. Bár a harmadik változó mérete ez esetben is kétséges. Későbbiekben volt rá mód hogy a következő módon rögzítsék a konstansokat, így könnyebben olvashatóvá téve annak „helyigényét” : Eletero Sebzes Pontok

= = =

1034 Eletero + 1 Sebzes + 4

Azonban előfordulhat olyan eset, ahol még így is átlóg a változó értéke. Ami ugyan a programozó hibája, mert rosszul tervezte meg az adatstruktúrákat, de még ezt nem jelezte semmi számára, csak a hibás működés.

Itt a programozónak különösen oda kellett figyelnie a változóiban tárolt értékekre, hogy ne pocsékoljon memóriát (Azzal hogy túl sok helyet foglal le egy változó számára), vagy épp ne lógjon át a változó értéke egy olyan memóriaterületre, ami egy másik változóhoz tartozik. A típus fogalma adott megoldást erre a problémára. Az Assembly nyelv első típusai : BYTE, WORD, és a DWORD, sorra 1, 2 és 4 byte helyigénnyel.

BYTE DWORD WORD

Eletero Sebzes Pontok

1034 - 1 byte 1035 - 4 byte 1039 - 2 byte

Ezeket nevezzük primitív típusoknak. Nem jelzik a bennük lévő adatok szintaktikáját, csupán a helyigényüket, nem is igazán típusnevek, valójában tárolási-igény nevek.

Ezután finomodott a változók fogalma.

1.2.2. Modern típusok A változóinkat érintő változások, és a típusok finomodása nagyban segíti a programozót, hogy az addig gyakori hibák előfordulása csökkenjen. A kezdetekben zavarónak érezhetjük az erős típusfüggőséget, azonban hamar beláthatjuk, hogy ezek mind a mi érdekeinket szolgálják, és a problémamentes, konzisztens működést hivatottak biztosítani. A változóink új tulajdonságokat kaptak, és működésük is kissé megváltozott, azonban az alapok

11

1.2. Primitív típusok, és azok fejlődése

megmaradtak, a már korábban látottakkal.

A változónak van : – Neve - Egy azonosító amivel hivatkozni tudunk rá a forrásállományban.

– Típusa - A típus ezentúl nem csak a tárolási igényét, de ábrázolási/kódolási módját is tartalmazza.

A típus ezentúl meghatározza az adott változóval elvégezhető műveletek körét is. Egy numerikus változóval elvégezhetőek a numerikus műveletek (összeadás, szorzás, stb.), a logikai változókkal elvégezhetőek a logikai műveletek. (és, vagy, stb.) Lehetetlenné vált egy változó értékének a részletes kiolvasása. A C#-ban található típusokat az alábbi osztályokra lehet csoportosítani: Egész

Valós

Logikai

Karakter

Szöveg

Egész típusok A következő táblázatban láthatjuk a típusainkat felosztva, előjeles, és előjel nélküli csoportosítás szerint, sorra 1, 2, 4, 8 byte helyigénnyel.

Előjel nélküli byte ushort uint ulong

Előjeles sbyte short int long

Típusaink minél több helyet foglalnak a memóriában, annál nagyobb számot vagyunk képesek ábrázolni. Gondoljunk bele, hogy 3 biten, a legnagyobb ábrázolható szám a hét.

1 byte-on (8 bit), már 255. Ezt könnyedén kiszámolhatjuk, ha vesszük a számrendszer alapját, a pozíciók számával hatványozzuk, és az eredményből kivonunk egyet.

(28 − 1 = 255) 0 . . . 255 0 . . . 65536 0 . . . 4.294.967.296 0 . . . 18446744073709551615

byte ushort uint ulong

sbyte short int long

−128 . . . 127 -32768 . . . 32767 +/- 2.147.483.648 +/-9 223372 036854 775808

Az előjel nélküli típusoknál nullától tudunk ábrázolni, az előjeleseknél az első bit-et előjelnek használjuk, így összességében egy bit-et elveszítünk, ennek eredményeképpen kisebb számokat tudunk csak ábrázolni. Azonban emiatt nem csak pozitív egészeket menthetünk el.

12

1. fejezet. Változók és azok működése

Valós típusok A valós típusok tárolási módszerére nem szükséges részletesen kitérnünk, ugyanis igen bonyolult, és hosszas kifejtését nem tartom célszerűnek. Elég tudnunk azt, hogy két valós típusunk van C#-ban. Ezek a float és a double (4-8 byte). A float és a double típusok helyigényükben, és pontosságukban térnek el. A double helyigénye és tárolási pontossága duplája a float-nak.

Logikai típus Logikai típus esetén csupán két lehetséges felvehető értékünk van. Az igaz-hamis. Ezt C# program írása közben az angol megfelelőjükkel tudjuk értékként átadni. (true-false) Tárolási igénye 1 byte. Helypazarlásnak tűnhet, hogy nem egyetlen bit-et foglalunk le, hiszen 0-1 értékek felvétele is elég lenne. Azonban a processzor nem tud egy bit-et megragadni, így szükségünk van egy egész byte-ra. Azonban ez bizonyos előnyökkel is jár.

J

Jegyezzük meg, hogy logikai típus esetén, minden nem nulla érték (1, 2, 34 stb.) számít true-nak

Ennek tudatában, alkalmazhatunk relációs operátorokat bool típusra, ahol false < true.

Karakter típus A karakter típus C#-ban a char kulcsszóval tudjuk használni. Egyetlen karakter tárolására alkalmas, azonban ez nem merül ki a számok, vagy az abc karaktereiben. Szimbólumok, és írásjelek is a részeit képzik. Memóriánk felépítése még most is ugyan olyan, mint a többi típusunknál ecseteltük, így karaktereink tárolására nincs más mód, mint számokkal reprezentálni őket. Ebben segít bennünket az ASCII, és UNICODE kódtáblázat. Részletes felépítésüket nem részletezzük. Annyit elég tudnunk, hogy minden szimbólumot egy szám reprezentál.

Memóriaigénye 2 byte.

Szöveg típus Ez a típus az első összetett adatszerkezetünk. Karakterekből felépített, dinamikus helyfoglalású típus. Kulcsszava a string. Egy N karakterből álló szöveg 2*N mennyiségű byte-ot foglal le a memóriában, ezen felül egy zárókarakterre van szükségünk hogy jelezzük a szöveg végét. (A valóságban ehhez még számos byte lefoglalása megtörténik, memóriakezelési szempontok miatt.) A szöveg n.-edik karakterét a nev[n] kódjával érhetjük el. Pl. a string elnevezes = "kerék"; változó harmadik eleme (elnevezes[3]) egyenlő az ’é’ karakterrel. Ne felejtsük el, hogy C#-ban nullától indexelünk.

13

1.3. Változókra alkalmazható operátorok

1.3. Változókra alkalmazható operátorok A következőkben C#-ban használható szintaktikákat fogunk megjeleníteni. Ezek a részletek önmagukban nem „lefuttathatóak”. Ezek későbbi ellenőrzésére szolgál a gyakorlati rész, ahol kitérünk minden fontos információra.

Tehát ismerjük a módját különféle értékek lementésére a memóriában. Ha C# ban létre akarunk hozni egy egész típusú változót, azt így kell megtennünk: 1 2 3

int valtozo ; valtozo = 10; valtozo = 20;

Figyeljünk oda a szintaktikára: tipus elnevezes = ertek; Az első sort deklarációnak hívjuk, a másodikat inicializálásnak. Ez a művelet elvégezhető egyben is. (int valtozo = 10;) Azért szeretnénk tárolni a memóriában adatokat, mert később szeretnénk velük dolgozni. A változó azért jó eszköz, mert futási időben megváltoztathatjuk az értékét, ahogyan azt a neve is sugallja. A 3. sorban felülírjuk az előző értéket egy új értékkel.

1 2 3

int a = 2; int b = 3; int c = a + b ;

Egy int típusú változóra elvégezhetőek matematikai műveletek, és a fordító nem fog hibát jelezni. Azonban figyelnünk kell arra, hogy a típusaink korlátoltak : 1 2 3

byte a = 255; byte b = 1; byte c = a + b ;

Ez esetben valami gond történik, hiszen a byte típus csupán 8 bit-en ábrázol, és a legnagyobb ábrázolható érték a 255. Ha a fordító engedné hogy ezt megtegyük, amit ilyen formátumban nem enged meg, akkor is hibás értéket kapnánk. Pontosabban 0-át. Túlcsordulásnak nevezzük, amikor „újrakezdődik”, vagy átfordul a változó értéke a legkisebb ábrázolható számra. Azonban a legtöbb fejlesztőfelület intelligensen kezeli az ilyen helyzeteket, és figyelmeztet bennünket.

1.3.1. Túlcsordulás Mielőtt jobban megértenénk, látnunk kell hogyan adunk össze kettes számrendszerben.

Adjuk össze az 101(2) -et az 011(2) -el. Írjuk fel őket egymás alá :

Jobbról balra haladunk.

+

1 0

0 1

1 1

1

0

0

0

14

1. fejezet. Változók és azok működése

1 + 1 = 2 → 10(2) , ahol 1 a maradék.

1 + 0 + 1 = 2 → 10(2) 1 + 1 + 0 = 2 → 10(2)

1. lépés : 2. lépés : 3. lépés :

Így kinullázódik a 3 bitünk. Az utolsó lépésben is leírjuk a maradékot. Ellenőrizzük le, helyes-e a számítás. Az 101(2) értéke 5(10) , a 011(2) értéke 3(10) . Belátható hogy 5 + 3 = 8(10) → 1000(2) A számítás értéke jó, azonban ha szorosan ragaszkodnánk hozzá hogy 3 biten ábrázoljuk az eredményt, akkor elveszítenénk az utolsó bitet. Ilyenkor beszélünk túlcsordulásról, hiszen a legnagyobb ábrázolható szám 3 pozíción, a 7.

Nézzük meg a 255, 8 biten való ábrázolását, és adjunk hozzá 1-et, számoljuk ki az eredményt: 0

1

1

1

1

1

1

1

1 1

0

0

0

0

0

0

0

0

+

1

Belátható, hogy ha hozzáadunk egyet a 11111111(2) , akkor a teljes byte kinullázódik a túlcsordulás miatt.

J

Általánosságban elmondható, hogy amennyiben egy összeadás értéke beláthatóan túllépi a típus tárolási korlátaiból adódó legnagyobb számot, úgy túlcsordulás áldozatai leszünk.

Változóinkra tehát széles körben alkalmazhatóak operátorok, de tudnunk kell hogy ezek pontosan hogyan működnek !

1.3.2. Operátorok viselkedése Ahogy azt már korábban említettük, a típusok nem csupán a helyigényt kötik le, hanem a változóra alkalmazható operátorok körét/viselkedését is.

1 2 3

string a = " Hello " ; string b = " World ! " ; string c = a + b ;

Ha kiírjuk a c változót a konzolablakunkra : Hello World ! - lesz az eredményünk.

A szöveg típusú változóra az összeadás összefűzésként viselkedik. (Konkatenáció) Karakterek esetén valójában egész számként kezeli őket a fordító, ami az ASCII/UNICODE táblázatban található pozíciójukat reprezentálja.

1 2 3

char a = ’a ’; // 97 char b = ’b ’; // 98 int c = a + b ; // 195

1.4. Konstans változók

15

Vegyük észre hogy két char összeadása egy int típust ad vissza.

J

Ha a Console.WriteLine((char)97); kódot leteszteljük, azt fogjuk tapasztalni hogy a Console ablakunk megjeleníti az a karaktert.

Figyelnünk kell hogy egész számoknál hogyan végzünk el osztást: 1 2 3

int a = 3; int b = 2; int c = a / b ; // Az eredm é ny 1 lesz .

A fordító automatikusan egész osztást fog végrehajtani, azaz az eredmény két egész típus osztásának is egész lesz. Ezt onnan is látjuk hogy ezt elbírjuk tárolni egy int típusú változóban hibaüzenet nélkül. Ha átírjuk double típusra a c változót, sem oldódik meg a helyzet. Jeleznünk kell a fordítónak hogy a jobb oldali kifejezés eredményét szeretnénk double típusban.

1 2 3

int a = 3; int b = 2; double c = ( double ) a / b ; // Az eredm é ny 1.5 lesz .

Ezt típuskényszerítésnek hívjuk, és a jobb oldali kifejezés kiértékelésének a menete miatt történik. Ennek okát, most nem részletezzük. Gyakori, szinte észrevehetetlen kezdő hibák közé tartozik, ugyanis szintaktikailag helyes, csupán szemantikailag helytelen.

W

Szintaktikai hibának nevezzük azt, amikor a nyelv szabályait sértettük meg. Szemantikai hibának, amikor a nyelv szabályait nem sértettük, de működés közben nem az történik, amit szerettünk volna.

Idővel ahogy gyakorlatra tettünk szert, a különböző, főleg gyakran használt típusaink különleges viselkedése magától értetődő lesz számunkra. A kezdetekben ne féljünk a kísérletezéstől, és fogadjuk örömmel a fordító által dobott hibaüzeneteket, hiszen ezekkel fog tudásunk bővülni. Amikor elkezdjük megtanulni a programozást, programjaink működése során, számtalan hibaüzenettel fogunk találkozni, és programunk nem megfelelő működést fog tanúsítani, azonban ez elengedhetetlen része a fejlődésnek, és tanulásnak.

1.4. Konstans változók Bizonyos esetekben elakarunk tekinteni a változók dinamikus működésétől, és csupán egy memóriában eltárolt értékhez akarunk hozzáférni, úgy, hogy megbizonyosodunk arról, hogy a program futása közben ez az érték nem változhat. Vannak bizonyos értékek, amelyeknek az értéke fix, vagy fix kell hogy legyen. Jó példa erre a Math.Pi. Ezek a változók többnyire globális változóként definiáltak, azonban erre semmi sem kötelez bennünket.

Konstans változót a const kulcsszóval tudunk deklarálni.

16

1 2

1. fejezet. Változók és azok működése

const int Pi = 3.14; int 2 Pi = Pi * 2;

Fontos, hogy a konstans értékét kiolvashatjuk, de nem módosíthatjuk.

1.5. Változó élettartam és hatáskör Egy változó esetén, egy nagyon fontos tulajdonság, hogy a változónak meddig ér a hatásköre, és az élettartama. Általánosságban kijelenthető hogy egy változó hatásköre, a deklarációja kezdetétől, az adott programblokk végéig tart. Programblokkjainkat kapcsos zárójel közé tesszük.

1 2 3 4 5

static void main () { int a ; ... }

A harmadik sorban kezdődik az a változó hatásköre. Belátható, hogy a változó deklarálása előtt nem használhatjuk azt, így hatásköre csak itt kezdődhet. Az érdekesség, hogy az ötödik sorban a változó megszűnik létezni számunkra. Ebben a példában nem látható tisztán, ez pontosan mit is takar. Azonban a későbbiekben látni fogjuk hogy nem csupán a main() lehet programblokkunk, hanem azon belül lehet belső programblokk is, és így rögtön érezni fogjuk, miért is fontos, a hatáskör fogalma.

1 2 3 4 5 6 7 8

static void main () { int a ; { int b ; } b = 2; }

Amennyiben egy változó hatáskörén kívül vagyunk, a fordító hibát fog jelezni. Amikor megpróbálunk hivatkozni a b nevére, hibaüzenettel leáll a programunk. Hiszen az előző szabály szerint, a b változó deklarációja egy belső blokkban van, így annak hatáskörének végét a programblokk vége jelzi. Így a fordító ezt a változót nem látja deklaráltnak sem.

Azonban hatáskörén kívül már lehetséges az újra deklaráció. Mindaddig amíg nincs átfedés, használhatjuk az adott változónevet.

1 2 3 4 5 6 7

static void main () { { int ertek = 0; } int ertek = 99; }

1.6. Névadási szabályok

17

Ne felejtsük el, hogy a belső blokkban létrehozott ertek változónak, semmilyen köze sincs, a programblokk után újra deklarált, és inicializált ertek változóhoz. Az ilyesfajta elnevezések, megértésbeli gondokat okozhatnak, hiszen a forrást olvasó, joggal gondolhatná, hogy ugyan arról a változóról van szó. Ezért ezeket az elnevezési eseteket, megpróbáljuk elkerülni.

1.6. Névadási szabályok Ahhoz hogy a kódunk forráskódja jól értelmezhető, nyomon követhető kód legyen, számos más teendőnk mellett figyelnünk kell a változóink elnevezésére is. Vannak kötelező elnevezési szabályaink: – betűvel, vagy aláhúzással kezdődhet – számmal, betűvel, aláhúzással folytatódhat – kis-nagy betű érzékenység – Tiltott karakterek: • • •

J

szóköz kötőjel írásjelek, és egyéb szimbólumok C#-ban megengedhető a magyar ékezetes betűk használata, azonban nem javasolt. Amennyiben kódunkat megosztanánk külöldi fejlesztőkkel is, így kódolási problémákba fognak ütközni a forrásállomány megtekintése során - a programozók ezért kerülik a magyar ékezetek használatát

A változóink kezdőbetűje legyen kicsi, és amennyiben szóváltás van, úgy értelmezést elősegítő nagybetűt helyezzünk el. (pl.: oldalMeret, szamitasEredmeny) Ne akarjuk jelezni a változónk esetében a típust, ugyanis felesleges.

1 2 3

// Ker ü lend ő : string strNev ; int intErtek ;

4 5 6 7

// helyes : string nev ; int ertek ;

Adjunk változóinknak beszédes, sokatmondó neveket. Kerüljük a felesleges rövidítéseket, és csak az általunk értelmezhető elnevezéseket. Ne féljünk a hosszú változónevektől, hosszútávon olvashatóbb lesz a forráskódunk, és saját magunknak is nagy segítség, egy régi projekthez való visszatérésnél, hogy könnyen értelmezhető legyen számunkra is a gondolatmenetünk.

18

1. fejezet. Változók és azok működése

1.7. A konzol használata A konzol a legegyszerűbb be, és kiviteli lehetőségünk. Ezen keresztül kommunikálhatunk a saját programunkkal. A Console osztály lehetőséget nyújt számunkra hogy ezt használjuk.

Két alapvető függvényt használunk kiíratásra.

– Console.WriteLine() → kiírás és soremelés – Console.Write() → kiírás A WriteLine() alapvetően egy adat kiírására alkalmas. Formátum string alkalmazásával azonban lehetőségünk van összetett kiíratásra is.

1 2 3

string a = " Marci " ; int kor = 18; Console . WriteLine ( " {0} most {1} é ves . " ,a , kor ) ;

Ezt úgy kell értelmeznünk, hogy a {} jelek közé tett számok, a vessző után felsorolt változók indexei. A nulladik elem az a változó, aminek értéke: "Marci", az első elem a kor változó, aminek értéke 18. Így a kiíratásunk a következőképpen fog látszódni a Konzolunkon : Marci most 18 éves.

Beolvasásra a következő függvényt használjuk: – Console.ReadLine(); A ReadLine() egyetlen adat beolvasására képes. Így ha több adat beolvasására van szükségünk, így a ReadLine() függvényt annyiszor kell meghívnunk, ahány adatra szükségünk van. Kurzorunk villogása a konzolablakban jelzi, ha beolvasásra vár adatot. string felhasznalo = Console.ReadLine();

Fontos, hogy minden adat, amit a konzolon beírunk, string-ként kezelendő. Ezért az adatok lementésénél figyelnünk kell rá, hogy az adatainkat átkonvertáljuk. int eletKor = Convert.ToInt32(Console.ReadLine()); A Convert osztály nyújt lehetőséget arra hogy különböző típusok között tudjunk konvertálni. Az összes típusunkra találhatunk átalakítást → Convert.ToTípusnév(); formában. Amennyiben int típusba szeretnénk konvertálni, úgy a Convert.ToInt32(); sort használhatjuk. A kapott string paraméterből átalakítja a megfelelő típusra, amennyi-

ben lehetséges ! Gyakorlatilag ugyan ezek a függvények a típusaink kapcsán is elérhetőek, méghozzá típus.Parse(); módon. Az előző példában az ötödik sorban azt is írhattuk volna, hogy ertek = int.Parse(helyes);, a működésen nem változtatott volna, ugyanis a két függvény megegyezik.

1 2

string helyes = " 12 " ; string helytelen = " ban á n " ;

3 4 5 6

int ertek ; ertek = Convert . ToInt32 ( helyes ) ; ertek = Convert . ToInt32 ( helytelen ) ;

1.8. Gyakorlati feladatok

19

Az ötödik sor típuskonverziója hiba nélkül lefog futni, hiszen a "12" átváltható a 12 értékre. Azonban a hatodik sorban a program hibás működésbe fog futni, amit a fordító nem is jelezhet előre. Futási időben előforduló hiba a program végzetes leállását okozza - előfordulását el kell kerülnünk.

A hibás adatbevitelt tehát el kell kerülnünk, és erre vannak is módszereink, ezeket azonban később fogjuk részletezni.

1.8. Gyakorlati feladatok 1. Mennyi az értéke a következő számoknak: – 10010(2) =?(10) – 11001(2) =?(10) – 011(2) =?(10) – 1101001(2) =?(10) 2. Mi lesz az eredménye a következő összeadásnak : a+b ? ahol → a = "al", és b = "ma".

3. Ha c = a + b;, akkor mi az értéke a c[6] elemének? ahol → a = "össze", és b = "fűzés".

4. Helyes-e az alábbi kód ?

1 2 3 4 5

static void main () { int magassag = 174; byte szelesseg = 312; }

5. Mi lesz az eredménye a következő műveletnek : byte c = a / b; ahol → a = 12, b = 5, és byte típusúak.

6. Helyes-e a következő kifejezés: double c = (double)a / b; ahol → a = 12, b = 5, és byte típusúak.

– Ha nem, miért?

– Amennyiben igen, mennyi c értéke ?

7. Hogyan kérnénk be a felhasználótól a string nev; értékét ?

8. Írjunk egy programot, ami bekéri a felhasználó nevét, és köszön!

20

1. fejezet. Változók és azok működése

1.8.1. Megoldások A megoldásokat kérem csak a feladatok megoldása után nézze meg.

1. Kettes számrendszerbeli számok értékei : – 18(10) – 25(10) – 3(10) – 105(10) 2. "alma" 3. ’ű’ 4. A kód helytelen, mégpedig a byte típus miatt, a maximum ábrázolható szám a 255.

5. Az eredmény 2 lesz.

6. Helyes, értéke 2,4 lesz.

7. string nev = Console.ReadLine(); 8. Név bekérése, és köszönés : 1 2 3 4 5 6

static void main () { Console . Write ( " K é rlek add meg neved : " ) ; string nev = Console . ReadLine () ; Console . WriteLine ( " Szia {0}! " , nev ) ; }

Az eredménye: Kérlek add meg a neved : Péter Szia Péter !_

2. fejezet

Elágazások, és jelentőségük 2.1. Egyszerű elágazás Az elágazások, kifejezetten fontosak programjainkban. Azt szeretnénk, ha az általunk írt algoritmus reagálna a körülményekre, és a viselkedése ez alapján megváltozna. Tudjuk, hogy programunkat a gép soronként értelmezi, a parancsok, utasítások sorban zajlanak egymás után. Azonban, bizonyos feltételek alapján lehetőségünk van, ezen módosítani.

Ez C#-ban, mint ahogy a legtöbb programozási nyelvben is a ha angol megfelelőjével érhető el, az if()-el. Az if() szintaktikája a következő : 1 2 3 4 5 6

if ( Felt é tel ) { parancs ; .. parancs ; }

Amennyiben a feltételünk igaz (true) addig lefutnak azok a parancsok, amik az if blokkjában találhatóak. Ezzel biztosítottuk azt, hogy ez a kódrészlet, csakis, és csakis akkor történjen meg, amikor egy különleges állapot teljesül. Amennyiben szeretnénk valami mást csinálni, az alapján, hogy a feltétel hamis (false), akkor az else ágra lesz szükségünk.

1 2 3 4 5 6 7 8 9 10

if ( Felt é tel ) { parancs ; .. parancs ; } else { parancs ; }

Ez esetben az else ágban lévő parancsok, csakis akkor futnak le, ha a feltétel hamis.

21

22

2. fejezet. Elágazások, és jelentőségük

2.2. Feltételek kiértékelése Így, hogy tudjuk hogy hogyan működik az egyszerű elágazás, a legfontosabb dolog, megértenünk a feltételeink működését, megfogalmazását és hasznosságát.

2.2.1. Relációs operátorok A relációs operátorok a legkönnyebben megérthető operátorok talán, mind közül. Vegyünk két int típusú változó esetét : 1 2

int a = 20; int b = 25;

Ezeknek az értékeknek megnézhetjük az egymáshoz viszonyított helyzetüket. Használható relációs operátorok: – A nagyobb mint B : (A > B) – A nagyobb/egyenlő mint B : (A >= B) – A kisebb mint B: (A < B) – A kisebb/egyenlő mint B: (A <= B) – A egyenlő B-vel: (A == B) – A nem egyenlő B-vel: (A != B) Az első 4 relációs operátorhoz nincs különösebb hozzáfűzni való, működésük egyértelmű. Ami viszont gyakori kezdő hiba, az az egyenlőség vizsgálatához használt operátor.

Nem összekeverendő az értékadás (=) operátorával. Az egy egyenlőségjel a jobb oldalon található értéket, kifejezés értékét próbálja beletenni a bal oldalon található változóba, típusegyezés vizsgálata után. A dupla egyenlőségjel viszont veszi a két oldal értékét, és igazzal tér vissza, amennyiben azok megegyeznek, és hamissal ha nem. A nem egyenlő, ennek a megfordítottja.

Fontos, hogy valami alapján, sorba rendezhetőek legyenek az értékek, amiket relációs operátorokkal vizsgálunk. Például két egész szám a számegyenesen egyértelműen viszonyítható egymáshoz, így eltudja dönteni a fordító, hogy melyik kisebb, vagy nagyobb.

Ha egy char típust nézünk, mivel tudjuk hogy a valóságban egy int típus áll mögötte, ezért erre a típusra is alkalmazhatóak a relációs operátorok. Van azonban számos olyan típusunk, ahol ez nem értelmezhető. Például nézzünk két string típust.

1 2

string text1 = " alma " ; string text2 = " ban á n " ;

Könnyű lenne azt mondani hogy a két string az első karakterek alapján rendezhető.

Ami alapvetően nem is lenne téves gondolat. Azonban a két string a hosszúságuk alapján is rendezhető lenne, mivel azok int típusú értékek. Tehát a fordító, nem értelmezi

2.2. Feltételek kiértékelése

23

ilyen típusra a relációs operátort. De konkrétan megmondhatjuk a fordítónak, hogy mit hasonlítson össze.

1 2

string text1 = " alma " ; string text2 = " ban á n " ;

3 4 5 6 7 8 9

// Karakterek alapj á n haszn á lt rel á ci ó s oper á tor // Ö sszehasonl í tott t í pus : char if ( text1 [0] < text2 [0]) { parancs ; }

10 11 12 13 14 15 16

// Hossz ú s á g alapj á n haszn á lt rel á ci ó s oper á tor // Ö sszehasonl í tottt t í pus : int if ( text1 . Lenght < text2 . Lenght ) { parancs ; }

Vegyük észre, hogy semmi sem kötelez bennünket hogy az egyik string nulladik elemét hasonlítsuk össze a másik nulladik elemével. Erre nekünk kell figyelnünk, hogy konzisztensek legyünk.

2.2.2. Logikai operátorok A logikai operátorok témaköre sem sokkal bonyolultabb mint az eddig tanultaké. Az egyik legfontosabb dolog, a logikai operátorok működésének megértése. Logikai operátorokat bool típusra alkalmazhatunk. (Ne feledkezzünk meg arról, hogy egy relációs kifejezés értéke bool típusú!)

Tagadás Az első, talán legegyszerűbben megérthető operátor, a tagadás. A tagadással megfordítjuk egy kifejezés értékét, azaz igazból hamis, hamisból igaz lesz. Csak az egyszerűség kedvéért írjuk fel táblázatos formában.

Látható, hogy a tagadás (!A) csupán megfordítja a logikai változó értékét.

24

2. fejezet. Elágazások, és jelentőségük

És Egy picivel bonyolultabb operátor, az és. Ez egy kétoperandusú operátor, ellentétben a tagadással. Egy és kifejezés, csakis akkor igaz, ha mind két operandus igaz. C#-ban, az és operátor megfelelője a dupla & jel, azaz &&. Fontos, hogy dupla, hiszen az egy & jel a bitenkénti és.

Az és működéséből, következik egy érdekes dolog. Ahhoz, hogy egyértelműen megtudjuk mondani egy kifejezés értékét, nem szükséges ismernünk az és mindkét oldalát. Hiszen, belátható, hogy amennyiben az első érték hamis/0, akkor egyértelműen meghatározható a kifejezés értéke, mégpedig hamis. Ezt a fordító ki is használja. Amikor a fordító eljut egy kifejezés esetén, arra a pontra, hogy egyértelműen megállapítható a kifejezés értéke, nem elemzi azt tovább, hanem visszatér az értékkel. Ezt nevezzük rövidzár kiértékelésnek.

J

A rövidzár kiértékelés nem csak és operátornál használható, hanem a vagy-nál is. Ezt számos esetben fogjuk használni/kihasználni bizonyos dolgok érdekében.

Vagy A következő amit megkel vizsgálnunk, az a vagy működése. A kifejezés értéke, akkor lesz igaz, ha bármelyik oldal igaz. Jele C#-ban a ||. Nézzük a táblázatot.

Belátható, hogy a rövidzár kiértékelés itt úgy működhet, hogy amennyiben az első érték igaz, nem szükséges megvizsgálnunk a következőt, hiszen egyértelműen meghatározható a kifejezés értéke.

2.3. Összetett elágazások

25

Összegzés Belátható, hogy ezek tagadhatóak, így megfordítva a különböző értékeket. Az és(and) tagadása a nand, a vagy(or) tagadása a nor. Ezeket logikai kapuként is ismerhetjük.

Elképzelhetjük őket egy áramkörben, mint egy alkatrész, ahol az és háromlábú alkatrész.

Két bemenet, és egy kimenet, csupán akkor küld jelet, a harmadik, kimeneti lábon, ha mind a két bemenetén is van feszültség. És így tovább. Ezekből a logikai kapukból épül fel a számítógépünk, és programjainkban is nagy szükségünk van ezekre.

Nézzük a táblázatot, a tagadásokkal együtt.

Ezeket az értékeket fontos elsajátítanunk, és fontos, hogy meggondoltan fogalmazzuk meg a logikai kifejezéseink. Később részletesebben kitérünk pár fontosabb dologra, mint pl. a de morgan azonosságok, de ebben a pillanatban elég ezekre koncentrálnunk.

2.3. Összetett elágazások Amennyiben nem kétirányú elágazást szeretnénk, problémába ütközünk, jelenlegi tudásunk szerint. Azonban, van lehetőségünk, összetett elágazásokat megfogalmazni. Ennek szintaktikája a következő : 1 2 3 4 5 6 7 8 9 10 11 12

if ( Felt é tel ) { parancs ; } else if ( Felt é tel ) { parancs ; } else { parancs ; }

Akármennyi else if részünk lehet, így különböző mennyiségű feltételt megvizsgálhatunk.

Minél több feltételt kell megvizsgálnunk, annál terebélyesebbre halmozódik a forráskódunk.

26

2. fejezet. Elágazások, és jelentőségük

Ezenkívül egy másik, összetett elágazás forma a switch. A switch vesz egy változót, aminek a különböző értékeit tudjuk lekezelni. Vegyük észre, hogy itt nincs feltételek kiértékelése, csak érték megegyezés vizsgálat van.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

int V á ltoz ó = 9; switch ( V á ltoz ó ) { case 0: parancs ; parancs ; break ; case 1: parancs ; parancs ; break ; ... case 9: parancs ; parancs ; break ; default : parancs ; break ; }

Egyenlőséget vizsgálunk (case érték:), és a parancsokat nem kapcsos zárójelbe kell tennünk, hanem a blokk végét, a break; jelzi, amivel kitörünk a switch-ből.

2.4. Feltételek tervezése 2.4.1. Első példafeladat Most, hogy tudunk feltételeket készíteni, nekiláthatunk megoldani számos problémát.

Vegyünk egy egyszerű geometria feladatot.

– Képzeljünk el, egy koordináta rendszerben, egy egy egység sugarú, origó középpontú kört. És egy bárhol elhelyezkedő P(x,y) pontot.

2.4. Feltételek tervezése

27

A Feladat a következő: Hogyan döntsük el, hogy ha a pont koordinátái véletlenszerűek lehetnek, hogy a körön belül, kívül, vagy a körvonalon található a pont ? Írnunk kell egy jól megfogalmazott feltételt, ami alapján eldönthető, hol helyezkedik a pont. Vegyük észre, hogy a három halmaz, egymást teljesen kizáró, hiszen ha a pont a körön belül helyezkedik el, nem lehet egyszerre kívül, és így tovább.

Próbáljuk megfogalmazni az első állapotot: A körön belül helyezkedik el.

– Tudjuk, hogy a kör Origó középpontú, és hogy a sugara 1.

– Ahhoz, hogy azt tudjuk mondani, hogy a P(x, y) pont, a körön belül helyezkedik el, tudnunk kell az origótól való távolságát, és megvizsgálnunk, hogy ez kisebb-e mint a kör sugara.

Hogyan számoljuk ki két pont távolságát ? Esetünkben könnyű dolgunk van, hiszen az Origótól való távolságot kell számolnunk, de a módszer más esetben is ez.

Feltudunk rajzolni egy háromszöget, ahol látható, hogy egy derékszögű háromszög átfogójának a méretére van szükségünk. A Pitagorasz tétel segítségével könnyedén kiszámolható, miután belátható, hogy adott a szükséges oldalak mérete, a koordinátákból.

28

2. fejezet. Elágazások, és jelentőségük

Könnyedén belátható, hogy a két befogó mérete, megegyezik a P pont koordinátáival.

A jobb oldali befogó hosszúsága az y értéke, az alsó befogó hosszúsága pedig az x értékével egyenlő. Ez abból adódik, hogy az Origótól nézzük a pont távolságát. Jelenleg nem szeretnék részletesen kitérni két pont távolságának a kiszámítására, az olvasóra bízom hogy utánajárjon.

Ezt felhasználva, máris alkalmazhatjuk a Pitagorasz tételt. p x2 + y 2 = z ahol z a keresett távolság.

Lássuk C#-ban hogyan kell megfogalmaznunk : double z = Math.Sqrt(Math.Pow(x,2)+ Math.Pow(y,2));

J

C#-ban a hatványozás a Math.Pow(alap,kitevő) módon érhető el, míg a gyökvonás a Math.Sqrt() függvénnyel.

Miután megkaptuk ezt az értéket, fogalmazzuk meg a feltételeinket.

1 2

double Px = 1; double Py = 1;

3 4 5

double z = Math . Sqrt ( Math . Pow ( Px ,2) + Math . Pow ( Py ,2) ) ; double r = 1; // A k ö r sugara

6 7 8 9 10 11 12 13 14 15 16 17 18

if ( z < r ) { Console . WriteLine ( " A Pont a k ö r ö n bel ü l helyezkedik el ! " ) ; } else if ( z == r ) { Console . WriteLine ( " A Pont a k ö rvonalon van rajta ! " ) } else { Console . WriteLine ( " A Pont a k ö r ö n k í v ü l tal á lhat ó ! " ) }

Figyeljük meg, az utolsó else ágat! Megvizsgálhattuk volna hogy z > r, de nem tettük, mivel egymást kizáró feltételekről van szó, így az utolsó feltételt nem akarjuk megvizsgálni, hiszen felesleges. Ezzel nyerhetünk egy kis erőforrást, könnyítünk kicsit a programunkon. Ez akkor igen szemléletes, ha három feltételből, az egyik kifejezetten bonyolult, és hosszú, aminek a kiértékelése is időt vesz igénybe.

W

Figyeljünk arra hogy egymást kizáró feltételeknél, a legbonyolultabb feltételt hagyjuk utoljára, így ne kelljen rengeteg számítási kapacitást elpazarolnunk rá !

2.4. Feltételek tervezése

29

2.4.2. Második példafeladat A megoldás kör esetén, tehát nem túl bonyolult. Nézzük meg ugyan ezt a problémát, csak egy négyzet esetén.

– Vegyünk egy Origó középpontú négyzetet – Legyen két egység hosszú az oldala – Vegyünk egy véletlen pozícióra generált P pontot.

Feladat Fogalmazzuk meg a feltételeket, ami ahhoz szükséges, hogy megállapítsuk a P pont viszonyát a négyzethez.

Vegyük sorra a lehetőségeinket : 1. A P pont a négyzeten belül van 2. A P pont a négyzeten kívül van 3. A P pont a négyzet körvonalán helyezkedik el.

Első lehetőség Próbáljuk megjeleníteni a problémát, hogy segítsen megérteni a feladatot. A jövőben minden hasonló problémánál, megpróbáljuk szemléltetni a feladatot, ábrákkal, és diagramokkal. A P pont, csak akkor lehet a négyzeten belül, ha az Y koordináta, a négyzet határain belül van(sötétkék terület).

30

2. fejezet. Elágazások, és jelentőségük

Ezen kívül ezt alkalmaznunk kell az X koordinátára is, így kapjuk meg a megfelelő feltételt, hogy a pont, a négyzeten belül van. Ezeket összerakva a következőt kapjuk :

Tehát, a következőket kell kikötnünk : – A pont Y koordinátájának nagyobbnak kell lennie, mint a négyzet alsó Y koordinátája – Egyúttal a pont Y koordinátájának kisebbnek kell lennie mint a négyzet felső Y koordinátája – A pont X Koordinátájának a négyzet bal oldali X koordinátájánál nagyobbnak – Egyúttal a pont X koordinátájának a négyzet jobb oldali X koordinátájánál kisebbnek kell lennie

2.4. Feltételek tervezése

31

És csakis ebben az esetben mondhatjuk azt, hogy a pont a négyzeten belül helyezkedik el. Esetünkben, a négyzet koordinátáit nem kell külön tárolnunk. Mivel két egység oldalhosszal rendelkezik, és origó középpontú, a sarkok koordinátái a következők :

Tehát az első feltételünk valahogy így kell hogy kinézzen: 1 2

double Px = 1; double Py = 1;

3 4 5 6 7

if ( Py > -1 && Py < 1 && Px > -1 && Px < 1) { Console . WriteLine ( " A Pont a n é gyzeten bel ü l helyezkedik el ! " ) ; }

W

Vegyük észre az egyenlőségjelek hiányát ! Ha kisebb-egyenlő, és nagyobb-egyenlő operátorokat használnánk, lefednénk azt a lehetőséget is, hogy a P pont a négyzet oldalán van, amit ebben az esetben, semmiképp sem szeretnénk.

Gondoljunk bele az eddigi ismereteinkbe. Ha a pont nem a négyzeten belül van, akkor csak a négyzeten lehet, vagy azon kívül. Az előzőleg megírt feltételt, tehát könnyedén át tudjuk fogalmazni, hogy számunkra használható legyen. Mi történik akkor ha tagadjuk ?

32

2. fejezet. Elágazások, és jelentőségük

Ahhoz, hogy ezt a kérdést megválaszoljuk, picit beszélnünk kell a de morgan azonosságokról. A de morgan azonosságok a logika, és halmazelmélet két alaptételét fogalmazzák meg. A legegyszerűbben megfogalmazva, a következőt jelentik : – nem(A és B) = nem(A) vagy nem(B) – nem(A vagy B) = nem(A) és nem(B) Tehát, azt láthatjuk, hogy ha tagadunk egy kifejezést, megfordul az és-vagy operátor. A fordító ugyan ezt teszi, akkor is, amikor használjuk az ! operátort.

Példafeladat a megoldás megértéséhez Mielőtt visszatérnénk a feladatunkhoz, nézzünk meg egy példát: – Írjunk fel egy olyan feltételt, ami akkor igaz, ha egy szám kisebb mint 100, de nagyobb mint 97 int Szám = Convert.ToInt32(Console.ReadLine()); if(Szám > 97 && Szám < 100){}

Tehát, ez a feltétel, megfeleltethető az A és B formulával, ahol az A az első, a B a második feltétel.

Használjuk a de morgan azonosságot: nem(A és B) = nem(A) vagy nem(B) Hogyan tagadjuk az A-t? Jelen esetben az A= Szám > 97 Amikor tagadunk, a relációs operátor megfordul, egyenlőség jellel. Próbáljuk megérteni, miért is jelenik meg az egyenlőségjel:

A kékkel jelölt szakasz, az eredeti feltételünknek megfelelő sáv. Vegyük észre, hogy a 97, és a 100, nem része a szakasznak. (üres kör) Tagadjuk tehát az A-t. Ha az A = Szám > 97, akkor annak tagadása, ha megfordítjuk a relációt :

Látnunk kell azonban, hogy ez nem az eredeti kifejezés megfordítása. Ugyanis a 97 felett, még mindig üres a kör. A tagadása tehát : nem(A) = Szám <= 97

2.4. Feltételek tervezése

33

Nagyon fontos megjegyeznünk, hogy a tagadás a relációs operátorokra hogyan működik.

Tehát, sikerült letagadnunk az A-t. Folytassuk a B-vel.

B = Szám < 100 => nem(B) = Szám >= 100

A de morgan azonosság szerint eljárva, az és-ből, vagy lesz. Tehát, nézzük meg még egyszer, pontosan mit kaptunk.

1 2

Az eredeti kifejez é s ü nk : if ( Sz á m > 97 && Sz á m < 100) {} Ennek tagad á sa : if ( Sz á m <= 97 || Sz á m >= 100) {}

Szemléltetve számegyenesen :

Visszatérés az eredeti feladathoz Tehát, tudjuk, hogy sikeresen megfogalmaztuk a feltételét, annak, hogy a pont a négyzeten belül van, mégpedig a következő módon :

34

1 2

2. fejezet. Elágazások, és jelentőségük

double Px = 1; double Py = 1;

3 4 5 6 7

if ( Py > -1 && Py < 1 && Px > -1 && Px < 1) { Console . WriteLine ( " A Pont a n é gyzeten bel ü l helyezkedik el ! " ) ; }

Tudjuk, hogy három állapotot akarunk lefedni, mégpedig: – A pont a négyzeten belül (kész) – négyzeten kívül – a négyzeten van.

Az előzőek alapján, tudjuk, hogy nem tagadhatjuk egyszerűen a megírt feltételünket, mivel így olyan eshetőséget is lefednénk a feltétellel, amit nem akarunk. Tehát, ahelyett, hogy a tagadás operátorát használnánk, használjuk az eddig tanultakat, és írjuk át a feltételt, az egyenlőségjel kihagyásával, és a logikai operátorok cseréjével. Így megfogalmazzuk azt a feltételt, hogy ha bármelyik koordináta kívül esik a négyzet határain, legyen az akármelyik, akkor biztos, hogy a pont a négyzeten kívül helyezkedik el a pont.

1 2

double Px = 1; double Py = 1;

3 4 5 6 7 8 9 10 11 12 13 14 15

if ( Py > -1 && Py < 1 && Px > -1 { Console . WriteLine ( " A Pont a } else if ( Py < -1 || Py > 1 || Px { Console . WriteLine ( " A Pont a } else { Console . WriteLine ( " A Pont a }

&& Px < 1) n é gyzeten bel ü l helyezkedik el ! " ) ; < -1 || Px > 1) n é gyzeten k í v ü l helyezkedik el ! " ) ;

n é gyzeten helyezkedik el ! " ) ;

Mivel egymást kizáró eseményekről van szó, tudjuk, hogy ha ezek közül a feltételek közül egyik sem igaz, akkor csak a négyzet körvonalán lehet a keresett pont. A feltétel a három közül a legbonyolultabb, és ezáltal a leglassabban kiértékelt feltétel. Az olvasóra bízom, hogy megpróbálja megfogalmazni azt a feltételt, ami akkor igaz, amikor a pont, pontosan a négyzet körvonalán helyezkedik el. Fontosnak tartom ezt a lépést, hogy az olvasó magától próbáljon megoldani egy ilyen feladatot, és lássa, hogy mennyivel hosszabb feltétel lesz az eredménye a munkájának. Ha sikerül megfogalmaznia, és látni a feltétel terebélyességét, utána bizonyára hasznosabbnak fogja találni, az egymást kizáró

2.5. Gyakorlati feladatok

35

halmazok képzését, egy-egy logikai problémánál. Néha rengeteg időt, és nem utolsósorban futási időt tudunk spórolni azzal, ha meggondoltan tervezzük meg a programjainkat, és feltételeinket.

2.5. Gyakorlati feladatok 1. Fogalmazz meg egy olyan feltételt, ami akkor igaz, ha az int number; páros És nagyobb mint 100.

2. Fogalmazz meg egy olyan feltételt, ami akkor igaz, ha a : string text; hossza nagyobb mint 5, És a text[0] eleme a ’c’ karakter.

3. Fogalmazz meg egy olyan feltételt, ami akkor, és csak akkor igaz ha : int number1; és int number2; összege kisebb mint 12 Vagy a különbségük nagyobb mint 4.

Gondolkozz el azon, milyen értékekre lesz igaz a kifejezés.

4. Írjunk egy programot, kérjük be a felhasználótól az életkorát, és írjuk ki hogy a felhasználó nagykorú-e.

36

2. fejezet. Elágazások, és jelentőségük

2.5.1. Megoldások A megoldásokat kérem csak a feladatok megoldása után nézze meg.

1. if(number % 2 == 0 && number > 100) (Ha a számot maradékosan elosztva kettővel nullát kapunk eredményül, a szám páros) 2. if(text.Lenght > 5 && text[0] == ’c’) 3. if(number1 + number2 < 12 || Math.Abs(number1)- Math.Abs(number2)> 4) (A két szám abszolút értékét a Math.Abs() függvénnyel tudjuk lekérdezni.)

(Mivel a feltételben Vagy van, így elegendő az egyik feltételnek megfelelnünk, hogy a feltétel kiértékelése során, igazat kapjunk) 4.

1 2

Console . Write ( " K é rem adja meg az é letkor á t : " ) ; int age = Convert . ToInt32 ( Console . Readline () ) ;

3 4 5 6 7 8 9 10 11

if ( age < 18) { Console . WriteLine ( " Ö n kiskor ú ! " ) ; } else { Console . WriteLine ( " Ö n nagykor ú ! " ) ; }

Az eredménye: Kérem adja meg az életkorát : 20 Ön nagykorú !_