Programozsi alapok 2 Hogyan gyakoroljunk otthon Visual Studio

Programozási alapok 2.

Hogyan gyakoroljunk otthon? • Visual Studio, MSDNAA • Monodevelop (Unity-hez jár) • Online fordítók • http: //rextester. com/runcode • http: //volatileread. com/Utility. Library/Snippet. Compiler • https: //dotnetfiddle. net/ – talán ez a legjobb

Új program Fordítás+futtatás Forráskód helye Konzol, a bemenetet „>” után kéri be

Gyakoroljunk együtt!

Visual Studio projektek • Egy solution-höz több projekt is tartozhat • Startup projekt: amelyik futtatáskor elindul

Feladat: Kő papír olló • Rock. Paper. Scissors. Basic projekt, Program. cs • 1. Feladat: írjuk meg a figura beolvasását! • 2. Feladat: nézzük meg, ki nyert! • 3. Feladat: lehessen kilépni a játékból!

Programkonstrukciók (4): alprogramok • A programozó lusta, nem szereti ugyanazt kétszer leírni • Alprogram: programrészlet, aminek külön neve van, erre hivatkozva lehet az alprogramot meghívni. • Láttunk már ilyet, pl: Console. Write. Line(Mit írjon ki) • Ugyanilyen maga a Main program is • Átláthatóbb a kód: bonyolult műveletek helyett egyetlen, kifejező sor • Lehet paraméterezni is, az alprogram ugyanazt a viselkedést valósítja meg (azaz valamilyen részproblémát old meg) más-más paraméterekkel

Alprogram szintaxis Ez most nem érdekes… Visszatérési érték típusa Mint a változók: típus név, típus név… módosítók típus alprogramnév(paraméterek) { Utasítás_1; Utasítás_2; Alprogram „törzse”, … a működést megvalósító } programkód

Alprogram példák void print(string s) { Console. Write. Line(s); } • void: speciális visszatérési érték. Az alprogram valamit csinál, de nem ad vissza „végeredményt” int add(int a, int b) { return a+b; } • Függvénynek nevezzük az olyan alprogramokat, amelyek valamilyen értéket számolnak ki. A végeredményt a return kulcsszóval jelezzük. void add_2(int a, int b, out int result) { result = a+b; } • lehetnek kimenő (out) paraméterek is, ezeket az alprogram állítja elő • így tudunk pl. több értéket visszaadni

Alprogram meghívása print("Hello World!"); int i = add(2, 5); i = add(i, 2*i); add_2(3, 42*52, out i); • Ekvivalens azzal, mintha az alprogramot bemásolnánk ide, és a paraméterek helyére beírnánk az átadott értékeket • Itt az i változó kimenő, azaz a program által számolt érték • Ezt az out kulcsszóval kell jeleznünk

Első alprogramom (1. feladat) • Rock. Paper. Scissors. Subprogram projekt • Írjunk alprogramot, ami beolvas egy kő papír olló figurát! • Adja vissza, hogy a beolvasott érték érvényes-e és a beolvasott értéket is! static bool read. Figure(string message, out string figure) { Console. Write. Line(message); figure = Console. Read. Line(); if ("ko" == figure || "papir" == figure || "ollo" == figure) { return true; } return false; }

