AAO

1
AAO

• Csink László
• 2008. osz

2
Adminisztráció

• Eloadók
• Csink László csink.laszlo_at_nik.bmf.huMiklós Árpád
  miklos.arpad_at_nik.bmf.hu
• A tárgy weblapja http//nik.bmf.hu/csink

3
A tárgy célja

• Ismerkedés az algoritmus fogalmával, egyszeru
  klasszikus algoritmusokkal
• Ismerkedés az algoritmusok implementálásához
  (megvalósításához) szükséges legalapvetobb
  adatstruktúrákkal
• Bevezetés az objektumorientált programozási
  paradigma alapjaiba
• Algoritmuskészítési készség kialakítása
• AAO Algoritmusok, Adatstruktúrák, Objektumok
• Mindez az OOP tárggyal való szoros
  együttmuködésben valósul meg

4
Irodalom

• Könyvek, amibikbol lehet meríteni
• Cormen, Leiserson, Rivest Algoritmusok (újabb
  kiadás is, valamint Informatikai algoritmusok)
• Trahtenbrot Algoritmusok és absztrakt automaták
• Kotsis et al Többnyelvu programozástechnika
• Lovász L., Gács P. Algoritmusok
• Referencia linkek
• Matematikai háttér http//mathworld.wolfram.com/
• Lexikon http//wikipedia.org/
• Ajánlott feladatgyujtemény (PPKE)(A Kotsis et al
  könyv mellett) http//digitus.itk.ppke.hu/lovei/
  2007-2/feladatok.html

5
Hogyan készüljenek?Sajnos, igen nagy szokott
lenni a bukási arány!

• A diák csak vázlatot jelentenek, a vetített
  anyag nem tankönyv!
• Sokakat megtéveszt, hogy az eloadásokon nincs
  névsor ellenorzés. Ennek ellenére folyamatosan
  kell tanulni már a félév elejétol, sok
  gyakorlatra van szükség, a tudásnak érlelodnie
  is kell
• Az eloadásokon tárgyalt algoritmusokat célszeru
  C-ban otthon megírni
• A Kotsis könyvben található algoritmusokat
  elolvasni, megérteni, megpróbálni segítség nélkül
  megírni
• A feladatgyujtemény feladataira a programokat
  megírni
• Az OOP gyakorlatokon tanultakat hasznosítani

6
Algoritmus fogalma

• Az algoritmus egy eljárás (jóldefiniált
  utasítások véges halmaza), amelyet valamely
  feladat megoldására készítünk. A feladat egy
  adott kezdeti állapotból egy meghatározott
  végállapotba jut (szakszóval terminál).
• Az algoritmus kiszámítási bonyolultsága és
  hatékony implementációja az alkalmazott
  adatstruktúrától függ.

7
Informális és formális definíció

• Az algoritmus tipikusan kisebb-nagyobb
  alkotórészekbol épül fel. Az egyszeru algoritmus
  egy ételrecepthez hasonlítható.
• A formális definíció Alan Turing (Turing gép,
  1936) és Alonzo Church (lambda kalkulus)
  matematikusokhoz kötheto. (lásd Haladó
  algoritmusok tárgy a késobbiekben)

8
Informális megközelítés ételrecept

• Informálisan hétköznapi szavakkal egy
  egyszeru algoritmus egy receptnek tekintheto.
• A recept tartalmazza az adott étel
• nevét
• elkészítésének idejét
• a szükséges alkotórészek nevét és mennyiségét
• az elkészítéshez szükséges eszközöket illetve
  környezetet (például mikrosüto)
• az elkészítéshez szükséges eljárásokat
  meghatározott sorrendben
• az elkészült adagok számát
• a kalóriatartalmat egy adagra vetítve
• az étel eltarthatóságának idejét.

9
A másodfokú egyenlet receptje 1.

• Készítsünk algoritmust az ax2bxc0 egyenlet
  megoldására.
• 1. lépés az input adatok meghatározása
• Jelen esetben a, b, c valós számok
• 2. lépés output adat(ok) meghatározása egy x
  valós szám (egy megoldás, illetve ha a két gyök
  egybeesik), x1 és x2 valós számok (két különbözo
  megoldás), illetve a nincs valós megoldás
  szöveg.

10
A megoldás menete

• Úgy fogjuk a megoldás menetét prezentálni, ahogy
  tervezés közben eszünkbe jut
• Óhatatlan, hogy menet közben lesznek még hibák,
  mert nem pattan ki a tökéletes megoldás az
  agyunkból egyszerre
• Minden lépés után elemezzük, hogy jól muködik-e a
  programunk, és ha nem tökéletes, akkor javítunk
  rajta

11
A feladat receptje a hozzávalók

• A recept adatai
• Név MASODFOKU
• elkészítésének ideje (és szerzo) 2006-07-11. CsL
• a feltétlenül szükséges adatok neve és típusa
• a,b,c, 3 valós szám (INPUT)
• x valós szám, VAGY x1 és x2 valós számok, VAGY
  nincs valós megoldás szöveg (OUTPUT)
• az elkészítéshez szükséges eszközök illetve
  környezet
• Turbo C 3.0 (természetesen más is lehetne,
  például C) Windows XP operációs rendszer alatt
  (ez is lehetne más)
• az elkészítéshez szükséges eljárások
• gyökvonás, abszolút érték (ezek elkészítettnek
  tekintett programok)
• Megjegyzés Az OOP gyakorlatokon Visual Studio C
  környezetben fogunk dolgozni. (A Turbo C
  elonye, hogy ingyenes)

12
A feladat pontosítása

• Hasznos dolog egy konkrét példát megnézni
  4x2-12x80
• A megoldás x12 x21Erre a feladatra ez a két
  értékadás tulajdonképpen egy program. Ez a
  program azonban nem ad megoldást a 3x24x-2.110
  feladatra. Azt szeretnénk, hogy ugyanaz a a
  program erre a feladatra is megoldást adjon.
• Mi a helyzet az 12x80 egyenlettel? Ez már
  elsofokú. El kell dönteni, hogy eredetileg a
  másodfokú, vagy a legfeljebb másodfokú egyenlet
  megoldását tuztük-e ki célul?
• Megállapítjuk, ezen példa kapcsán, hogy a feladat
  pontos mibenléte gyakran a megoldás során
  tisztázódik. A feladat specifikációja tehát
  finomodhat a megoldás közben.

13
A specifikáció

• Oldjuk meg az ax2bxc0 egyenletet minden a, b,
  c valós szám esetén.Nevezzük aax2bxc0 a,
  b, c valós számokproblémaosztálynak, melynek a
  megoldását keressük.
• Lehetett volna a problémaosztályt ax2bxc0
  a, b, c valós számok és a?0halmaznak
  választani, ekkor a megoldási algoritmus kicsit
  egyszerubb, de kevésbé általános.

14
Létezik-e megoldás?

• Tudjuk (például mert érettségiztünk ?), hogy van
  megoldóképlet

Ha komplex megoldást nem engedünk meg azaz a
specifikációt úgy finomítjuk tovább, hogy valós x
megoldásokat keresünk akkor nincs megoldás.
15
Tanulságok

• Hajlamosak vagyunk azt gondolni, hogy mindig
  létezik valamilyen megoldás, talán azért, mert
  hozzászoktunk a megoldható feladatokhoz a
  középiskolában. Vannak azonban algoritmussal nem
  megoldható problémák. Nem oldható meg például a
  szögharmadolási probléma tetszoleges szög
  harmadának megszerkesztése.
• Egy probléma algoritmussal való megoldhatóságának
  kérdése igen mély dolog, lásd incompleteness
  theorem a wikipedia-ban. (E tételt felállító Kurt
  Gödelrol az az anekdota szól, hogy Einstein csak
  azért járt be Princetonban az egyetemre, hogy
  Gödellel sétálhasson haza és beszélgethessenek ?)

16
Elso nekifutás
gy mint egész nem jó, pl. b1.1., a1, c0.2

• VÁLTOZÓK gy, a,b,c VALÓS SZÁM
• BEOLVAS(a,b,c)
• gy ? (bb-4ac)
• HA gy 0 AKKOR gy ? GYOKVONAS(bb-4ac)
• EGYÉBKÉNT KIIR(nincs valós megoldás)
• Itt folytatódna a megoldás, de csak akkor, ha a
  gyökvonás lehetséges volt. Mivel a gylt0 esetben a
  KIIR végrehajtása után nem akarjuk, hogy a
  program folytatódjon, ezért trükkösen
  megcseréljük a feltételt a HA mögött.