Első alprogramom: felhasználási példa static void Main(string[] args) { bool new. Game = true; Random rnd = new Random(); while (new. Game) { Console. Clear(); string player. Figure. String; while (!read. Figure("Mit mutatsz? ", out player. Figure. String)) { Console. Write. Line("Ervenyes figurak: ko, papir, ollo"); } //. . .

Feladat: kő papír olló, alprogram • 2. Feladat: írjunk alprogramot, ami a véletlenszerűen generált számból stringet csinál!

Programkonstrukciók (2. 5): választás (switch) if (változó == érték_1) { Utasításblokk_1; } else if (változó == érték_2) { Utasításblokk_2; } else if (változó == érték_3) { Utasításblokk_3; } // … else { Egyébként_ág; } switch (változó) { case érték_1: Utasításblokk_1; break; case érték_2: Utasításblokk_2; break; case érték_3: Utasításblokk_3; break; default: Egyébként_ág; }

Programkonstrukciók (2. 5): választás (switch) • default (általában) nem kötelező • De mindig ajánlott kiírni egy üres default ágat • A változó csak elemi típus lehet • bool, char, string, int, … • break helyett állhat: • return (alprogramból visszatérés) • goto case érték_i (másik címkére ugrás) • (throw – ez most nem érdekes…) switch (változó) { case érték_1: Utasításblokk_1; break; case érték_2: Utasításblokk_2; break; case érték_3: Utasításblokk_3; break; default: Egyébként_ág; }

Feladat: kő papír olló, switch • 3. Feladat: írjunk switch-case szerkezetet, ami a nyertes alapján kiírja az eredményt! • • A nyertest a winner függvény adja vissza, egész számként -1: az első játékos nyert (ami most a felhasználó) 0: döntetlen 1: a második játékos nyert (ami most a gépi játékos)

Adatszerkezetek • Az algoritmustervezés legfontosabb eszközeinek egyike • Sok egyforma (vagy hasonló) dolgot szeretnénk rendezett formában tárolni • Rengeteg fajtája van, az optimális választás attól függ, hogy az adatszerkezetben tárolt adatokkal mit szeretnénk kezdeni • Felhasználási példák: • Gyors keresés • telefonkönyv • Gyors beszúrás • jegyzettömb • Sorrendiség • ki volt itt előbb? • Szomszédsági viszony • határos országok • Térbeli elrendezés • legközelebbi rakétavető

Tömb (1 D) • Azonos típusú elemek számozott listája Tömb (6 -os indexű) eleme Első index (nullától!!!) 0 1 2 3 4 5 6 7 Indexek (elemek sorszáma) 2 5 3 9 2 1 8 1 Tömb elemei Tömb hossza (mérete) 8

Tömb (1 D) a programban int[] numbers; deklaráció (név létrehozás) int[] numbers = new int[6]; tömb létrehozás int[] numbers = new int[6] { 2, 1, 5, 4, 2, 7 }; int[] numbers = { 2, 1, 5, 4, 2, 7 }; ? ? ? numbers 2 1 5 4 2 7 létrehozás és inicializáció 0 1 2 3 4 5

Tömb (1 D) a programban numbers[3] = 9; numbers[6] = 0; // futási idejű hiba! ? ? ? numbers 2 1 5 49 2 7 0 1 2 3 4 5

Tömbök bejárása • Nagyon gyakran előjövő feladatok: • A tömb minden elemére végezzünk el valami műveletet • Keressünk a tömbben • Tömb bejárás string[] array = {"alma", "dio", "mogyoro"}; for (int i = 0; i < array. Length; ++i) { Console. Write. Line(array[i]); } • foreach: Speciális for ciklus adatszerkezetek bejárására // pontosan ugyanazt csinálja, mint az előző ciklus foreach (string s in array) { Console. Write. Line(s); }

Feladat: Kő papír olló, tömbökkel • Hány helyen kell átírni az előző programot, ha más nevet szeretnék a figuráknak? • Használjunk tömböket a figuranevek tárolására! • Máshol ne forduljon elő a figurák neve static string[] Figure. Strings = { "ko", "papir", "ollo" }; static string int. To. Figure(int i) { if (0 <= i && i < Figure. Strings. Length) return figures[i]; return ""; }

Konstansok • Motiváció: a kő papír olló programban észben kell tartanunk, hogy melyik indexhez milyen figura tartozott. • 1. változat: definiáljunk nekik konstansokat const int ROCK = 0; const int PAPER = 1; const int SCISSORS = 2; • A konstansok típussal rendelkező, névvel azonosított értékek (mint a változók), amelyek értéke a program során nem változhat const int ROCK = 0; ROCK = 2; // fordítási hiba! • Tipikusan előre beégetett értékeket szoktunk megadni velük

Felsorolási típus • Motiváció: a kő papír olló programban észben kell tartanunk, hogy melyik indexhez milyen figura tartozott. • 2. (szebb) változat: definiáljunk nekik saját felsorolási típust • Emlékeztető: a típus meghatározza többek között, hogy a változók milyen értékeket vehetnek fel enum Figures {ROCK = 0, PAPER, SCISSORS}; • A felvehető értékeket mi soroljuk fel, név szerint • Számmá tudjuk őket konvertálni, explicit konverzióval int i = (int)Figures. ROCK; // C#: típusnév. érték • A felsorolt értékeknek megfelelő számot egyenlőség jel után megadhatjuk • Alapból 0 -tól kezdődik, egyesével nő

Felsorolási típus: bejárás • Összes érték bejárására speciális konstrukció: foreach • (Az Enum. Get. Values egy tömböt ad vissza a lehetséges értékekkel, ezt járja be a foreach) foreach (int i in Enum. Get. Values(typeof(Figures))) { Console. Write(Figure. Strings[i] + " "); } foreach (Figures f in Enum. Get. Values(typeof(Figures))) { Console. Write(Figure. Strings[(int)f] + " "); }

Feladat: kő papír olló, enum • Definiáljunk enum típust a figurákhoz • Indexeljük ezzel a figurák neveit tartalmazó tömbünket mindenhol a kódban!

Tömb (2 D) 0 0 1 3 3 4 5 A[0, 0] 1 2 2 A[1, 3] A[2, 1] A[3, 5]

Tömb (2 D) a programban int[, ] two. Dim. Array = new int[3, 2] { { 7, 2 }, { 1, 4 }, { 5, 9 } }; 1 0 ahány vessző, annyi+1 dimenziós dimenziók méretei 0 1 2 7 2 1 4 5 9 2 3

2 D tömb bejárása • Összes elem, egyszerre: foreach (int i in two. Dim. Array) { Console. Write. Line(i); } • Dimenziónként: for (int row = 0; row < two. Dim. Array. Get. Length(0); ++row) { for (int col = 0; col < two. Dim. Array. Get. Length(1); ++col) { Console. Write. Line(two. Dim. Array[row, col]); } } • HF: mi történik, ha a két for-t megcseréljük?

Kép mint 2 D tömb

2 D tömb a játékokban

3 D tömb a játékokban

Feladat: Pacman alapprogram • Pacman solution, Pacman 01 -2 DArray projekt • 1. feladat: rajzoljuk a ki a pályát • Már tárolva van egy 2 D tömbben • 2. feladat: pontszámmegjelenítés

Objektum Orientált Programozás • Programozási paradigma • A legtöbb programban logikailag valamilyen nem elemi típusú „objektumon” dolgozunk • Szörny, rakétavető, képernyő, bemeneti fájl … • Ezekhez létrehozhatunk saját típus: osztály • Attribútumok (tulajdonságok) • Objektumokon végezhető műveletek

Osztály, mint „összetett típus” class Hi. Score { // public: láthatóság kifelé (ld. Később) public string player. Name; public int score; public Date. Time date; attribútum vagy property // további adatok, pl. játszott faj stb. } példányosítás //. . . Használat: player. Name Hi. Score hiscore = new Hi. Score(); score hiscore = 5; date hiscore. player. Name = "Lajos"; hiscore Lajos 5 …

Osztály, mint típus saját műveletekkel class My. Integer { public My. Integer(int value) { this. value = value; } konstruktor public void negate() { value = -value; } public void print() { metódusok / tagfüggvények static void Main(string[] args) { My. Integer m = new My. Integer(5); Console. Write. Line(value); m. print(); } m. negate(); int value; } m. print(); }

Házi feladat: Legyen Ön is milliomos • Tipp: kérdés osztály • Kérdés szövege • Lehetséges válaszok (4 elemű tömb) • Helyes válasz sorszáma • A játék menete: • Amíg a játékos ki nem lép, kiírunk 1 -1 kérdést és a lehetséges válaszokat • Bekérjük a játékos tippjét • Ha jó a válasz, ugrunk a következő nyereményszintre • Különben game over

Pacman V 2 • Van már Vec 2 osztály • Game. Object osztály class Game. Object { public enum GO_Type { WALL, HERO, ENEMY, COIN } public virtual void draw() { //TODO } } public GO_Type m. Type; public Vec 2 position = new Vec 2(); public Vec 2 move = new Vec 2(); public int score = 0;

Player funkciói class Game. Object { … public void update() { if (m. Type == GO_Type. HERO) { if (System. Console. Key. Available) { Console. Key. Info keyinfo = System. Console. Read. Key(true); move. set. Null(); if (keyinfo. Key == Console. Key. Left. Arrow) move. x = -1; if (keyinfo. Key == Console. Key. Right. Arrow) move. x = 1; if (keyinfo. Key == Console. Key. Up. Arrow) move. y = -1; if (keyinfo. Key == Console. Key. Down. Arrow) move. y = 1; if (keyinfo. Key == Console. Key. Escape) System. Environment. Exit(0); } } }

Player funkciói II. class Game. Object { … public void allow. Move() { System. Console. Set. Cursor. Position(position. x, position. y + 1); System. Console. Write(" "); position = position. add(move); move. set. Null(); draw(); } public void cancel. Move() { move. set. Null(); }

Main loop //draw level … System. Console. Set. Cursor. Position(0, 0); System. Console. Write("Score: 0"); . . következő dia jön ide

while (true){ for (int i = 0; i < cols; ++i) { for (int j = 0; j < rows; ++j) { if(map[j][i] != null) map[j][i]. update(); if(map[j][i] == player) { if (!player. move. is. Null()) { Vec 2 next. Position = player. position. add(player. move); Game. Object obj = map[next. Position. y][next. Position. x]; if (obj. m. Type != Game. Object. GO_Type. WALL) { if (obj. m. Type == Game. Object. GO_Type. COIN) { player. score++; map[next. Position. y][next. Position. x] = null; draw. GUI(); } else if (obj. m. Type == Game. Object. GO_Type. ENEMY) { player = null; draw. GUI(); } player. allow. Move(); map[player. position. y][player. position. x] = player; } else player. cancel. Move(); } } }

GUI rajzolás class Game { void draw. GUI() { if(player == null) { System. Console. Set. Cursor. Position(0, 0); System. Console. Write("GAME OVER"); System. Threading. Thread. Sleep(3000); System. Environment. Exit(0); } System. Console. Set. Cursor. Position(0, 0); System. Console. Write("Score: " + player. score); }

Öröklődés Játékobjektum Fal Specializáció Játékos Szörny Vámpír Sárkány

Öröklődés példa class Vec 2 {/*. . . */}; public class Game. Object { public void draw() { /*. . . */ } public void move() { /*. . . */ } Vec 2 position; int ID; //. . . } public class Monster : Game. Object { // örököltük a metódusokat // örököltük a koordinátát, ID-t stb. }

Absztrakt osztály class Vec 2 {/*. . . */}; public class Game. Object { public void draw() { /*. . . */ } public void move() { /*. . . */ } Vec 2 position; int ID; //. . . } public class Monster : Game. Object { // örököltük a metódusokat // örököltük a koordinátát, ID-t stb. } Hogyan mozog egy „általános” játékobjektum? ? ?

Absztrakt osztály class Vec 2 {/*. . . */}; public abstract class Game. Object { public abstract void draw(); public abstract void move(); Vec 2 position; Nem írunk hozzá törzset, majd a speciális esetek implementálják külön-külön int ID; //. . . } public class Monster : Game. Object { // felülírjuk az örökölt metódusok viselkedését public override void draw() { /*. . . */ } public override void move() { /*. . . */ } // örököltük a koordinátát, ID-t stb. } A konkrét, nem absztrakt leszármazottak már definiálják a viselkedést

Pacman V 3 • Öröklődés • Game loop

Pacman modell