értékadás
17
Folytatjuk
6., 7., 8. sorok egybetartozásának jelölése (a
zárójelek párban vannak!)

• VÁLTOZÓK gy,a,b,c, x1 VALÓS SZÁM
• BEOLVAS(a,b,c)
• gy ? (bb-4ac)
• HA gy lt0 AKKOR KIIR(nincs valós megoldás)
• EGYÉBKÉNT
• gy ? GYOKVONAS(bb-4ac)
• HA gy0 AKKOR x1 -b/(2a)
• EGYÉBKÉNT folytatni kell a dolgot
• Piros színnel jelezzük a változásokat az
  elozoekhez képest.

18
Tovább folytatjuk (EZ MÉG NEM VÉGLEGES!

1. VÁLTOZÓK gy,a,b,c, x1,x2 VALÓS SZÁM ag EGÉSZ
   SZÁM
2. BEOLVAS(a,b,c)
3. gy ? (bb-4ac)
4. HA gy lt0 AKKOR ag1
5. EGYÉBKÉNT ag2
6. gy ? GYOKVONAS(bb-4ac)
7. HA gy0 AKKOR x1 -b/(2a)
8. EGYÉBKÉNT ag3
9. x1-bgy/(2a)
10. x2-b-gy/(2a)
13. ESETEK ag
14. 1 KIIR(nincs valós megoldás)
15. 2 KIIR(egy megoldás van , x1)
16. 3 KIIR(két megoldás van, x1, x2)
17. ESETEK VEGE

19
Javítások, megjegyzések

• Kellenek további zárójelek
• x1(-bgy)/(2a)
• x2(-b-gy)/(2a)
• Feltételezzük, hogy a KIIR argumentumában ha
  magyar mondat van, akkor a szöveg íródik ki, ha
  változónév van, akkor a változó értéke. Azt is
  feltesszük, hogy a BEOLVAS a megfelelo változókba
  a billentyuzetrol megadott adatokat elhelyezi. A
  BEOLVAS és a KIIR megvalósításával nem
  bíbelodünk.
• Mi történik, ha a 7., vagy a 9. vagy a 10. sorban
  a0 eset áll elo? Ekkor nullával való osztásra
  utaló hibaüzenet generálódik. Az ilyen esetek
  kezelésére a legtöbb nyelvben vannak eszközök
  (ezzel most nem foglalkozunk), hanem megpróbáljuk
  elore látni, hogy ilyen eset elofordulhat.

20
a0 eset

• HA a0 AKKOR
• Megoldjuk a bxc0 egyenletet
• EGYÉBKÉNT
• Amit eddig csináltunk (a?0, b,c tetszoleges)

Kész programblokk
Megírandó programblokk
A lépésenkénti finomítás módszerét alkalmazuk,
pszeudokód segítségével.
21
A nyilak jelzik a megfelelo színu zárójelpárokat,
azaz hogy melyik AKKOR és EGYÉBKÉNT melyik HA-hoz
tartozik. Az alapértelmezés pont olyan, hogy ezek
a zárójelek elhagyhatók.

• VÁLTOZÓK gy,a,b,c, x1,x2 VALÓS SZÁM
• BEOLVAS(a,b,c)
• HA a0 AKKOR
• HA b0 AKKOR
• HA c0 AKKOR KIIR(minden valós szám megoldás)
• EGYÉBKÉNT KIIR(nincs megoldás)
• EGYÉBKÉNT x1-c/b
• EGYÉBKÉNT
• Amit eddig csináltunk (a?0, b,c tetszoleges)

22
A program (algoritmus) összerakása

• PROGRAM MASODFOKU
• VÁLTOZÓK gy,a,b,c, x1,x2 VALÓS SZÁM ag
  EGÉSZ SZÁM
• BEOLVAS(a,b,c)
• HA a0 AKKOR
• HA b0 AKKOR
• HA c0 AKKOR ag4
• EGYÉBKÉNT ag5
• EGYÉBKÉNT ag6 x1-c/b
• EGYÉBKÉNT gy ? (bb-4ac)
• HA gy lt0 AKKOR ag1
• EGYÉBKÉNT ag2
• gy ? GYOKVONAS(bb-4ac)
• HA gy0 AKKOR x1 -b/(2a)
• EGYÉBKÉNT ag3
• x1(-bgy)/(2a)
• x2(-b-gy)/(2a)

• ESETEK ag
• 1 KIIR(nincs valós megoldás)
• 2 KIIR(egy megoldás van , x1)
• 3 KIIR(két megoldás van, x1, x2))
• 4 KIIR(minden valós szám megoldás)
• 5 KIIR(nincs megoldás)
• 6 KIIR(elfajulo egyenlet, egy megoldás, x1)
• ESETEK VEGE
• PROGRAM VÉGE

23
Közelíto gyökvonás (Newton módszer)
Legyen Agt0, emelybol gyököt szeretnénk vonni, és
gy1 tetszoleges, például 1. Ekkor elég nagy n-re
gyn közel van egy számhoz, amely A
négyzetgyöke. Más szóval a gyn sorozat konvergens
és határértéke A négyzetgyöke. Ilyenkor elég nagy
n-re gyn és gyn1 egy tetszolegesen elore
megadott számnál is közelebb kerülnek egymáshoz.
A következokben gyn helyett gy-t, gyn1 helyett
ujgy-t írunk és iteratíven számolunk.
24
A gyökvonás programja

1. // inp adott szám, melybol gyököt akarunk vonni
2. VÁLTOZÓK in, ujgy, gy, d, eps DUPLAPONTOS
3. BEOLVAS(inp)
4. gy 1.0
5. d1.0
6. eps0.00001
7. ISMETELNI HA( d gt eps)
8. ujgy (1.0/2)(gy inp/gy)
9. d ujgy gy
10. ujgy gy
12. KIIR(gy)

Abszolút érték
A piros rész ismétlodik mindaddig, amíg a sárga
rész teljesül. Figyeljük meg, hogy d menetközben
változik!
25
6 négyzetgyökének közelíto számítása
gy ujgy d (ujgy-gy)
1 3.5 2.5
3.5 2.607143 0.892857
2.607143 2.454256 0.152886
2,454256 2,449494 0.004762
2.449494 2.44949 4.628819e-06
26
Vigyázat!

• A fentiek csak azért muködtek jól, mert tudtuk
  (matematikából), hogy gyn konvergens.
• Ha most
• akkor ugyan sn1-sn bármilyen kicsi lehet, sn
  mégsem konvergens!
• Tanulság egy program használhatóságához
  szükséges, hogy az elméleti megalapozás korrekt
  legyen! Anélkül, hogy a gyn konvergenciáját
  bebizonyítjuk, vagy legalább hivatkozunk a
  megfelelo szakirodalomra, a fenti program nem ad
  megoldást, mert nem tudhatjuk, hogy véget ér-e a
  program, és ha igen, korrekt eredményt ad-e?

27
Példa Hogyan keresünk algoritmust egy feladatra
igazi alkalmazásoknál?

• A napi gyakorlatban ahelyett, hogy magunk
  készítünk algoritmust sokszor inkább
  körülnézünk. Pontosabban mindig körülnézünk,
  hogy van-e megoldás a feladatunkra, vagy nekünk
  kell nekifognunk megcsinálni (kivétel persze a zh
  vagy vizsga ?)
• Nézzünk egy példát tegyük fel, hogy egy szám
  prím vagy összetett voltát akarjuk megállapítani.
• Keresünk egy algoritmus gyujteményt, például a
  MathWorld weblapját (ld. referencia linkek)
  http//mathworld.wolfram.com/
• Mivel jól tudunk angolul ?, könnyedén
  elnavigálunk az adott területre Number Theory,
  Prime Numbers, Primality Testing.

28
ERATHOSTENESI SZITA
An algorithm for making tables of primes.
Sequentially write down the integers from 2 to
the highest number you wish to include in the
table. Cross out all numbers which are divisible
by 2 (every second number). Find the smallest
remaining number . It is 3. So cross out all
numbers which are divisible by 3 (every third
number). Find the smallest remaining number . It
is 5. So cross out all numbers which are
divisible by 5 (every fifth number). Continue
until you have crossed out all numbers divisible
by . The numbers remaining are prime.
Forrás MathWorld
29
Akkor miért nem csináljuk mindig így?

• A feladat pontos megértéséhez gyakran el kell
  kezdeni megoldani a feladatot. Nem mindig van
  tehát elegendo információnk a feladatmegoldás
  kezdetén ahhoz, hogy algoritmus adatbázisokat
  vagy szakirodalmat használjunk.
• Ahhoz, hogy a megfelelo megoldási változatot
  (paraméterek, sebesség, környezet stb.)
  kiválasszuk, algoritmuselmélet ismeretekre és
  implementációs gyakorlatra van szükségünk,
  melyet például ez a tárgy is adhat.
• Lehet, hogy az adott feladatra nem találunk az
  igényeinket kielégíto megoldást.
• Lehet, hogy a talált megoldásnál jobb jut
  eszünkbe (hiszen az irodalomban és a weben
  publikált megoldásokat is kitalálta valaki
  valamikor).

30
Egyszeru programozási tételek

• Sorozatszámítás
• Eldöntés
• Kiválasztás
• Keresés
• Megszámolás
• Maximumkeresés

31
Sorozatszámítás

• A múlt évben minden hónapban eltettem a
  gázszámlát. Szeretném kiszámolni, hogy mennyi
  pénzbe került az éves gázfogyasztás. A megoldás
  lépései
• Lenullázok egy gyujtováltozót.
• A következo két lépést 12-szer ismételem
• Megfogom a soron következo számlát.
• Hozzáadom az elozo összeghez.
• Megvan az összeg.

32
Pszeudokód

• VÁLTOZÓK i, sum EGÉSZ, szamlai VALÓS(vagy
  EGÉSZ)
• i ? 0 sum ? 0
• ISMÉTELNI HA( i kisebb mint 12)
• sum ? sum szamlai
• KIIR(sum)

Január a 0.-dik, február az 1., , december a 11.
hónap a jelölés szerint
33
Eldöntés

• Egy tanuló érdemjegyei alapján szeretném
  eldönteni, hogy kituno-e, vagy sem. Kétféle ötlet
  is lehet
• Ha a jegyei közt van olyan, ami nem ötös, akkor
  nem kituno.
• Ha minden jegye ötös, akkor kituno.
• Vizsgáljuk meg eloször az elso ötletet
  közelebbrol!
• Nézzük végig a jegyeket, eloször az elsot, majd
  sorra a többit, és ellenorizzuk, hogy ötös-e.
• Ha találtunk olyat, ami nem ötös, akkor nem kell
  megnézni a további jegyeket, mert van nem ötös
  osztályzat, azaz nem kituno.

34
Az 1. számú pszeudokód

• VÁLTOZÓK tantárgy_szám, i, jegyeki EGÉSZ,
• van_nemotos LOGIKAI
• i ? 1    
• ISMÉTELD HA(i tantárgy_szám) és (jegyeki
  egyenlo 5-tel)
• i ? i1
• van_nemotos ?(i tantárgy_szám)
• HA (van_nemotos) AKKOR KIIR(nem kituno)
• EGYÉBKÉNT KIIR(kituno)

Végignézem a jegyeket. Az elsovel kezdem.
ellenorizzük a többit is, hogy ötös-e.
35
Második ötlet

• Nézzük végig a jegyeket, eloször az elsot,majd
  sorra a többit, és ellenorizzük, hogy ötös-e. Ha
  a tömb minden elemét megvizsgáltuk, akkor minden
  érdemjegy ötös, azaz kituno.

• VÁLTOZÓK tantárgy_szám, i, jegyeki EGÉSZ,
  mind_otos LOGIKAI
• i ? 1    
• ISMÉTELD HA(i tantárgy_szám) és (jegyeki
  egyenlo 5) i ? i1
• mind_otos ?(i gt tantárgy_szám)  
• HA(mind_otos) AKKOR KIIR(kituno) EGYÉBKÉNT
  KIIR(nem kituno)

36
Kiválasztás

• Egy tankör zárthelyi dolgozatai közül válasszuk
  ki az egyik elégséges dolgozatot. Megoldás
  nézzük végig a dolgozatokat,
• eloször az elsot, majd sorra a többit, amíg nem
  találunk elégséges dolgozatot.
• Amikor megtaláltunk egy elégségest, akkor o lesz
  a kiválasztott.

37
Pszeudokód

• VÁLTOZÓK i, sorsz, dolg_szama, dolgozatoki
  EGÉSZ
• i ? 1    
• ISMÉTELD HA ( (i dolg_szama) és (dolgozatoki
  ? 2) )
• i ? i 1
• sorsz ? i    // Ha találtunk elégségest, az lesz
  a megoldás.
• HA(i lt dolg_szama) AKKOR KIIR(i)
• EGYÉBKÉNT KIIR ("nincs elégséges")
• Hasonlít az eldöntéshez, de más a konklúzió!

38
Keresés

• Ismerjük egy üzlet januári napi bevételeit.
  Adjunk meg egy olyan napot -ha van-, amikor a
  bevétel több volt, mint 20,000 Ft. Megoldás
• Nézzük végig a bevételeket,
• eloször az elsot,
• majd sorra a többit,
• amíg nem találunk 20,000 Ft-nál nagyobbat.
• Ha találtunk ilyet,
• akkor van megoldás, és a megoldás a megtalált
  bevétel sorszáma
• különben nincs megoldás

39
Input adatok generálása

• Töltsük fel véletlen egészekkel a január tömb
  elemeit.
• (Ezt most még nem kell megérteni, a félév végére
  világos lesz.)
• int januar new int 32 // 0-tól indul, a
  32. lesz jan. 31 !
• Random RandomClass new Random()
• for(int i 1i lt31 i) januari
  RandomClass.Next(10,30)

• 18 26 28 12 . Január 1, 2, 3, 4, 5, .
  Bevételei rendre ezer forintban, akkor január
  3.-át kell megtalálnunk.
• Persze az is lehet, hogy a bevétel egyetlen napon
  sem haladja meg a 20 ezer forintot.
• A for ciklust fogjuk részletesen taglalni

40
A kód (a while ciklust fogjuk részletesen
taglalni)

• int i 1
• while (januari lt 20) i Console.Write(janua
  ri " ")
• Ez akkor nem jó, ha nincs megoldás, azaz jan.
  31.-én (i32)
• Is a bevétel kisebb, mint 20. Mitol állna meg a
  ciklus?

Ha a napokszama 31, akkor i 1 while (
(iltnapokszama) (januari lt 20)) i if (i
gt napokszama) Console.WriteLine("NINCS
megoldas") else Console.Write(i "dik nap!
")
41
Megszámolás

• Az elozo feladatot kicsit módosítjuk. Számoljuk
  meg, hány napon (ha egyáltalán) volt az üzlet
  bevétele 20 ezer forintnál nagyobb?

42
Megszámolás kódja

• int darab 0
• for (i 1 i lt napokszama i)
• if (januari gt 20) darab
• Console.WriteLine("a nagyobb bevételek száma "
  darab)

43
Maximum-kiválasztás

• Tegnap este a térképet nézegettem. Kiírtam
  magamnak 20 magas hegy tengerszint feletti
  magasságát. Adjuk meg az egyik legmagasabb
  csúcsot! Megoldás
• Megjegyzem az elso hegy magasságát. Ezt tekintem
  a legmagasabbnak.
• A többi hegyet sorra végignézem
• Ha valamelyik magasabb, mint az eddigi
  legmagasabb, akkor az eddigi legmagasabbat
  elfelejtem, és az újat jegyzem meg.
• A végén pont az elso legmagasabb hegyet jegyeztük
  meg.

44
Maximum-kiválasztás pszeudokódja 1

• int hegyekszama 10
• int magas new int hegyekszama1
• // mert 1-tol indexelünk
• int i
• Random RandomClass new Random()
• for (i 1 i lt hegyekszama i)
• magasi RandomClass.Next(10,
  26)
• Console.Write(magasi" ")

45
Maximum-kiválasztás pszeudokódja 2

• int max magas1 int eddigi 1
• for (i 1 i lt hegyekszama i)
• if (magasi gt max) max
  magasi eddigi i
• Console.WriteLine("az (egyik) legmagasabb
  sorszáma "eddigi" magassag "max)
• // magas tartalmát 1-tol kezeljük
• // Ha mondjuk a 2. hegy és a 7. hegy ugyanolyan
  magas,
• // és a többi mind kisebb, az eredmény 2 lesz
  vagy 7?
• // 2 lesz. Azonban ha gt helyett gt kerül be,
  akkor 7.

46
Egyszeru változók (OOP gyakorlatokon részletezzük)
C típus .Net Framework (System) típus Elo-jeles? Elfoglalt bájtok Lehetséges értékek
sbyte System.Sbyte Igen 1 -128 to 127
short System.Int16 Igen 2 -32768 to 32767
int System.Int32 Igen 4 -2147483648 to 2147483647
long System.Int64 Igen 8 -9223372036854775808 to 9223372036854775807
byte System.Byte Nem 1 0 to 255
ushort System.Uint16 Nem 2 0 to 65535
uint System.UInt32 Nem 4 0 to 4294967295
ulong System.Uint64 Nem 8 0 to 18446744073709551615
float System.Single Igen 4 Approximately 1.5 x 10-45 to 3.4 x 1038 with 7 significant figures
double System.Double Igen 8 Approximately 5.0 x 10-324 to 1.7 x 10308 with 15 or 16 significant figures
decimal System.Decimal Igen 12 Approximately 1.0 x 10-28 to 7.9 x 1028 with 28 or 29 significant figures
char System.Char --- 2 Any Unicode character (16 bit)
bool System.Boolean --- 1 / 2 true or false
47
Példák

• int x 10 // deklarálás kezdeti
  értékadássalint y xy 20 // x értéke 10 és
  y értéke 20
• float v2.34 double w

48
Adatkonverziók

• A konverzió C -ban lehet implicit vagy explicit.
  Ha az átalakítás automatikus, akkor implicit
  konverzióról beszélünk, ilyenkor nincs
  adatvesztés. Az explicit konverzió
  kikényszerített, ilyenkor elofordulhat
  adatvesztés.
• Konverzió leggyakrabban függvényhívás
  paraméter-átadásakor történik (késobb látunk majd
  példákat), vagy kevert típusú adatokkal való
  numerikus számítások esetén.

49
A nyilak mutatják az implicit konverziós
lehetoségeket (referencia táblázat)
50
Implicit numerikus konverzió

• long x1
• int y1 25
• x1 y1 // implicit numerikus konverzió int
  -gtlong
• Console.WriteLine(x1)

int x1 long y1 25 x1 y1 // long -gt int
nyíl nincs, mi lesz ? // HIBAÜZENET NEM
LÉTEZO implicit konverzió! // OK mert esetleges
adatvesztés lehetséges!
51
Megoldás kasztolással (explicit)

• int x1, x2
• long y1 2147483647, y2 21474836470
• //y1 belefér int-be, y2 nem fér bele
• x1 (int)y1 x2 (int)y2 // (int) kasztolás
• Console.WriteLine(x1" "x2)
• // x1 2147483647, x2 -10
• // x2 esetében adatvesztés történt

52
Egész-osztás vagy valós osztás?

• int i 13, j 7 // mindkét argumentum
  eredetileg egész
• int k i / j Console.WriteLine(k)
  // KIIR 1
• float k1 i / j Console.WriteLine(k1)
  // KIIR 1
• float k2 (float) i / j Console.WriteLine(k2)
  // 1.857143
• // (float) i / (float) j vagy i /
  (float) j is jó!
• Console.WriteLine( 55 / 7)
  // 7
• Console.WriteLine(55.0 / 7)
  // 7.8571...

53
Osztás folytatása

• int j 7 float i2 13, f // 13 egész
  típusú, átalakul valóssá
• f i2 / j
• Console.WriteLine(f) // f 1.85..

double i1 13.15 int j 7 // i1
duplapontos, nem egészértéku Console.WriteLine(i1/
j) // 1.87...
float i2 13.15 // 13.15 double, nem tud
floattá alakulni, HIBA! int j 7
Console.WriteLine((int) i2 / j)
float i2 13.15F // 13.15F valós konstans int
j 7 Console.WriteLine((int) i2 / j) // 1-t
fog kiírni
54
Duplapontos változó konvertálása egészre
adatvesztéssel

• double i2 13.83
• Console.WriteLine( (int) i2 ) // 13

Példa logikai kifejezésre int a 7 bool log
log a 2 0 // log (a 2
0) if (log) Console.WriteLine("
paros") else Console.WriteLine("parat
lan")
55
String -gt numerikus (egész) érték
string sz "123" int sz1 Int32.Parse(sz)
// így is lehet int sz2 Convert.ToInt32(sz)
// vagy akár így is lehet
56
String -gt numerikus (valós) érték

• string myDoubleStr "-12,2"
• double x Double.Parse(myDoubleStr) 5.3
• double y Convert.ToDouble(myDoubleStr) 1.1
• Console.WriteLine(x) // -6,9
• Console.WriteLine(y) // -11,1

Érdemes a tizedespont illetve a vesszo
használatára figyelni.
A stringek részletes tárgyalása az IMOP
gyakorlatokon történik!!
57
Elöltesztelo és hátultesztelo ciklus 1.
Vissza

• int a 0
• while (a lt 3) Console.WriteLine(a)
• a
• // a0 indulással kiírja a 0, 1, 2 számokat

int a 0 do Console.WriteLine(a)
a while(a lt 3) // a0 indulással ugyanúgy,
mint a zöld kód, kiírja a 0,1,2-t
Nem olyan, mint a repeat Delphiben!
58
Elöltesztelo és hátultesztelo ciklus 2.

• int a 5
• while (a lt 3) Console.WriteLine(a)
• a
• // ha a5 induláskor, akkor egyszer sem hajtódik
  végre

int a 5 do Console.WriteLine(a)
a while(a lt 3) // ha induláskor a5 akkor
kiírja az 5-t, egyszer végrehajtódik, többször nem
Nem olyan, mint a repeat Delphiben!
59
For ciklus

• for (int a 0 a lt 5 a) // 0, 1, 2, 3, 4
  kiírása
• Console.WriteLine(a)
• // Nem hajtódik végre a ciklusmag a következo
  esetben
• for (int a 6 a lt 5 a)
• Console.WriteLine(a)
• // 0, 2, 4 íródik ki a következo esetben (ámbár
  nem ajánlott
• // ciklusváltozót egyszerre két helyen
  változtatni!)
• for (int a 0 a lt 5 a)
• Console.WriteLine(a)

60
Függvények használata érték visszaadása nélkül

• public static void change(int b) // void szerepe
  !!
• b 5
• static void Main()
• int a 0
• change(a)
• Console.WriteLine(a) // hívás után
  is a0 marad

61
Egy érték visszaadása a metódus nevében

• public static int change(int b) // int szerepe
  !!
• b 5
• return b
• static void Main()
• int a 0 int c
• c change(a)
• Console.WriteLine(c) // c5 lesz

62
Paraméterátadás ref segítségével

• public static void change(ref int b)
• b 5
• static void Main()
• int a 0 // ha hívás elott a nem
  kapna értéket, az hiba!
• change(ref a)
• Console.WriteLine(a) // a5

63
Paraméterátadás out segítségével

• public static void change(out int b)
• b 5
• static void Main()
• int a // 0 nem muszáj, hogy a
  értéket kapjon!
• change(out a)
• // a5, még akkor is, ha az elozo sorban a
  értéket kapna
• Console.WriteLine(a)

64
Egydimenziós tömb

• int itomb // deklarálás
• itomb new int3 0, 1, 2 // inicializálás
• for (int i 0 i lt itomb.Length i)
  Console.WriteLine(itombi)

• int itomb new int3 0, 1, 2
• // a deklarálás és az inicializálás össze is
  vonható

65
Egydimenziós tömb átlaga

• public static double atlag(double vektor)
• double s 0.0
• for (int i 0 i lt vektor.Length
  i) s vektori
• return s/vektor.Length
• public static void Main()
• double tomb new double -4.11,
  1.23, 2.14
• Console.WriteLine(atlag(tomb)) // -
  0,246..
• Console.ReadKey() // várakozás

66
Írjunk egy függvényt, amely nullára cseréli egy
tömb ama elemeit, melyek abszolút értéke egy
paraméternél nagyobb

• public static double atl_csere (ref double
  vektor, double eps)
• double s 0.0
• for (int i 0 i lt vektor.Length i) s
  vektori
• s s/vektor.Length // átlagszámítás
• for (int i 0 i lt vektor.Length i) //
  csere, ha kell
• if ((vektori gteps) (vektori lt -
  eps)) vektori 0
• return s // a régi átlag visszaadása

67
és a foprogram

• public static void Main()
• double tomb double eps 5.1
• tomb new double -4.11, 1.23, 20.14
• Console.WriteLine(atl_csere(ref tomb,5))
• for (int i 0 i lt tomb.Length i)
  Console.WriteLine( tombi) // új tömb
• Console.ReadKey() // várakozás

A tömbök tárgyalására visszatérünk!
68
Nem-egydimenziós tömbök

• A nem-egydimenziós tömbökkel a késobbiekben
  részletesen fogunk foglalkozni!